···

       
635
       
635
       
 
       
  );

     

       
636
       
636
       
 
       


     

       
637
       
637
       
 
       
type skipUntilStateT = {

     

       
638
       
638
       
-
       
  mutable skip: bool,

     

       
639
       
639
       
-
       
  mutable ended: bool,

     

       
640
       
640
       
-
       
  mutable gotSignal: bool,

     

       
641
       
638
       
 
       
  mutable sourceTalkback: (. talkbackT) => unit,

     

       
642
       
639
       
 
       
  mutable notifierTalkback: (. talkbackT) => unit,

     

       
640
       
640
       
+
       
  mutable skip: bool,

     

       
641
       
641
       
+
       
  mutable pulled: bool,

     

       
642
       
642
       
+
       
  mutable ended: bool,

     

       
643
       
643
       
 
       
};

     

       
644
       
644
       
 
       


     

       
645
       
645
       
 
       
[@genType]

     
···

       
647
       
647
       
 
       
  curry(source =>

     

       
648
       
648
       
 
       
    curry(sink => {

     

       
649
       
649
       
 
       
      let state: skipUntilStateT = {

     

       
650
       
650
       
-
       
        skip: true,

     

       
651
       
651
       
-
       
        ended: false,

     

       
652
       
652
       
-
       
        gotSignal: false,

     

       
653
       
650
       
 
       
        sourceTalkback: talkbackPlaceholder,

     

       
654
       
651
       
 
       
        notifierTalkback: talkbackPlaceholder,

     

       
652
       
652
       
+
       
        skip: true,

     

       
653
       
653
       
+
       
        pulled: false,

     

       
654
       
654
       
+
       
        ended: false,

     

       
655
       
655
       
 
       
      };

     

       
656
       
656
       
 
       


     

       
657
       
657
       
 
       
      source((. signal) =>

     
···

       
664
       
664
       
 
       
            | Start(innerTb) =>

     

       
665
       
665
       
 
       
              state.notifierTalkback = innerTb;

     

       
666
       
666
       
 
       
              innerTb(. Pull);

     

       
667
       
667
       
-
       
              tb(. Pull);

     

       
668
       
667
       
 
       
            | Push(_) =>

     

       
669
       
668
       
 
       
              state.skip = false;

     

       
670
       
669
       
 
       
              state.notifierTalkback(. Close);

     

       
670
       
670
       
+
       
            | End when state.skip =>

     

       
671
       
671
       
+
       
              state.ended = true;

     

       
672
       
672
       
+
       
              state.sourceTalkback(. Close);

     

       
671
       
673
       
 
       
            | End => ()

     

       
672
       
674
       
 
       
            }

     

       
673
       
675
       
 
       
          );

     

       
674
       
674
       
-
       
        | Push(_) when state.skip && !state.ended =>

     

       
675
       
675
       
-
       
          state.sourceTalkback(. Pull)

     

       
676
       
676
       
-
       
        | Push(_) when !state.ended =>

     

       
677
       
677
       
-
       
          state.gotSignal = false;

     

       
676
       
676
       
+
       
        | Push(_) when !state.skip && !state.ended =>

     

       
677
       
677
       
+
       
          state.pulled = false;

     

       
678
       
678
       
 
       
          sink(. signal);

     

       
679
       
679
       
 
       
        | Push(_) => ()

     

       
680
       
680
       
 
       
        | End =>

     
···

       
689
       
689
       
 
       
      sink(.

     

       
690
       
690
       
 
       
        Start(

     

       
691
       
691
       
 
       
          (. signal) =>

     

       
692
       
692
       
-
       
            switch (signal) {

     

       
693
       
693
       
-
       
            | Close =>

     

       
694
       
694
       
-
       
              if (state.skip) {

     

       
695
       
695
       
-
       
                state.notifierTalkback(. Close);

     

       
692
       
692
       
+
       
            if (!state.ended) {

     

       
693
       
693
       
+
       
              switch (signal) {

     

       
694
       
694
       
+
       
              | Close =>

     

       
695
       
695
       
+
       
                state.ended = true;

     

       
696
       
696
       
+
       
                state.sourceTalkback(. Close);

     

       
697
       
697
       
+
       
                if (state.skip) {

     

       
698
       
698
       
+
       
                  state.notifierTalkback(. Close);

     

       
699
       
699
       
+
       
                };

     

       
700
       
700
       
+
       
              | Pull when !state.pulled =>

     

       
701
       
701
       
+
       
                state.pulled = true;

     

       
702
       
702
       
+
       
                if (state.skip) {

     

       
703
       
703
       
+
       
                  state.notifierTalkback(. Pull);

     

       
704
       
704
       
+
       
                };

     

       
705
       
705
       
+
       
                state.sourceTalkback(. Pull);

     

       
706
       
706
       
+
       
              | Pull => ()

     

       
696
       
707
       
 
       
              };

     

       
697
       
697
       
-
       
              state.ended = true;

     

       
698
       
698
       
-
       
              state.sourceTalkback(. Close);

     

       
699
       
699
       
-
       
            | Pull when !state.gotSignal && !state.ended =>

     

       
700
       
700
       
-
       
              state.gotSignal = true;

     

       
701
       
701
       
-
       
              state.sourceTalkback(. Pull);

     

       
702
       
702
       
-
       
            | Pull => ()

     

       
703
       
708
       
 
       
            },

     

       
704
       
709
       
 
       
        ),

     

       
705
       
710
       
 
       
      );

     

···

       
804
       
804
       
 
       


     

       
805
       
805
       
 
       
describe('skipUntil', () => {

     

       
806
       
806
       
 
       
  const noop = operators.skipUntil(sources.fromValue(null));

     

       
807
       
807
       
-
       
  // TODO: passesPassivePull(noop);

     

       
808
       
808
       
-
       
  // TODO: passesActivePush(noop);

     

       
809
       
809
       
-
       
  // TODO: passesSinkClose(noop);

     

       
807
       
807
       
+
       
  passesPassivePull(noop);

     

       
808
       
808
       
+
       
  passesActivePush(noop);

     

       
809
       
809
       
+
       
  passesSinkClose(noop);

     

       
810
       
810
       
 
       
  passesSourceEnd(noop);

     

       
811
       
811
       
 
       
  passesSingleStart(noop);

     

       
812
       
812
       
 
       
  passesAsyncSequence(noop);

     

       
813
       
813
       
+
       
  passesStrictEnd(noop);

     

       
813
       
814
       
 
       


     

       
814
       
815
       
 
       
  it('skips values until the notifier source emits', () => {

     

       
815
       
816
       
 
       
    const { source: notifier$, next: notify } = sources.makeSubject();