···

       
256
       
 
       


     

       
257
       
 
       
export function mergeMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       
258
       
 
       
  return source => sink => {

     

       
259
       
-
       
    const innerTalkbacks: TalkbackFn[] = [];

     

       
260
       
 
       
    let outerTalkback = talkbackPlaceholder;

     

       
261
       
 
       
    let outerPulled = false;

     

       
262
       
 
       
    let ended = false;

     
···

       
266
       
 
       
        if (signal === SignalKind.End) {

     

       
267
       
 
       
          if (innerTalkbacks.length) {

     

       
268
       
 
       
            const index = innerTalkbacks.indexOf(talkback);

     

       
269
       
-
       
            if (index > -1) innerTalkbacks.splice(index, 1);

     

       
270
       
 
       
            if (!innerTalkbacks.length) {

     

       
271
       
 
       
              if (ended) {

     

       
272
       
 
       
                sink(SignalKind.End);

     
···

       
309
       
 
       
            ended = true;

     

       
310
       
 
       
            outerTalkback(TalkbackKind.Close);

     

       
311
       
 
       
          }

     

       
312
       
-
       
          while (innerTalkbacks.length) innerTalkbacks.shift()!(TalkbackKind.Close);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
313
       
 
       
        } else {

     

       
314
       
 
       
          if (!ended && !outerPulled) {

     

       
315
       
 
       
            outerPulled = true;

     
···

       
317
       
 
       
          } else {

     

       
318
       
 
       
            outerPulled = false;

     

       
319
       
 
       
          }

     

       
320
       
-
       
          for (let i = 0; i < innerTalkbacks.length; i++) innerTalkbacks[i](TalkbackKind.Pull);

     

       
0
       
 
       

     

       
321
       
 
       
        }

     

       
322
       
 
       
      })

     

       
323
       
 
       
    );

     
···

       
475
       
 
       
}

     

       
476
       
 
       


     

       
477
       
 
       
export function share<T>(source: Source<T>): Source<T> {

     

       
478
       
-
       
  const sinks: Sink<T>[] = [];

     

       
479
       
 
       
  let talkback = talkbackPlaceholder;

     

       
480
       
 
       
  let gotSignal = false;

     

       
481
       
 
       
  return sink => {

     
···

       
483
       
 
       
    if (sinks.length === 1) {

     

       
484
       
 
       
      source(signal => {

     

       
485
       
 
       
        if (signal === SignalKind.End) {

     

       
486
       
-
       
          while (sinks.length) sinks.pop()!(SignalKind.End);

     

       
0
       
 
       

     

       
487
       
 
       
        } else if (signal.tag === SignalKind.Start) {

     

       
488
       
 
       
          talkback = signal[0];

     

       
489
       
 
       
        } else {

     

       
490
       
 
       
          gotSignal = false;

     

       
491
       
-
       
          for (let i = 0; i < sinks.length; i++) sinks[i](signal);

     

       
492
       
 
       
        }

     

       
493
       
 
       
      });

     

       
494
       
 
       
    }

     
···

       
496
       
 
       
      start(signal => {

     

       
497
       
 
       
        if (signal === TalkbackKind.Close) {

     

       
498
       
 
       
          const index = sinks.indexOf(sink);

     

       
499
       
-
       
          if (index > -1) sinks.splice(index, 1);

     

       
500
       
 
       
          if (!sinks.length) talkback(TalkbackKind.Close);

     

       
501
       
 
       
        } else if (!gotSignal) {

     

       
502
       
 
       
          gotSignal = true;

     

···

       
256
       
 
       


     

       
257
       
 
       
export function mergeMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       
258
       
 
       
  return source => sink => {

     

       
259
       
+
       
    let innerTalkbacks: TalkbackFn[] = [];

     

       
260
       
 
       
    let outerTalkback = talkbackPlaceholder;

     

       
261
       
 
       
    let outerPulled = false;

     

       
262
       
 
       
    let ended = false;

     
···

       
266
       
 
       
        if (signal === SignalKind.End) {

     

       
267
       
 
       
          if (innerTalkbacks.length) {

     

       
268
       
 
       
            const index = innerTalkbacks.indexOf(talkback);

     

       
269
       
+
       
            if (index > -1) (innerTalkbacks = innerTalkbacks.slice()).splice(index, 1);

     

       
270
       
 
       
            if (!innerTalkbacks.length) {

     

       
271
       
 
       
              if (ended) {

     

       
272
       
 
       
                sink(SignalKind.End);

     
···

       
309
       
 
       
            ended = true;

     

       
310
       
 
       
            outerTalkback(TalkbackKind.Close);

     

       
311
       
 
       
          }

     

       
312
       
+
       
          for (let i = 0, a = innerTalkbacks, l = innerTalkbacks.length; i < l; i++)

     

       
313
       
+
       
            a[i](TalkbackKind.Close);

     

       
314
       
+
       
          innerTalkbacks.length = 0;

     

       
315
       
 
       
        } else {

     

       
316
       
 
       
          if (!ended && !outerPulled) {

     

       
317
       
 
       
            outerPulled = true;

     
···

       
319
       
 
       
          } else {

     

       
320
       
 
       
            outerPulled = false;

     

       
321
       
 
       
          }

     

       
322
       
+
       
          for (let i = 0, a = innerTalkbacks, l = innerTalkbacks.length; i < l; i++)

     

       
323
       
+
       
            a[i](TalkbackKind.Pull);

     

       
324
       
 
       
        }

     

       
325
       
 
       
      })

     

       
326
       
 
       
    );

     
···

       
478
       
 
       
}

     

       
479
       
 
       


     

       
480
       
 
       
export function share<T>(source: Source<T>): Source<T> {

     

       
481
       
+
       
  let sinks: Sink<T>[] = [];

     

       
482
       
 
       
  let talkback = talkbackPlaceholder;

     

       
483
       
 
       
  let gotSignal = false;

     

       
484
       
 
       
  return sink => {

     
···

       
486
       
 
       
    if (sinks.length === 1) {

     

       
487
       
 
       
      source(signal => {

     

       
488
       
 
       
        if (signal === SignalKind.End) {

     

       
489
       
+
       
          for (let i = 0, a = sinks, l = sinks.length; i < l; i++) a[i](SignalKind.End);

     

       
490
       
+
       
          sinks.length = 0;

     

       
491
       
 
       
        } else if (signal.tag === SignalKind.Start) {

     

       
492
       
 
       
          talkback = signal[0];

     

       
493
       
 
       
        } else {

     

       
494
       
 
       
          gotSignal = false;

     

       
495
       
+
       
          for (let i = 0, a = sinks, l = sinks.length; i < l; i++) a[i](signal);

     

       
496
       
 
       
        }

     

       
497
       
 
       
      });

     

       
498
       
 
       
    }

     
···

       
500
       
 
       
      start(signal => {

     

       
501
       
 
       
        if (signal === TalkbackKind.Close) {

     

       
502
       
 
       
          const index = sinks.indexOf(sink);

     

       
503
       
+
       
          if (index > -1) (sinks = sinks.slice()).splice(index, 1);

     

       
504
       
 
       
          if (!sinks.length) talkback(TalkbackKind.Close);

     

       
505
       
 
       
        } else if (!gotSignal) {

     

       
506
       
 
       
          gotSignal = true;

     

···

       
73
       
 
       
}

     

       
74
       
 
       


     

       
75
       
 
       
export function makeSubject<T>(): Subject<T> {

     

       
76
       
-
       
  const sinks: Sink<T>[] = [];

     

       
77
       
 
       
  let ended = false;

     

       
78
       
 
       
  return {

     

       
79
       
 
       
    source(sink: Sink<T>) {

     
···

       
82
       
 
       
        start(signal => {

     

       
83
       
 
       
          if (signal === TalkbackKind.Close) {

     

       
84
       
 
       
            const index = sinks.indexOf(sink);

     

       
85
       
-
       
            if (index > -1) sinks.splice(index, 1);

     

       
86
       
 
       
          }

     

       
87
       
 
       
        })

     

       
88
       
 
       
      );

     
···

       
90
       
 
       
    next(value: T) {

     

       
91
       
 
       
      if (!ended) {

     

       
92
       
 
       
        const signal = push(value);

     

       
93
       
-
       
        for (let i = 0; i < sinks.length; i++) sinks[i](signal);

     

       
94
       
 
       
      }

     

       
95
       
 
       
    },

     

       
96
       
 
       
    complete() {

     

       
97
       
 
       
      if (!ended) {

     

       
98
       
 
       
        ended = true;

     

       
99
       
-
       
        for (let i = 0; i < sinks.length; i++) sinks[i](SignalKind.End);

     

       
100
       
 
       
      }

     

       
101
       
 
       
    },

     

       
102
       
 
       
  };

     

···

       
73
       
 
       
}

     

       
74
       
 
       


     

       
75
       
 
       
export function makeSubject<T>(): Subject<T> {

     

       
76
       
+
       
  let sinks: Sink<T>[] = [];

     

       
77
       
 
       
  let ended = false;

     

       
78
       
 
       
  return {

     

       
79
       
 
       
    source(sink: Sink<T>) {

     
···

       
82
       
 
       
        start(signal => {

     

       
83
       
 
       
          if (signal === TalkbackKind.Close) {

     

       
84
       
 
       
            const index = sinks.indexOf(sink);

     

       
85
       
+
       
            if (index > -1) (sinks = sinks.slice()).splice(index, 1);

     

       
86
       
 
       
          }

     

       
87
       
 
       
        })

     

       
88
       
 
       
      );

     
···

       
90
       
 
       
    next(value: T) {

     

       
91
       
 
       
      if (!ended) {

     

       
92
       
 
       
        const signal = push(value);

     

       
93
       
+
       
        for (let i = 0, a = sinks, l = sinks.length; i < l; i++) a[i](signal);

     

       
94
       
 
       
      }

     

       
95
       
 
       
    },

     

       
96
       
 
       
    complete() {

     

       
97
       
 
       
      if (!ended) {

     

       
98
       
 
       
        ended = true;

     

       
99
       
+
       
        for (let i = 0, a = sinks, l = sinks.length; i < l; i++) a[i](SignalKind.End);

     

       
100
       
 
       
      }

     

       
101
       
 
       
    },

     

       
102
       
 
       
  };