synstate 3.0.0 → 3.0.2

package/dist/core/operators/merge-map.mjs

@@ -1,39 +1,132 @@
-import { Optional, Arr } from 'ts-data-forge';
-import { createAsyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { Arr, Optional } from 'ts-data-forge';
+import { createAsyncChildObservable } from '../base/index.mjs';
 
-const mergeMap = (mapToObservable) => (parentObservable) => createMergeMapObservable(parentObservable, mapToObservable);
-const flatMap = mergeMap;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const mergeMap = (mapToObservable) => (parentObservable) => createMergeMapObservable(parentObservable, mapToObservable);
+
+
+
+
+export const flatMap = mergeMap;
 const createMergeMapObservable = (parentObservable, mapToObservable) => {
-  let mut_observables = [];
-  let mut_subscriptions = [];
-  return createAsyncChildObservable(
-    {
-      parents: [parentObservable],
-      initialValue: Optional.none,
-      onComplete: () => {
-        for (const s of mut_subscriptions) {
-          s.unsubscribe();
-        }
-        for (const o of mut_observables) {
-          o.complete();
+    let mut_observables = [];
+    let mut_subscriptions = [];
+    return createAsyncChildObservable({
+        parents: [parentObservable],
+        initialValue: Optional.none,
+        onComplete: () => {
+            for (const s of mut_subscriptions) {
+                s.unsubscribe();
+            }
+            for (const o of mut_observables) {
+                o.complete();
+            }
+        },
+    }, ({ startUpdate }) => (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
         }
-      }
-    },
-    ({ startUpdate }) => (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      const observable = mapToObservable(sn.value);
-      mut_observables = Arr.toPushed(mut_observables, observable);
-      const subscription = observable.subscribe((curr) => {
-        startUpdate(curr);
-      });
-      mut_subscriptions = Arr.toPushed(mut_subscriptions, subscription);
-    }
-  );
+        const observable = mapToObservable(sn.value);
+        mut_observables = Arr.toPushed(mut_observables, observable);
+        const subscription = observable.subscribe((curr) => {
+            startUpdate(curr);
+        });
+        mut_subscriptions = Arr.toPushed(mut_subscriptions, subscription);
+    });
 };
-
-export { flatMap, mergeMap };
-//# sourceMappingURL=merge-map.mjs.map
+//# sourceMappingURL=merge-map.mjs.map

package/dist/core/operators/merge-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { createAsyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type MergeMapOperatorObservable,\n  type Observable,\n  type Subscription,\n} from '../types/index.mjs';\n\n/**\n * Projects each source value to an observable and merges all inner observables.\n * Unlike `switchMap`, does not cancel previous inner observables.\n *\n * @template A - The type of values from the source\n * @template B - The type of values from the projected observable\n * @param mapToObservable - A function that maps each source value to an observable\n * @returns An operator that merges mapped observables\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  input$      A                          B              C\n * //  inner A     A1    A2    A3\n * //  inner B                                B1    B2             B3\n * //  inner C                                              C1         C2    C3\n * //  result$     A1    A2    A3              B1    B2      C1    B3   C2    C3\n * //\n * //  Explanation:\n * //  - mergeMap creates an inner observable for each source value\n * //  - Unlike switchMap, previous inner observables are NOT cancelled\n * //  - B's inner continues even after C arrives (B3 is still emitted)\n * //  - All inner observables run concurrently and their results are merged\n *\n * const input$ = source<string>();\n *\n * const result$ = input$.pipe(\n *   mergeMap((letter) => {\n *     const inner$ = source<string>();\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}1`);\n *     }, 10);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}2`);\n *     }, 110);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}3`);\n *     }, 210);\n *\n *     return inner$;\n *   }),\n * );\n *\n * const valueHistory: string[] = [];\n *\n * result$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms\n * input$.next('A');\n *\n * await sleep(250);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);\n *\n * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms\n * input$.next('B');\n *\n * await sleep(150);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);\n *\n * // Emit C while B's inner is still running (B3 at 210ms not yet fired)\n * // Unlike switchMap, B's inner is NOT cancelled\n * input$.next('C');\n *\n * await sleep(250);\n *\n * // B3 appears between C1 and C2, showing the merge behavior\n * assert.deepStrictEqual(valueHistory, [\n *   'A1',\n *   'A2',\n *   'A3',\n *   'B1',\n *   'B2',\n *   'C1',\n *   'B3',\n *   'C2',\n *   'C3',\n * ]);\n * ```\n *\n * @note To improve code readability, consider using `createState` instead of `mergeMap`,\n * subscribing to `parentObservable` and calling `setState` within it.\n */\nexport const mergeMap =\n  <A, B>(\n    mapToObservable: (curr: A) => Observable<B>,\n  ): DropInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    createMergeMapObservable(parentObservable, mapToObservable);\n\n/**\n * Alias for `mergeMap`.\n * @see mergeMap\n */\nexport const flatMap = mergeMap;\n\nconst createMergeMapObservable = <A, B>(\n  parentObservable: Observable<A>,\n  mapToObservable: (curr: A) => Observable<B>,\n): MergeMapOperatorObservable<A, B> => {\n  let mut_observables: readonly Observable<B>[] = [];\n\n  let mut_subscriptions: readonly Subscription[] = [];\n\n  return createAsyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.none,\n      onComplete: () => {\n        for (const s of mut_subscriptions) {\n          s.unsubscribe();\n        }\n\n        for (const o of mut_observables) {\n          o.complete();\n        }\n      },\n    },\n    ({ startUpdate }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        const observable = mapToObservable(sn.value);\n\n        mut_observables = Arr.toPushed(mut_observables, observable);\n\n        const subscription = observable.subscribe((curr) => {\n          startUpdate(curr);\n        });\n\n        mut_subscriptions = Arr.toPushed(mut_subscriptions, subscription);\n      },\n  );\n};\n"],"names":[],"mappings":";;;;AAwGO,MAAM,WACX,CACE,eAAA,KAEF,CAAC,gBAAA,KACC,wBAAA,CAAyB,kBAAkB,eAAe;AAMvD,MAAM,OAAA,GAAU;AAEvB,MAAM,wBAAA,GAA2B,CAC/B,gBAAA,EACA,eAAA,KACqC;AACrC,EAAA,IAAI,kBAA4C,EAAC;AAEjD,EAAA,IAAI,oBAA6C,EAAC;AAElD,EAAA,OAAO,0BAAA;AAAA,IACL;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS,IAAA;AAAA,MACvB,YAAY,MAAM;AAChB,QAAA,KAAA,MAAW,KAAK,iBAAA,EAAmB;AACjC,UAAA,CAAA,CAAE,WAAA,EAAY;AAAA,QAChB;AAEA,QAAA,KAAA,MAAW,KAAK,eAAA,EAAiB;AAC/B,UAAA,CAAA,CAAE,QAAA,EAAS;AAAA,QACb;AAAA,MACF;AAAA,KACF;AAAA,IACA,CAAC,EAAE,WAAA,EAAY,KACb,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,UAAA,GAAa,eAAA,CAAgB,EAAA,CAAG,KAAK,CAAA;AAE3C,MAAA,eAAA,GAAkB,GAAA,CAAI,QAAA,CAAS,eAAA,EAAiB,UAAU,CAAA;AAE1D,MAAA,MAAM,YAAA,GAAe,UAAA,CAAW,SAAA,CAAU,CAAC,IAAA,KAAS;AAClD,QAAA,WAAA,CAAY,IAAI,CAAA;AAAA,MAClB,CAAC,CAAA;AAED,MAAA,iBAAA,GAAoB,GAAA,CAAI,QAAA,CAAS,iBAAA,EAAmB,YAAY,CAAA;AAAA,IAClE;AAAA,GACJ;AACF,CAAA;;;;"}
+{"version":3,"file":"merge-map.mjs","sourceRoot":"","sources":["../../../src/core/operators/merge-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAQ/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,MAAM,CAAC,MAAM,QAAQ,GACnB,CACE,eAA2C,EACX,EAAE,CACpC,CAAC,gBAAgB,EAAE,EAAE,CACnB,wBAAwB,CAAC,gBAAgB,EAAE,eAAe,CAAC,CAAC;AAEhE;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC;AAEhC,MAAM,wBAAwB,GAAG,CAC/B,gBAA+B,EAC/B,eAA2C,EACT,EAAE;IACpC,IAAI,eAAe,GAA6B,EAAE,CAAC;IAEnD,IAAI,iBAAiB,GAA4B,EAAE,CAAC;IAEpD,OAAO,0BAA0B,CAC/B;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;QAC3B,UAAU,EAAE,GAAG,EAAE;YACf,KAAK,MAAM,CAAC,IAAI,iBAAiB,EAAE,CAAC;gBAClC,CAAC,CAAC,WAAW,EAAE,CAAC;YAClB,CAAC;YAED,KAAK,MAAM,CAAC,IAAI,eAAe,EAAE,CAAC;gBAChC,CAAC,CAAC,QAAQ,EAAE,CAAC;YACf,CAAC;QACH,CAAC;KACF,EACD,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAClB,CAAC,WAAW,EAAE,EAAE;QACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,MAAM,UAAU,GAAG,eAAe,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAE7C,eAAe,GAAG,GAAG,CAAC,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;QAE5D,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YACjD,WAAW,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC,CAAC,CAAC;QAEH,iBAAiB,GAAG,GAAG,CAAC,QAAQ,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;IACpE,CAAC,CACJ,CAAC;AACJ,CAAC,CAAC"}

package/dist/core/operators/pairwise.mjs

@@ -1,30 +1,80 @@
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 
-const pairwise = () => f;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const pairwise = () => f;
 const f = (parentObservable) => createPairwiseObservable(parentObservable);
-const createPairwiseObservable = (parentObservable) => createSyncChildObservable(
-  {
+const createPairwiseObservable = (parentObservable) => createSyncChildObservable({
     parents: [parentObservable],
-    initialValue: Optional.none
-  },
-  ({ setNext }) => {
+    initialValue: Optional.none,
+}, ({ setNext }) => {
+
+
     let mut_previousValue = parentObservable.getSnapshot();
     return (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      const prev = mut_previousValue;
-      const cond = !Optional.isNone(prev);
-      mut_previousValue = parentObservable.getSnapshot();
-      if (cond) {
-        setNext([prev.value, sn.value], updateToken);
-      }
-    };
-  }
-);
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        const prev = mut_previousValue;
+        const cond = !Optional.isNone(prev);
 
-export { pairwise };
-//# sourceMappingURL=pairwise.mjs.map
+        mut_previousValue = parentObservable.getSnapshot();
+        if (cond) {
+            setNext([prev.value, sn.value], updateToken);
+        }
+    };
+});
+//# sourceMappingURL=pairwise.mjs.map

package/dist/core/operators/pairwise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { type FixedLengthTuple } from 'ts-type-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type PairwiseOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Emits the previous and current values as a pair.\n * Does not emit until the source has emitted at least twice.\n *\n * @template A - The type of values from the source\n * @returns An operator that pairs consecutive values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4\n * //  pairs$          [1,2] [2,3] [3,4]\n * //\n * //  Explanation:\n * //  - pairwise emits the current and previous values as a tuple\n * //  - Nothing is emitted for the first value (no previous value yet)\n * //  - Useful for tracking changes between consecutive values\n *\n * const num$ = source<number>();\n *\n * const pairs$ = num$.pipe(pairwise());\n *\n * const valueHistory: FixedLengthTuple<2, number>[] = [];\n *\n * pairs$.subscribe(([prev, curr]) => {\n *   valueHistory.push([prev, curr]);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * num$.next(2); // logs: 1, 2\n *\n * assert.deepStrictEqual(valueHistory, [[1, 2]]);\n *\n * num$.next(3); // logs: 2, 3\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, 2],\n *   [2, 3],\n * ]);\n *\n * num$.next(4); // logs: 3, 4\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, 2],\n *   [2, 3],\n *   [3, 4],\n * ]);\n * ```\n */\nexport const pairwise = <A,>(): DropInitialValueOperator<\n  A,\n  FixedLengthTuple<2, A>\n> => f;\n\nconst f = <A,>(\n  parentObservable: Observable<A>,\n): Observable<FixedLengthTuple<2, A>> =>\n  createPairwiseObservable(parentObservable);\n\nconst createPairwiseObservable = <A,>(\n  parentObservable: Observable<A>,\n): PairwiseOperatorObservable<A> =>\n  createSyncChildObservable<FixedLengthTuple<2, A>, readonly [A]>(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    },\n    ({ setNext }) => {\n      // parentObservable.snapshot has value\n      // if parentObservable is InitializedObservable\n      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        const prev = mut_previousValue;\n\n        const cond = !Optional.isNone(prev);\n\n        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively\n        mut_previousValue = parentObservable.getSnapshot();\n\n        if (cond) {\n          setNext([prev.value, sn.value], updateToken);\n        }\n      };\n    },\n  );\n"],"names":[],"mappings":";;;;AA8DO,MAAM,WAAW,MAGnB;AAEL,MAAM,CAAA,GAAI,CACR,gBAAA,KAEA,wBAAA,CAAyB,gBAAgB,CAAA;AAE3C,MAAM,wBAAA,GAA2B,CAC/B,gBAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,cAAc,QAAA,CAAS;AAAA,GACzB;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KAAM;AAGf,IAAA,IAAI,iBAAA,GAAiC,iBAAiB,WAAA,EAAY;AAElE,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,IAAA,GAAO,iBAAA;AAEb,MAAA,MAAM,IAAA,GAAO,CAAC,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA;AAGlC,MAAA,iBAAA,GAAoB,iBAAiB,WAAA,EAAY;AAEjD,MAAA,IAAI,IAAA,EAAM;AACR,QAAA,OAAA,CAAQ,CAAC,IAAA,CAAK,KAAA,EAAO,EAAA,CAAG,KAAK,GAAG,WAAW,CAAA;AAAA,MAC7C;AAAA,IACF,CAAA;AAAA,EACF;AACF,CAAA;;;;"}
+{"version":3,"file":"pairwise.mjs","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,GAGtB,EAAE,CAAC,CAAC,CAAC;AAEP,MAAM,CAAC,GAAG,CACR,gBAA+B,EACK,EAAE,CACtC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;AAE7C,MAAM,wBAAwB,GAAG,CAC/B,gBAA+B,EACA,EAAE,CACjC,yBAAyB,CACvB;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;CAC5B,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACd,sCAAsC;IACtC,+CAA+C;IAC/C,IAAI,iBAAiB,GAAgB,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAEpE,OAAO,CAAC,WAAW,EAAE,EAAE;QACrB,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,MAAM,IAAI,GAAG,iBAAiB,CAAC;QAE/B,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAEpC,wHAAwH;QACxH,iBAAiB,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAEnD,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/core/operators/scan.mjs

@@ -1,22 +1,66 @@
 import { Optional } from 'ts-data-forge';
-import { createInitializedSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { createInitializedSyncChildObservable } from '../base/index.mjs';
 
-const scan = (reducer, initialValue) => (parentObservable) => createScanObservable(parentObservable, reducer, initialValue);
-const createScanObservable = (parentObservable, reducer, initialValue) => createInitializedSyncChildObservable(
-  {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const scan = (reducer, initialValue) => (parentObservable) => createScanObservable(parentObservable, reducer, initialValue);
+const createScanObservable = (parentObservable, reducer, initialValue) => createInitializedSyncChildObservable({
     parents: [parentObservable],
-    initialValue: Optional.some(initialValue)
-  },
-  ({ setNext, getSnapshot }) => (updateToken) => {
+    initialValue: Optional.some(initialValue),
+}, ({ setNext, getSnapshot }) => (updateToken) => {
     const psn = parentObservable.getSnapshot();
     const sn = getSnapshot();
-    if (parentObservable.updateToken !== updateToken || Optional.isNone(psn) || Optional.isNone(sn)) {
-      return;
+    if (parentObservable.updateToken !== updateToken ||
+        Optional.isNone(psn) ||
+        Optional.isNone(sn)) {
+        return;
     }
     setNext(reducer(sn.value, psn.value), updateToken);
-  }
-);
-
-export { scan };
-//# sourceMappingURL=scan.mjs.map
+});
+//# sourceMappingURL=scan.mjs.map

package/dist/core/operators/scan.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"scan.mjs","sources":["../../../src/core/operators/scan.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createInitializedSyncChildObservable } from '../base/index.mjs';\nimport {\n  type Observable,\n  type ScanOperatorObservable,\n  type WithInitialValueOperator,\n} from '../types/index.mjs';\n\n/**\n * Applies an accumulator function over the source observable and emits each intermediate result.\n * Similar to Array.reduce but emits accumulated value after each source emission.\n *\n * @template A - The type of values from the source\n * @template B - The type of the accumulated value\n * @param reducer - The accumulator function\n * @param initialValue - The initial accumulated value (seed)\n * @returns An operator that accumulates values\n *\n * @example\n * ```ts\n * //  Timeline (accumulating sum):\n * //\n * //  num$    1     2     3     4     5\n * //  sum$    1     3     6     10    15\n * //          |     |     |     |     |\n * //          0+1   1+2   3+3   6+4   10+5\n * //\n * //  Explanation:\n * //  - scan accumulates values over time using a reducer function\n * //  - Starting with seed value 0, each emission adds to the accumulator\n * //  - Similar to Array.reduce, but for streams\n *\n * const num$ = source<number>();\n *\n * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));\n *\n * const valueHistory: number[] = [];\n *\n * sum$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [0, 1]);\n *\n * num$.next(2); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 3]);\n *\n * num$.next(3); // logs: 6\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 3, 6]);\n * ```\n */\nexport const scan =\n  <A, B>(\n    reducer: (acc: B, curr: A) => B,\n    initialValue: B,\n  ): WithInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    createScanObservable(parentObservable, reducer, initialValue);\n\nconst createScanObservable = <A, B>(\n  parentObservable: Observable<A>,\n  reducer: (acc: B, curr: A) => B,\n  initialValue: B,\n): ScanOperatorObservable<A, B> =>\n  createInitializedSyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.some(initialValue),\n    },\n    ({ setNext, getSnapshot }) =>\n      (updateToken) => {\n        const psn = parentObservable.getSnapshot();\n\n        const sn = getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(psn) ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(reducer(sn.value, psn.value), updateToken);\n      },\n  );\n"],"names":[],"mappings":";;;;AAyDO,MAAM,IAAA,GACX,CACE,OAAA,EACA,YAAA,KAEF,CAAC,gBAAA,KACC,oBAAA,CAAqB,gBAAA,EAAkB,OAAA,EAAS,YAAY;AAEhE,MAAM,oBAAA,GAAuB,CAC3B,gBAAA,EACA,OAAA,EACA,YAAA,KAEA,oCAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,YAAY;AAAA,GAC1C;AAAA,EACA,CAAC,EAAE,OAAA,EAAS,WAAA,EAAY,KACtB,CAAC,WAAA,KAAgB;AACf,IAAA,MAAM,GAAA,GAAM,iBAAiB,WAAA,EAAY;AAEzC,IAAA,MAAM,KAAK,WAAA,EAAY;AAEvB,IAAA,IACE,gBAAA,CAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,IACnB,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,MAAA;AAAA,IACF;AAEA,IAAA,OAAA,CAAQ,QAAQ,EAAA,CAAG,KAAA,EAAO,GAAA,CAAI,KAAK,GAAG,WAAW,CAAA;AAAA,EACnD;AACJ,CAAA;;;;"}
+{"version":3,"file":"scan.mjs","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,oCAAoC,EAAE,MAAM,mBAAmB,CAAC;AAOzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,IAAI,GACf,CACE,OAA+B,EAC/B,YAAe,EACiB,EAAE,CACpC,CAAC,gBAAgB,EAAE,EAAE,CACnB,oBAAoB,CAAC,gBAAgB,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;AAElE,MAAM,oBAAoB,GAAG,CAC3B,gBAA+B,EAC/B,OAA+B,EAC/B,YAAe,EACe,EAAE,CAChC,oCAAoC,CAClC;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;CAC1C,EACD,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,CAC3B,CAAC,WAAW,EAAE,EAAE;IACd,MAAM,GAAG,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAE3C,MAAM,EAAE,GAAG,WAAW,EAAE,CAAC;IAEzB,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;QAC5C,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;QACpB,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;QACD,OAAO,CAAC,cAAc;IACxB,CAAC;IAED,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;AACrD,CAAC,CACJ,CAAC"}

package/dist/core/operators/skip-if-no-change.mjs

@@ -1,36 +1,94 @@
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
-
-const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => createSkipIfNoChangeObservable(
-    parentObservable,
-    eq
-  ))
-);
-const distinctUntilChanged = skipIfNoChange;
-const createSkipIfNoChangeObservable = (parentObservable, eq) => createSyncChildObservable(
-  {
+import { createSyncChildObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => 
+
+((parentObservable) => createSkipIfNoChangeObservable(parentObservable, eq));
+
+
+
+
+export const distinctUntilChanged = skipIfNoChange;
+const createSkipIfNoChangeObservable = (parentObservable, eq) => createSyncChildObservable({
     parents: [parentObservable],
-    initialValue: parentObservable.getSnapshot()
-  },
-  ({ setNext }) => {
+    initialValue: parentObservable.getSnapshot(),
+}, ({ setNext }) => {
+
+
     let mut_previousValue = parentObservable.getSnapshot();
     return (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      const prev = mut_previousValue;
-      const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);
-      mut_previousValue = sn;
-      if (cond) {
-        setNext(sn.value, updateToken);
-      }
-    };
-  }
-);
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        const prev = mut_previousValue;
+        const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);
 
-export { distinctUntilChanged, skipIfNoChange };
-//# sourceMappingURL=skip-if-no-change.mjs.map
+        mut_previousValue = sn;
+        if (cond) {
+            setNext(sn.value, updateToken);
+        }
+    };
+});
+//# sourceMappingURL=skip-if-no-change.mjs.map

package/dist/core/operators/skip-if-no-change.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip-if-no-change.mjs","sources":["../../../src/core/operators/skip-if-no-change.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type SkipIfNoChangeOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Skips emissions if the value hasn't changed from the previous emission.\n * Uses a custom equality function or Object.is by default.\n *\n * @template A - The type of values from the source\n * @param eq - Equality comparison function (default: Object.is)\n * @returns An operator that skips duplicate consecutive values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     1     2     2     1     2     3     2\n * //  distinct$ 1           2           1     2     3     2\n * //\n * //  Explanation:\n * //  - skipIfNoChange filters out consecutive duplicate values\n * //  - Uses strict equality (===) for comparison\n * //  - Only emits when the value actually changes\n *\n * const num$ = source<number>();\n *\n * const distinct$ = num$.pipe(skipIfNoChange());\n *\n * const valueHistory: number[] = [];\n *\n * distinct$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(1); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * num$.next(2); // nothing logged\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2]);\n *\n * num$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3, 2]);\n * ```\n */\nexport const skipIfNoChange = <A,>(\n  eq: (x: A, y: A) => boolean = (x, y) => Object.is(x, y),\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    createSkipIfNoChangeObservable(\n      parentObservable,\n      eq,\n    )) as KeepInitialValueOperator<A, A>;\n\n/**\n * Alias for `skipIfNoChange`.\n * @see skipIfNoChange\n */\nexport const distinctUntilChanged = skipIfNoChange;\n\nconst createSkipIfNoChangeObservable = <A,>(\n  parentObservable: Observable<A>,\n  eq: (x: A, y: A) => boolean,\n): SkipIfNoChangeOperatorObservable<A> =>\n  createSyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    },\n    ({ setNext }) => {\n      // parentObservable.snapshot has value\n      // if parentObservable is InitializedObservable\n      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        const prev = mut_previousValue;\n\n        const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);\n\n        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively\n        mut_previousValue = sn;\n\n        if (cond) {\n          setNext(sn.value, updateToken);\n        }\n      };\n    },\n  );\n"],"names":[],"mappings":";;;;AAqEO,MAAM,cAAA,GAAiB,CAC5B,EAAA,GAA8B,CAAC,GAAG,CAAA,KAAM,MAAA,CAAO,EAAA,CAAG,CAAA,EAAG,CAAC,CAAA;AAAA;AAAA,GAGrD,CAAC,gBAAA,KACA,8BAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,oBAAA,GAAuB;AAEpC,MAAM,8BAAA,GAAiC,CACrC,gBAAA,EACA,EAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,GAC7C;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KAAM;AAGf,IAAA,IAAI,iBAAA,GAAiC,iBAAiB,WAAA,EAAY;AAElE,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,IAAA,GAAO,iBAAA;AAEb,MAAA,MAAM,IAAA,GAAO,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA,IAAK,CAAC,EAAA,CAAG,IAAA,CAAK,KAAA,EAAO,EAAA,CAAG,KAAK,CAAA;AAG9D,MAAA,iBAAA,GAAoB,EAAA;AAEpB,MAAA,IAAI,IAAA,EAAM;AACR,QAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,MAC/B;AAAA,IACF,CAAA;AAAA,EACF;AACF,CAAA;;;;"}
+{"version":3,"file":"skip-if-no-change.mjs","sourceRoot":"","sources":["../../../src/core/operators/skip-if-no-change.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,EAAE,GAA4B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EACvB,EAAE;AAClC,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,8BAA8B,CAC5B,gBAAgB,EAChB,EAAE,CACH,CAAmC,CAAC;AAEzC;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAEnD,MAAM,8BAA8B,GAAG,CACrC,gBAA+B,EAC/B,EAA2B,EACU,EAAE,CACvC,yBAAyB,CACvB;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;CAC7C,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACd,sCAAsC;IACtC,+CAA+C;IAC/C,IAAI,iBAAiB,GAAgB,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAEpE,OAAO,CAAC,WAAW,EAAE,EAAE;QACrB,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,MAAM,IAAI,GAAG,iBAAiB,CAAC;QAE/B,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;QAEhE,wHAAwH;QACxH,iBAAiB,GAAG,EAAE,CAAC;QAEvB,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACjC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/core/operators/skip-until.mjs

@@ -1,33 +1,75 @@
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 
-const skipUntil = (notifier) => (parentObservable) => createSkipUntilObservable(parentObservable, notifier);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const skipUntil = (notifier) => (parentObservable) => createSkipUntilObservable(parentObservable, notifier);
 const createSkipUntilObservable = (parentObservable, notifier) => {
-  let mut_isSkipping = true;
-  const observable = createSyncChildObservable(
-    {
-      parents: [parentObservable],
-      initialValue: Optional.none
-    },
-    ({ setNext }) => (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (mut_isSkipping || parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      setNext(sn.value, updateToken);
-    }
-  );
-  notifier.subscribe(
-    () => {
-      mut_isSkipping = false;
-    },
-    () => {
-      mut_isSkipping = false;
-    }
-  );
-  return observable;
+    let mut_isSkipping = true;
+    const observable = createSyncChildObservable({
+        parents: [parentObservable],
+        initialValue: Optional.none,
+    }, ({ setNext }) => (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+        if (mut_isSkipping ||
+            parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        setNext(sn.value, updateToken);
+    });
+    notifier.subscribe(() => {
+        mut_isSkipping = false;
+    }, () => {
+        mut_isSkipping = false;
+    });
+    return observable;
 };
-
-export { skipUntil };
-//# sourceMappingURL=skip-until.mjs.map
+//# sourceMappingURL=skip-until.mjs.map