commit 2578f76c9dc0bfedf7fff397179c661044f666f4 · kitten.sh/wonka

+52

src/__tests__/operators.test.ts

···

       506
       506
        
           expect(fnB).toHaveBeenCalledWith([0]);

     

       507
       507
        
           expect(fnA.mock.calls[0][0]).toBe(fnB.mock.calls[0][0]);

     

       508
       508
        
         });

     

       509
       509
       +
       

     

       510
       510
       +
         it('completes the source when no more sink is listening', () => {

     

       511
       511
       +
           let onPush = () => {};

     

       512
       512
       +
       

     

       513
       513
       +
           const talkback = vi.fn();

     

       514
       514
       +
           const source: Source<any> = operators.share(sink => {

     

       515
       515
       +
             sink(start(talkback));

     

       516
       516
       +
             onPush = () => {

     

       517
       517
       +
               sink(push([0]));

     

       518
       518
       +
               sink(push([1]));

     

       519
       519
       +
               sink(SignalKind.End);

     

       520
       520
       +
             };

     

       521
       521
       +
           });

     

       522
       522
       +
       

     

       523
       523
       +
           const fnA = vi.fn();

     

       524
       524
       +
           const fnB = vi.fn();

     

       525
       525
       +
       

     

       526
       526
       +
           sinks.forEach(fnA)(operators.take(1)(source));

     

       527
       527
       +
           sinks.forEach(fnB)(operators.take(1)(source));

     

       528
       528
       +
           onPush();

     

       529
       529
       +
       

     

       530
       530
       +
           expect(fnA).toHaveBeenCalledWith([0]);

     

       531
       531
       +
           expect(fnB).toHaveBeenCalledWith([0]);

     

       532
       532
       +
           expect(fnA.mock.calls[0][0]).toBe(fnB.mock.calls[0][0]);

     

       533
       533
       +
           expect(talkback).toHaveBeenCalledWith(TalkbackKind.Close);

     

       534
       534
       +
         });

     

       509
       535
        
       });

     

       510
       536
        
       

     

       511
       537
        
       describe('skip', () => {

     
···

       696
       722
        
           notify(null);

     

       697
       723
        
           expect(fn).toHaveBeenCalledTimes(3);

     

       698
       724
        
           expect(fn.mock.calls[2][0]).toEqual(SignalKind.End);

     

       725
       725
       +
         });

     

       726
       726
       +
       

     

       727
       727
       +
         it('emits values until a notifier emits', () => {

     

       728
       728
       +
           const { source: input$, next } = sources.makeSubject<number>();

     

       729
       729
       +
           const fn = vi.fn();

     

       730
       730
       +
       

     

       731
       731
       +
           let hasClosed = false;

     

       732
       732
       +
       

     

       733
       733
       +
           operators.takeUntil(sink => {

     

       734
       734
       +
             sink(

     

       735
       735
       +
               start(talkback => {

     

       736
       736
       +
                 if (talkback === TalkbackKind.Close) {

     

       737
       737
       +
                   hasClosed = true;

     

       738
       738
       +
                 } else if (talkback === TalkbackKind.Pull && !hasClosed) {

     

       739
       739
       +
                   sink(push(1));

     

       740
       740
       +
                 }

     

       741
       741
       +
               })

     

       742
       742
       +
             );

     

       743
       743
       +
           })(input$)(fn);

     

       744
       744
       +
       

     

       745
       745
       +
           next(1);

     

       746
       746
       +
       

     

       747
       747
       +
           expect(fn).toHaveBeenCalledTimes(2);

     

       748
       748
       +
           expect(fn.mock.calls).toEqual([[0], [start(expect.any(Function))]]);

     

       749
       749
       +
       

     

       750
       750
       +
           expect(hasClosed).toBe(true);

     

       699
       751
        
         });

     

       700
       752
        
       });

     

       701
       753

src/operators.ts

···

       710
       710
        
                   (notifierTalkback = signal[0])(TalkbackKind.Pull);

     

       711
       711
        
                 } else {

     

       712
       712
        
                   ended = true;

     

       713
       713
       +
                   notifierTalkback(TalkbackKind.Close);

     

       713
       714
        
                   sourceTalkback(TalkbackKind.Close);

     

       714
       715
        
                   sink(SignalKind.End);

     

       715
       716
        
                 }