synstate 0.1.1 → 1.0.0

package/src/utils/create-state.mts

@@ -28,31 +28,31 @@ const reducer = <S,>(state: S, action: Action<S>): S => {
  *
  * @template S - The type of the state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable and methods to manipulate it
+ * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
  *
  * @example
  * ```ts
  * const [state, setState, { updateState, resetState }] = createState(0);
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * setState(10); // logs: 10
  *
- * assert.deepStrictEqual(mut_history, [0, 10]);
+ * assert.deepStrictEqual(stateHistory, [0, 10]);
  *
  * updateState((prev: number) => prev + 1); // logs: 11
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11]);
  *
  * resetState(); // logs: 0
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11, 0]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
  * ```
  */
 export const createState = <S,>(
@@ -64,9 +64,10 @@ export const createState = <S,>(
     updateState: (updateFn: (prev: S) => S) => S;
     resetState: () => S;
     getSnapshot: () => S;
+    initialState: S;
   }>,
 ] => {
-  const [state, dispatch, getSnapshot] = createReducer<S, Action<S>>(
+  const [state, dispatch, { getSnapshot }] = createReducer<S, Action<S>>(
     reducer,
     initialState,
   );
@@ -86,73 +87,7 @@ export const createState = <S,>(
       updateState,
       resetState,
       getSnapshot,
-    },
-  ] as const;
-};
-
-/**
- * Creates a reactive boolean state with convenient methods for boolean operations.
- * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
- *
- * @param initialState - The initial boolean value
- * @returns An object with the state observable and boolean-specific methods
- *
- * @example
- * ```ts
- * const [state, { setTrue, toggle }] = createBooleanState(false);
- *
- * const mut_history: boolean[] = [];
- *
- * state.subscribe((value: boolean) => {
- *   mut_history.push(value);
- * });
- *
- * assert.deepStrictEqual(mut_history, [false]);
- *
- * setTrue(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true]);
- *
- * toggle(); // logs: false
- *
- * assert.deepStrictEqual(mut_history, [false, true, false]);
- *
- * toggle(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true, false, true]);
- * ```
- */
-export const createBooleanState = (
-  initialState: boolean,
-): readonly [
-  state: InitializedObservable<boolean>,
-  Readonly<{
-    setTrue: () => void;
-    setFalse: () => void;
-    setState: (next: boolean) => boolean;
-    toggle: () => boolean;
-    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
-    resetState: () => boolean;
-    getSnapshot: () => boolean;
-  }>,
-] => {
-  const [state, setState, { updateState, resetState, getSnapshot }] =
-    createState(initialState);
-
-  return [
-    state,
-    {
-      setTrue: () => {
-        setState(true);
-      },
-      setFalse: () => {
-        setState(false);
-      },
-      toggle: () => updateState((s) => !s),
-      setState,
-      updateState,
-      resetState,
-      getSnapshot,
+      initialState,
     },
   ] as const;
 };

package/src/utils/index.mts

@@ -1,3 +1,5 @@
+export * from './collect-to-array.mjs';
+export * from './create-boolean-state.mjs';
 export * from './create-event-emitter.mjs';
 export * from './create-reducer.mjs';
 export * from './create-state.mjs';

package/dist/core/create/from-array.d.mts

@@ -1,39 +0,0 @@
-import { type FromArrayObservable } from '../types/index.mjs';
-/**
- * Creates an observable that emits all values from an array sequentially, then completes.
- *
- * @template A - The type of array elements
- * @param values - The array of values to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits array values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  nums$     1     2     3     | (completes)
- * //
- * //  Explanation:
- * //  - fromArray creates an observable from an array
- * //  - Emits all values synchronously, then completes
- *
- * const nums$ = fromArray([1, 2, 3]);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   nums$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
- * ```
- */
-export declare const fromArray: <A>(values: readonly A[], startManually?: boolean) => FromArrayObservable<A>;
-//# sourceMappingURL=from-array.d.mts.map

package/dist/core/create/from-array.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-array.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-array.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,QAAQ,SAAS,CAAC,EAAE,EACpB,gBAAe,OAAe,KAC7B,mBAAmB,CAAC,CAAC,CACgC,CAAC"}

package/dist/core/create/from-array.mjs

@@ -1,65 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-/**
- * Creates an observable that emits all values from an array sequentially, then completes.
- *
- * @template A - The type of array elements
- * @param values - The array of values to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits array values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  nums$     1     2     3     | (completes)
- * //
- * //  Explanation:
- * //  - fromArray creates an observable from an array
- * //  - Emits all values synchronously, then completes
- *
- * const nums$ = fromArray([1, 2, 3]);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   nums$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
- * ```
- */
-const fromArray = (values, startManually = false) => new FromArrayObservableClass(values, startManually);
-class FromArrayObservableClass extends RootObservableClass {
-    #values;
-    constructor(values, startManually = false) {
-        super({ initialValue: Optional.none });
-        this.#values = values;
-        if (!startManually) {
-            setTimeout(() => {
-                this.emit();
-            }, 0);
-        }
-    }
-    emit() {
-        if (this.isCompleted)
-            return this;
-        for (const v of this.#values) {
-            this.startUpdate(v);
-        }
-        this.complete();
-        return this;
-    }
-}
-
-export { fromArray };
-//# sourceMappingURL=from-array.mjs.map

package/dist/core/create/from-array.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-array.mjs","sources":["../../../src/core/create/from-array.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACI,MAAM,SAAS,GAAG,CACvB,MAAoB,EACpB,aAAA,GAAyB,KAAK,KAE9B,IAAI,wBAAwB,CAAI,MAAM,EAAE,aAAa;AAEvD,MAAM,wBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,OAAO;IAEhB,WAAA,CAAY,MAAoB,EAAE,aAAA,GAAyB,KAAK,EAAA;QAC9D,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,OAAO,GAAG,MAAM;QAErB,IAAI,CAAC,aAAa,EAAE;YAClB,UAAU,CAAC,MAAK;gBACd,IAAI,CAAC,IAAI,EAAE;YACb,CAAC,EAAE,CAAC,CAAC;QACP;IACF;IAEA,IAAI,GAAA;QACF,IAAI,IAAI,CAAC,WAAW;AAAE,YAAA,OAAO,IAAI;AAEjC,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE;AAC5B,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACrB;QAEA,IAAI,CAAC,QAAQ,EAAE;AAEf,QAAA,OAAO,IAAI;IACb;AACD;;;;"}

package/dist/core/create/interval.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"interval.d.mts","sourceRoot":"","sources":["../../../src/core/create/interval.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,QAAQ,GACnB,cAAc,MAAM,EACpB,gBAAgB,OAAO,KACtB,kBACuD,CAAC"}

package/dist/core/create/interval.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"interval.mjs","sources":["../../../src/core/create/interval.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;AACI,MAAM,QAAQ,GAAG,CACtB,YAAoB,EACpB,aAAuB,KAEvB,IAAI,uBAAuB,CAAC,YAAY,EAAE,aAAa;AAEzD,MAAM,uBACJ,SAAQ,mBAA6B,CAAA;AAG5B,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,aAAa;AACb,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAuB,EAAA;QACvD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,CAAC,CAAC;AAEjC,QAAA,IAAI,CAAC,aAAa,GAAG,SAAS;AAE9B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;AAE3B,QAAA,IAAI,aAAa,KAAK,IAAI,EAAE;YAC1B,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;AAElC,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,2CAA2C,CAAC;AAEzD,YAAA,OAAO,IAAI;QACb;;AAGA,QAAA,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;QACrC,CAAC,EAAE,CAAC,CAAC;AAEL,QAAA,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC;AAEtD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;AACrC,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;AAEtB,QAAA,OAAO,IAAI;IACb;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACvE,YAAA,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC;AAEjC,YAAA,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;QAClC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/create/of.d.mts

@@ -1,39 +0,0 @@
-import { type OfObservable } from '../types/index.mjs';
-/**
- * Creates an observable that emits a single value and then completes.
- *
- * @template A - The type of the value
- * @param value - The value to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits the value
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$    42  | (completes immediately)
- * //
- * //  Explanation:
- * //  - of creates an observable that emits a single value, then completes
- * //  - Useful for converting a static value into an observable
- *
- * const num$ = of(42);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   num$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [42]);
- * ```
- */
-export declare const of: <A>(value: A, startManually?: boolean) => OfObservable<A>;
-//# sourceMappingURL=of.d.mts.map

package/dist/core/create/of.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"of.d.mts","sourceRoot":"","sources":["../../../src/core/create/of.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAClB,OAAO,CAAC,EACR,gBAAe,OAAe,KAC7B,YAAY,CAAC,CAAC,CAAmD,CAAC"}

package/dist/core/create/of.mjs

@@ -1,63 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-/**
- * Creates an observable that emits a single value and then completes.
- *
- * @template A - The type of the value
- * @param value - The value to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits the value
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$    42  | (completes immediately)
- * //
- * //  Explanation:
- * //  - of creates an observable that emits a single value, then completes
- * //  - Useful for converting a static value into an observable
- *
- * const num$ = of(42);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   num$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [42]);
- * ```
- */
-const of = (value, startManually = false) => new OfObservableClass(value, startManually);
-class OfObservableClass extends RootObservableClass {
-    #value;
-    constructor(value, startManually = false) {
-        super({ initialValue: Optional.none });
-        this.#value = value;
-        if (!startManually) {
-            setTimeout(() => {
-                this.emit();
-            }, 0);
-        }
-    }
-    emit() {
-        if (this.isCompleted)
-            return this;
-        this.startUpdate(this.#value);
-        this.complete();
-        return this;
-    }
-}
-
-export { of };
-//# sourceMappingURL=of.mjs.map

package/dist/core/create/of.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"of.mjs","sources":["../../../src/core/create/of.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACI,MAAM,EAAE,GAAG,CAChB,KAAQ,EACR,aAAA,GAAyB,KAAK,KACV,IAAI,iBAAiB,CAAI,KAAK,EAAE,aAAa;AAEnE,MAAM,iBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,MAAM;IAEf,WAAA,CAAY,KAAQ,EAAE,aAAA,GAAyB,KAAK,EAAA;QAClD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;QAEnB,IAAI,CAAC,aAAa,EAAE;YAClB,UAAU,CAAC,MAAK;gBACd,IAAI,CAAC,IAAI,EAAE;YACb,CAAC,EAAE,CAAC,CAAC;QACP;IACF;IAEA,IAAI,GAAA;QACF,IAAI,IAAI,CAAC,WAAW;AAAE,YAAA,OAAO,IAAI;AAEjC,QAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC;QAE7B,IAAI,CAAC,QAAQ,EAAE;AAEf,QAAA,OAAO,IAAI;IACb;AACD;;;;"}

package/dist/core/operators/audit-time.d.mts

@@ -1,62 +0,0 @@
-import { type KeepInitialValueOperator } from '../types/index.mjs';
-/**
- * Emits the last value from the source observable after a specified time window has passed.
- * Unlike throttleTime which emits the first value, auditTime emits the last value.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The audit time window in milliseconds
- * @returns An operator that audits emissions from the observable
- *
- * @example
- * ```ts
- * //  Timeline (1000ms audit):
- * //
- * //  Time(ms)  0    100   200   300   400   ...   1000  1100
- * //  input$    e1   e2    e3    e4    e5
- * //  audited$                                      e5 (emitted at end of window)
- * //            |-------1000ms window------>        ^
- * //
- * //  Explanation:
- * //  - auditTime emits the LAST value received during each time window
- * //  - Unlike throttleTime (which emits the FIRST value), audit emits the LAST
- * //  - At 0-1000ms: e1-e5 are received
- * //  - At 1000ms: e5 (the last value in the window) is emitted
- * //  - Useful when you want the most recent value after a burst of events
- *
- * const input$ = source<number>();
- *
- * const audited$ = input$.pipe(auditTime(200));
- *
- * const mut_history: number[] = [];
- *
- * audited$.subscribe((value) => {
- *   mut_history.push(value);
- * });
- *
- * input$.next(1);
- *
- * input$.next(2);
- *
- * input$.next(3);
- *
- * assert.deepStrictEqual(mut_history, []);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 250);
- * });
- *
- * assert.deepStrictEqual(mut_history, [3]);
- *
- * input$.next(4);
- *
- * input$.next(5);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 250);
- * });
- *
- * assert.deepStrictEqual(mut_history, [3, 5]);
- * ```
- */
-export declare const auditTime: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;
-//# sourceMappingURL=audit-time.d.mts.map

package/dist/core/operators/audit-time.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"audit-time.d.mts","sourceRoot":"","sources":["../../../src/core/operators/audit-time.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/audit-time.mjs

@@ -1,109 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-/**
- * Emits the last value from the source observable after a specified time window has passed.
- * Unlike throttleTime which emits the first value, auditTime emits the last value.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The audit time window in milliseconds
- * @returns An operator that audits emissions from the observable
- *
- * @example
- * ```ts
- * //  Timeline (1000ms audit):
- * //
- * //  Time(ms)  0    100   200   300   400   ...   1000  1100
- * //  input$    e1   e2    e3    e4    e5
- * //  audited$                                      e5 (emitted at end of window)
- * //            |-------1000ms window------>        ^
- * //
- * //  Explanation:
- * //  - auditTime emits the LAST value received during each time window
- * //  - Unlike throttleTime (which emits the FIRST value), audit emits the LAST
- * //  - At 0-1000ms: e1-e5 are received
- * //  - At 1000ms: e5 (the last value in the window) is emitted
- * //  - Useful when you want the most recent value after a burst of events
- *
- * const input$ = source<number>();
- *
- * const audited$ = input$.pipe(auditTime(200));
- *
- * const mut_history: number[] = [];
- *
- * audited$.subscribe((value) => {
- *   mut_history.push(value);
- * });
- *
- * input$.next(1);
- *
- * input$.next(2);
- *
- * input$.next(3);
- *
- * assert.deepStrictEqual(mut_history, []);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 250);
- * });
- *
- * assert.deepStrictEqual(mut_history, [3]);
- *
- * input$.next(4);
- *
- * input$.next(5);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 250);
- * });
- *
- * assert.deepStrictEqual(mut_history, [3, 5]);
- * ```
- */
-const auditTime = (milliSeconds) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new AuditTimeObservableClass(parentObservable, milliSeconds));
-class AuditTimeObservableClass extends AsyncChildObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    #mut_isSkipping;
-    constructor(parentObservable, milliSeconds) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        this.#mut_isSkipping = false;
-        this.#mut_timerId = undefined;
-        this.#milliSeconds = milliSeconds;
-    }
-    tryUpdate(updaterSymbol) {
-        const par = this.parents[0];
-        if (par.updaterSymbol !== updaterSymbol ||
-            Optional.isNone(par.getSnapshot()) ||
-            this.#mut_isSkipping) {
-            return; // skip update
-        }
-        // set timer
-        this.#mut_isSkipping = true;
-        this.#mut_timerId = setTimeout(() => {
-            const sn = par.getSnapshot();
-            if (Optional.isNone(sn))
-                return;
-            this.startUpdate(sn.value);
-            this.#mut_isSkipping = false;
-        }, this.#milliSeconds);
-    }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
-    }
-    complete() {
-        this.#resetTimer();
-        super.complete();
-    }
-}
-
-export { auditTime };
-//# sourceMappingURL=audit-time.mjs.map

package/dist/core/operators/audit-time.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"audit-time.mjs","sources":["../../../src/core/operators/audit-time.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AACI,MAAM,SAAS,GAAG,CACvB,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,wBAAwB,CAC1B,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,wBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAE5B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,IACE,GAAG,CAAC,aAAa,KAAK,aAAa;AACnC,YAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;YAClC,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;;AAGA,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,YAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE;AAEzB,YAAA,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC;AAE1B,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/debounce-time.d.mts

@@ -1,51 +0,0 @@
-import { type KeepInitialValueOperator } from '../types/index.mjs';
-/**
- * Delays emissions from the source observable until a specified time has passed without another emission.
- * Useful for handling user input events like typing or scrolling.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The debounce duration in milliseconds
- * @returns An operator that debounces the observable
- *
- * @example
- * ```ts
- * //  Timeline (300ms debounce):
- * //
- * //  Time(ms)  0     100    200    300    400    500    600   ...   900   1000
- * //  input$    'h'   'he'   'hel'  'hello'
- * //  debounced$                                         'hello' (emitted after 300ms silence)
- * //
- * //  Explanation:
- * //  - At 0ms: 'h' is emitted, timer starts
- * //  - At 100ms: 'he' is emitted, timer resets
- * //  - At 200ms: 'hel' is emitted, timer resets
- * //  - At 300ms: 'hello' is emitted, timer resets
- * //  - At 600ms: No new emission for 300ms, 'hello' is finally emitted
- *
- * const input$ = source<string>();
- *
- * const debounced$ = input$.pipe(debounceTime(300));
- *
- * const mut_history: string[] = [];
- *
- * debounced$.subscribe((value) => {
- *   mut_history.push(value);
- * });
- *
- * input$.next('h');
- *
- * input$.next('he');
- *
- * input$.next('hel');
- *
- * input$.next('hello');
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 400);
- * });
- *
- * assert.deepStrictEqual(mut_history, ['hello']);
- * ```
- */
-export declare const debounceTime: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;
-//# sourceMappingURL=debounce-time.d.mts.map

package/dist/core/operators/debounce-time.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce-time.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce-time.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAC5B,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}