synstate 0.1.0

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

@@ -0,0 +1,75 @@
+import { Optional, Arr } from 'ts-data-forge';
+import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Projects each source value to an observable and merges all inner observables.
+ * Unlike `switchMap`, does not cancel previous inner observables.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of values from the projected observable
+ * @param mapToObservable - A function that maps each source value to an observable
+ * @returns An operator that merges mapped observables
+ *
+ * @example
+ * ```ts
+ * const ids$ = source<number>();
+ *
+ * const users$ = ids$.pipe(mergeMap((id) => fromPromise(fetchUser(id))));
+ *
+ * users$.subscribe((user) => {
+ *   console.log(user);
+ * });
+ * // All requests run in parallel, results merged as they arrive
+ *
+ * const fetchUser = async (id: number): Promise<unknown> => ({ id });
+ * ```
+ *
+ * @note To improve code readability, consider using `createState` instead of `mergeMap`,
+ * subscribing to `parentObservable` and calling `setState` within it.
+ */
+const mergeMap = (mapToObservable) => (parentObservable) => new MergeMapObservableClass(parentObservable, mapToObservable);
+/**
+ * Alias for `mergeMap()`.
+ * @see mergeMap
+ */
+const flatMap = mergeMap;
+class MergeMapObservableClass extends AsyncChildObservableClass {
+    #mapToObservable;
+    #mut_observables;
+    #mut_subscriptions;
+    constructor(parentObservable, mapToObservable) {
+        super({
+            parents: [parentObservable],
+            initialValue: Optional.none,
+        });
+        this.#mapToObservable = mapToObservable;
+        this.#mut_observables = [];
+        this.#mut_subscriptions = [];
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+            return; // skip update
+        }
+        const observable = this.#mapToObservable(sn.value);
+        this.#mut_observables = Arr.toPushed(this.#mut_observables, observable);
+        const subscription = observable.subscribe((curr) => {
+            this.startUpdate(curr);
+        });
+        this.#mut_subscriptions = Arr.toPushed(this.#mut_subscriptions, subscription);
+    }
+    complete() {
+        for (const s of this.#mut_subscriptions) {
+            s.unsubscribe();
+        }
+        for (const o of this.#mut_observables) {
+            o.complete();
+        }
+        super.complete();
+    }
+}
+
+export { flatMap, mergeMap };
+//# sourceMappingURL=merge-map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;MACU,QAAQ,GACnB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,uBAAuB,CAAC,gBAAgB,EAAE,eAAe;AAEjE;;;AAGG;AACI,MAAM,OAAO,GAAG;AAEvB,MAAM,uBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,gBAAgB;AAChB,IAAA,kBAAkB;IAElB,WAAA,CACE,gBAA+B,EAC/B,eAA2C,EAAA;AAE3C,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,gBAAgB,GAAG,eAAe;AAEvC,QAAA,IAAI,CAAC,gBAAgB,GAAG,EAAE;AAE1B,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;IAC9B;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;QAEA,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;QAEvE,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,KAAI;AACjD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AACxB,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,QAAQ,CACpC,IAAI,CAAC,kBAAkB,EACvB,YAAY,CACb;IACH;IAES,QAAQ,GAAA;AACf,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACvC,CAAC,CAAC,WAAW,EAAE;QACjB;AAEA,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACrC,CAAC,CAAC,QAAQ,EAAE;QACd;QAEA,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/pairwise.d.mts

@@ -0,0 +1,27 @@
+import { type DropInitialValueOperator } from '../types/index.mjs';
+/**
+ * Emits the previous and current values as a pair.
+ * Does not emit until the source has emitted at least twice.
+ *
+ * @template A - The type of values from the source
+ * @returns An operator that pairs consecutive values
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const pairs$ = num$.pipe(pairwise());
+ *
+ * pairs$.subscribe(([prev, curr]) => {
+ *   console.log(prev, curr);
+ * });
+ *
+ * num$.next(1); // nothing logged
+ *
+ * num$.next(2); // logs: 1, 2
+ *
+ * num$.next(3); // logs: 2, 3
+ * ```
+ */
+export declare const pairwise: <A>() => DropInitialValueOperator<A, readonly [A, A]>;
+//# sourceMappingURL=pairwise.d.mts.map

package/dist/core/operators/pairwise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.d.mts","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,OAAM,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CACxE,CAAC"}

package/dist/core/operators/pairwise.mjs

@@ -0,0 +1,59 @@
+import { Optional } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Emits the previous and current values as a pair.
+ * Does not emit until the source has emitted at least twice.
+ *
+ * @template A - The type of values from the source
+ * @returns An operator that pairs consecutive values
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const pairs$ = num$.pipe(pairwise());
+ *
+ * pairs$.subscribe(([prev, curr]) => {
+ *   console.log(prev, curr);
+ * });
+ *
+ * num$.next(1); // nothing logged
+ *
+ * num$.next(2); // logs: 1, 2
+ *
+ * num$.next(3); // logs: 2, 3
+ * ```
+ */
+const pairwise = () => f;
+const f = (parentObservable) => new PairwiseObservableClass(parentObservable);
+class PairwiseObservableClass extends SyncChildObservableClass {
+    #mut_previousValue;
+    constructor(parentObservable) {
+        super({
+            parents: [parentObservable],
+            initialValue: Optional.none,
+        });
+        // parentObservable.snapshot has value
+        // if parentObservable is InitializedObservable
+        this.#mut_previousValue = parentObservable.getSnapshot();
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+            return; // skip update
+        }
+        const prev = this.#mut_previousValue;
+        const cond = !Optional.isNone(prev);
+        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
+        this.#mut_previousValue = par.getSnapshot();
+        if (cond) {
+            this.setNext([prev.value, sn.value], updaterSymbol);
+        }
+    }
+}
+
+export { pairwise };
+//# sourceMappingURL=pairwise.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;MACU,QAAQ,GAAG,MACtB;AAEF,MAAM,CAAC,GAAG,CAAK,gBAA+B,KAC5C,IAAI,uBAAuB,CAAC,gBAAgB,CAAC;AAE/C,MAAM,uBACJ,SAAQ,wBAAuD,CAAA;AAG/D,IAAA,kBAAkB;AAElB,IAAA,WAAA,CAAY,gBAA+B,EAAA;AACzC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;IAC1D;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB;QAEpC,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;;AAGnC,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,WAAW,EAAE;QAE3C,IAAI,IAAI,EAAE;AACR,YAAA,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QACrD;IACF;AACD;;;;"}

package/dist/core/operators/scan.d.mts

@@ -0,0 +1,30 @@
+import { type WithInitialValueOperator } from '../types/index.mjs';
+/**
+ * Applies an accumulator function over the source observable and emits each intermediate result.
+ * Similar to Array.reduce but emits accumulated value after each source emission.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of the accumulated value
+ * @param reducer - The accumulator function
+ * @param initialValue - The initial accumulated value (seed)
+ * @returns An operator that accumulates values
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
+ *
+ * sum$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(2); // logs: 3
+ *
+ * num$.next(3); // logs: 6
+ * ```
+ */
+export declare const scan: <A, B>(reducer: (acc: B, curr: A) => B, initialValue: B) => WithInitialValueOperator<A, B>;
+//# sourceMappingURL=scan.d.mts.map

package/dist/core/operators/scan.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.mts","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,EACH,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC/B,cAAc,CAAC,KACd,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEkC,CAAC"}

package/dist/core/operators/scan.mjs

@@ -0,0 +1,56 @@
+import { Optional } from 'ts-data-forge';
+import { InitializedSyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Applies an accumulator function over the source observable and emits each intermediate result.
+ * Similar to Array.reduce but emits accumulated value after each source emission.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of the accumulated value
+ * @param reducer - The accumulator function
+ * @param initialValue - The initial accumulated value (seed)
+ * @returns An operator that accumulates values
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
+ *
+ * sum$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(2); // logs: 3
+ *
+ * num$.next(3); // logs: 6
+ * ```
+ */
+const scan = (reducer, initialValue) => (parentObservable) => new ScanObservableClass(parentObservable, reducer, initialValue);
+class ScanObservableClass extends InitializedSyncChildObservableClass {
+    #reducer;
+    constructor(parentObservable, reducer, initialValue) {
+        super({
+            parents: [parentObservable],
+            initialValue: Optional.some(initialValue),
+        });
+        this.#reducer = reducer;
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const psn = par.getSnapshot();
+        const sn = this.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol ||
+            Optional.isNone(psn) ||
+            Optional.isNone(sn)) {
+            return; // skip update
+        }
+        this.setNext(this.#reducer(sn.value, psn.value), updaterSymbol);
+    }
+}
+
+export { scan };
+//# sourceMappingURL=scan.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scan.mjs","sources":["../../../src/core/operators/scan.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,IAAI,GACf,CACE,OAA+B,EAC/B,YAAe,KAEjB,CAAC,gBAAgB,KACf,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,OAAO,EAAE,YAAY;AAEnE,MAAM,mBACJ,SAAQ,mCAAoD,CAAA;AAGnD,IAAA,QAAQ;AAEjB,IAAA,WAAA,CACE,gBAA+B,EAC/B,OAA+B,EAC/B,YAAe,EAAA;AAEf,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;AAC1C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;IACzB;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE;AAE7B,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE;AAE7B,QAAA,IACE,GAAG,CAAC,aAAa,KAAK,aAAa;AACnC,YAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB;AACA,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;IACjE;AACD;;;;"}

package/dist/core/operators/skip-if-no-change.d.mts

@@ -0,0 +1,33 @@
+import { type KeepInitialValueOperator } from '../types/index.mjs';
+/**
+ * Skips emissions if the value hasn't changed from the previous emission.
+ * Uses a custom equality function or Object.is by default.
+ *
+ * @template A - The type of values from the source
+ * @param eq - Equality comparison function (default: Object.is)
+ * @returns An operator that skips duplicate consecutive values
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const distinct$ = num$.pipe(skipIfNoChange());
+ *
+ * distinct$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(1); // nothing logged
+ *
+ * num$.next(2); // logs: 2
+ * ```
+ */
+export declare const skipIfNoChange: <A>(eq?: (x: A, y: A) => boolean) => KeepInitialValueOperator<A, A>;
+/**
+ * Alias for `skipIfNoChange()`.
+ * @see skipIfNoChange
+ */
+export declare const distinctUntilChanged: <A>(eq?: (x: A, y: A) => boolean) => KeepInitialValueOperator<A, A>;
+//# sourceMappingURL=skip-if-no-change.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip-if-no-change.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-if-no-change.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAC9B,KAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmC,KACtD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAdF,CAAC,OAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAC1B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAYkB,CAAC"}

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

@@ -0,0 +1,68 @@
+import { Optional } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Skips emissions if the value hasn't changed from the previous emission.
+ * Uses a custom equality function or Object.is by default.
+ *
+ * @template A - The type of values from the source
+ * @param eq - Equality comparison function (default: Object.is)
+ * @returns An operator that skips duplicate consecutive values
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const distinct$ = num$.pipe(skipIfNoChange());
+ *
+ * distinct$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(1); // nothing logged
+ *
+ * num$.next(2); // logs: 2
+ * ```
+ */
+const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+((parentObservable) => new SkipIfNoChangeObservableClass(parentObservable, eq));
+/**
+ * Alias for `skipIfNoChange()`.
+ * @see skipIfNoChange
+ */
+const distinctUntilChanged = skipIfNoChange; // alias
+class SkipIfNoChangeObservableClass extends SyncChildObservableClass {
+    #eq;
+    #mut_previousValue;
+    constructor(parentObservable, eq) {
+        super({
+            parents: [parentObservable],
+            initialValue: parentObservable.getSnapshot(),
+        });
+        // parentObservable.snapshot has value
+        // if parentObservable is InitializedObservable
+        this.#mut_previousValue = parentObservable.getSnapshot();
+        this.#eq = eq;
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+            return; // skip update
+        }
+        const prev = this.#mut_previousValue;
+        const cond = Optional.isNone(prev) || !this.#eq(prev.value, sn.value);
+        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
+        this.#mut_previousValue = sn;
+        if (cond) {
+            this.setNext(sn.value, updaterSymbol);
+        }
+    }
+}
+
+export { distinctUntilChanged, skipIfNoChange };
+//# sourceMappingURL=skip-if-no-change.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip-if-no-change.mjs","sources":["../../../src/core/operators/skip-if-no-change.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;MACU,cAAc,GAAG,CAC5B,EAAA,GAA8B,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AAEvD;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,6BAA6B,CAC/B,gBAAgB,EAChB,EAAE,CACH;AAEL;;;AAGG;AACI,MAAM,oBAAoB,GAAG,eAAe;AAEnD,MAAM,6BACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,GAAG;AACZ,IAAA,kBAAkB;IAElB,WAAA,CAAY,gBAA+B,EAAE,EAA2B,EAAA;AACtE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;AAExD,QAAA,IAAI,CAAC,GAAG,GAAG,EAAE;IACf;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB;QAEpC,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC;;AAGrE,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;QAE5B,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;QACvC;IACF;AACD;;;;"}

package/dist/core/operators/skip-until.d.mts

@@ -0,0 +1,3 @@
+import { type DropInitialValueOperator, type Observable } from '../types/index.mjs';
+export declare const skipUntil: <A>(notifier: Observable<unknown>) => DropInitialValueOperator<A, A>;
+//# sourceMappingURL=skip-until.d.mts.map

package/dist/core/operators/skip-until.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-until.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-until.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,SAAS,GACnB,CAAC,EAAG,UAAU,UAAU,CAAC,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAER,CAAC"}

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

@@ -0,0 +1,33 @@
+import { Optional } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+const skipUntil = (notifier) => (parentObservable) => new SkipUntilObservableClass(parentObservable, notifier);
+class SkipUntilObservableClass extends SyncChildObservableClass {
+    #mut_isSkipping;
+    constructor(parentObservable, notifier) {
+        super({
+            parents: [parentObservable],
+            initialValue: Optional.none,
+        });
+        this.#mut_isSkipping = true;
+        notifier.subscribe(() => {
+            this.#mut_isSkipping = false;
+        }, () => {
+            this.#mut_isSkipping = false;
+        });
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol ||
+            Optional.isNone(sn) ||
+            this.#mut_isSkipping) {
+            return; // skip update
+        }
+        this.setNext(sn.value, updaterSymbol);
+    }
+}
+
+export { skipUntil };
+//# sourceMappingURL=skip-until.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;MASa,SAAS,GACpB,CAAK,QAA6B,KAClC,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,QAAQ;AAE3D,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGjD,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,QAA6B,EAAA;AACxE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,QAAQ,CAAC,SAAS,CAChB,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;QAC9B,CAAC,EACD,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,CACF;IACH;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IACE,GAAG,CAAC,aAAa,KAAK,aAAa;AACnC,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;IACvC;AACD;;;;"}

package/dist/core/operators/skip-while.d.mts

@@ -0,0 +1,4 @@
+import { type DropInitialValueOperator } from '../types/index.mjs';
+export declare const skipWhile: <A>(predicate: (value: A, index: SafeUint | -1) => boolean) => DropInitialValueOperator<A, A>;
+export declare const skip: <A>(n: PositiveSafeIntWithSmallInt) => DropInitialValueOperator<A, A>;
+//# sourceMappingURL=skip-while.d.mts.map

package/dist/core/operators/skip-while.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-while.mts"],"names":[],"mappings":"AAQA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,SAAS,GACnB,CAAC,EACA,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC;AAI9D,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}

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

@@ -0,0 +1,40 @@
+import { PositiveSafeInt, pipe, Optional, asSafeUint, SafeUint } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+const skipWhile = (predicate) => (parentObservable) => new SkipWhileObservableClass(parentObservable, predicate);
+/* Specialized operators */
+const skip = (n) => !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
+const idFn = (value) => value;
+/* implementation */
+class SkipWhileObservableClass extends SyncChildObservableClass {
+    #predicate;
+    #mut_index;
+    constructor(parentObservable, predicate) {
+        super({
+            parents: [parentObservable],
+            initialValue: pipe(parentObservable.getSnapshot()).map((sn) => Optional.isNone(sn)
+                ? Optional.none
+                : predicate(sn.value, -1)
+                    ? Optional.none
+                    : sn).value,
+        });
+        this.#mut_index = -1;
+        this.#predicate = predicate;
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+            return; // skip update
+        }
+        this.#mut_index =
+            this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+        if (!this.#predicate(sn.value, this.#mut_index)) {
+            this.setNext(sn.value, updaterSymbol);
+        }
+    }
+}
+
+export { skip, skipWhile };
+//# sourceMappingURL=skip-while.mjs.map

package/dist/core/operators/skip-while.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;MAea,SAAS,GACpB,CACE,SAAsD,KAExD,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,SAAS;AAE5D;AAEO,MAAM,IAAI,GAAG,CAClB,CAA8B,KAE9B,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;AAExE,MAAM,IAAI,GAAG,CAAK,KAAQ,KAAQ,KAAK;AAEvC;AAEA,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAsD,EAAA;AAEtD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KACxD,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACd,QAAQ,CAAC;kBACT,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;sBACpB,QAAQ,CAAC;AACX,sBAAE,EAAE,CACT,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;IAC7B;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC/C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;QACvC;IACF;AACD;;;;"}

package/dist/core/operators/switch-map.d.mts

@@ -0,0 +1,31 @@
+import { type DropInitialValueOperator, type Observable } from '../types/index.mjs';
+/**
+ * Projects each source value to an observable, subscribes to it, and emits its values.
+ * When a new value arrives from the source, the previous inner observable is unsubscribed.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of values from the projected observable
+ * @param mapToObservable - A function that maps each source value to an observable
+ * @returns An operator that switches to new observables
+ *
+ * @example
+ * ```ts
+ * const searchQuery$ = source<string>();
+ *
+ * const results$ = searchQuery$.pipe(
+ *   switchMap((query) => fromPromise(fetchResults(query))),
+ * );
+ *
+ * results$.subscribe((results) => {
+ *   console.log(results);
+ * });
+ * // Only the latest search results are emitted, previous searches are cancelled
+ *
+ * const fetchResults = async (_query: string): Promise<readonly unknown[]> => [];
+ * ```
+ *
+ * @note To improve code readability, consider using `createState` instead of `switchMap`,
+ * subscribe to `parentObservable` and call `setState` within it.
+ */
+export declare const switchMap: <A, B>(mapToObservable: (curr: A) => Observable<B>) => DropInitialValueOperator<A, B>;
+//# sourceMappingURL=switch-map.d.mts.map

package/dist/core/operators/switch-map.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/switch-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEiC,CAAC"}

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

@@ -0,0 +1,70 @@
+import { Optional } from 'ts-data-forge';
+import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Projects each source value to an observable, subscribes to it, and emits its values.
+ * When a new value arrives from the source, the previous inner observable is unsubscribed.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of values from the projected observable
+ * @param mapToObservable - A function that maps each source value to an observable
+ * @returns An operator that switches to new observables
+ *
+ * @example
+ * ```ts
+ * const searchQuery$ = source<string>();
+ *
+ * const results$ = searchQuery$.pipe(
+ *   switchMap((query) => fromPromise(fetchResults(query))),
+ * );
+ *
+ * results$.subscribe((results) => {
+ *   console.log(results);
+ * });
+ * // Only the latest search results are emitted, previous searches are cancelled
+ *
+ * const fetchResults = async (_query: string): Promise<readonly unknown[]> => [];
+ * ```
+ *
+ * @note To improve code readability, consider using `createState` instead of `switchMap`,
+ * subscribe to `parentObservable` and call `setState` within it.
+ */
+const switchMap = (mapToObservable) => (parentObservable) => new SwitchMapObservableClass(parentObservable, mapToObservable);
+class SwitchMapObservableClass extends AsyncChildObservableClass {
+    #mapToObservable;
+    #mut_observable;
+    #mut_subscription;
+    constructor(parentObservable, mapToObservable) {
+        super({
+            parents: [parentObservable],
+            initialValue: Optional.none,
+        });
+        this.#mapToObservable = mapToObservable;
+        this.#mut_observable = undefined;
+        this.#mut_subscription = undefined;
+    }
+    tryUpdate(updaterSymbol) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+            return; // skip update
+        }
+        this.#mut_observable?.complete();
+        this.#mut_subscription?.unsubscribe();
+        const observable = this.#mapToObservable(sn.value);
+        this.#mut_observable = observable;
+        const subscription = observable.subscribe((curr) => {
+            this.startUpdate(curr);
+        });
+        this.#mut_subscription = subscription;
+    }
+    complete() {
+        this.#mut_subscription?.unsubscribe();
+        this.#mut_observable?.complete();
+        super.complete();
+    }
+}
+
+export { switchMap };
+//# sourceMappingURL=switch-map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"switch-map.mjs","sources":["../../../src/core/operators/switch-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;MACU,SAAS,GACpB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,eAAe;AAElE,MAAM,wBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,eAAe;AACf,IAAA,iBAAiB;IAEjB,WAAA,CACE,gBAA+B,EAC/B,eAA2C,EAAA;AAE3C,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,gBAAgB,GAAG,eAAe;AAEvC,QAAA,IAAI,CAAC,eAAe,GAAG,SAAS;AAEhC,QAAA,IAAI,CAAC,iBAAiB,GAAG,SAAS;IACpC;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE;AAEhC,QAAA,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE;QAErC,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,eAAe,GAAG,UAAU;QAEjC,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,KAAI;AACjD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AACxB,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,CAAC,iBAAiB,GAAG,YAAY;IACvC;IAES,QAAQ,GAAA;AACf,QAAA,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE;AAErC,QAAA,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE;QAEhC,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/take-until.d.mts

@@ -0,0 +1,32 @@
+import { type KeepInitialValueOperator, type Observable } from '../types/index.mjs';
+/**
+ * Emits values from the source until the notifier observable emits.
+ * When the notifier emits, this observable completes.
+ *
+ * @template A - The type of values from the source
+ * @param notifier - An observable that signals when to complete
+ * @returns An operator that takes values until notifier emits
+ *
+ * @example
+ * ```ts
+ * const num$ = source<number>();
+ *
+ * const [stopNotifier, stop_] = createEventEmitter();
+ *
+ * const limited$ = num$.pipe(takeUntil(stopNotifier));
+ *
+ * limited$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(2); // logs: 2
+ *
+ * stop_();
+ *
+ * num$.next(3); // nothing logged (completed)
+ * ```
+ */
+export declare const takeUntil: <A>(notifier: Observable<unknown>) => KeepInitialValueOperator<A, A>;
+//# sourceMappingURL=take-until.d.mts.map

package/dist/core/operators/take-until.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-until.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-until.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,UAAU,UAAU,CAAC,OAAO,CAAC,KAC5B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}