synstate 0.1.0 → 0.1.2

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

@@ -2,6 +2,64 @@ import { Optional, Result } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
+/**
+ * Converts any subscribable object into a SynState Observable.
+ * Works with objects that have a subscribe(onNext, onError, onComplete) method.
+ *
+ * @template A - The type of values from the subscribable
+ * @template E - The type of errors from the subscribable
+ * @param subscribable - An object with a subscribe method
+ * @returns An observable that wraps values in Result type
+ *
+ * @example
+ * ```ts
+ * //  Explanation:
+ * //  - fromSubscribable converts any subscribable object into a SynState Observable
+ * //  - Works with objects that have a subscribe(onNext, onError, onComplete) method
+ * //  - Wraps values in Result type for error handling
+ * //  - Useful for integrating with other reactive libraries or custom subscribables
+ *
+ * // Example: Converting a custom subscribable
+ * const customSubscribable = {
+ *   subscribe: (
+ *     onNext: (value: number) => void,
+ *     _onError?: (error: unknown) => void,
+ *     onComplete?: () => void,
+ *   ) => {
+ *     setTimeout(() => {
+ *       onNext(1);
+ *
+ *       onNext(2);
+ *
+ *       onNext(3);
+ *
+ *       onComplete?.();
+ *     }, 0);
+ *
+ *     return { unsubscribe: () => {} };
+ *   },
+ * };
+ *
+ * const observable$ = fromSubscribable<number>(customSubscribable);
+ *
+ * const mut_history: number[] = [];
+ *
+ * await new Promise<void>((resolve) => {
+ *   observable$.subscribe(
+ *     (result) => {
+ *       if (Result.isOk(result)) {
+ *         mut_history.push(result.value);
+ *       }
+ *     },
+ *     () => {
+ *       resolve();
+ *     },
+ *   );
+ * });
+ *
+ * assert.deepStrictEqual(mut_history, [1, 2, 3]);
+ * ```
+ */
 const fromSubscribable = (subscribable) => new FromSubscribableObservableClass(subscribable);
 class FromSubscribableObservableClass extends RootObservableClass {
     constructor(subscribable) {

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

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOO,MAAM,gBAAgB,GAAG,CAC9B,YAA6B,KAE7B,IAAI,+BAA+B,CAAC,YAAY;AAElD,MAAM,+BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,YAA6B,EAAA;QACvC,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,YAAY,CAAC,SAAS,CACpB,CAAC,SAAS,KAAI;YACZ,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AACxC,QAAA,CAAC,EACD,CAAC,KAAe,KAAI;AAClB,YAAA,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,GAAG;;YAER,KAAU,CACX,CACF;QACH,CAAC,EACD,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CACF;IACH;AACD;;;;"}
+{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,YAA6B,KAE7B,IAAI,+BAA+B,CAAC,YAAY;AAElD,MAAM,+BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,YAA6B,EAAA;QACvC,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,YAAY,CAAC,SAAS,CACpB,CAAC,SAAS,KAAI;YACZ,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AACxC,QAAA,CAAC,EACD,CAAC,KAAe,KAAI;AAClB,YAAA,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,GAAG;;YAER,KAAU,CACX,CACF;QACH,CAAC,EACD,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CACF;IACH;AACD;;;;"}

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

@@ -9,12 +9,37 @@ import { type IntervalObservable } from '../types/index.mjs';
  *
  * @example
  * ```ts
- * const tick$ = interval(1000);
+ * //  Timeline:
+ * //
+ * //  Time(s)   0     1     2     3     4     5
+ * //  tick$     0     1     2     3     4     5     ...
+ * //
+ * //  Explanation:
+ * //  - interval emits incrementing numbers at specified intervals
+ * //  - Starts at 0 and continues indefinitely
+ * //  - Useful for periodic tasks or animations
  *
- * tick$.subscribe((count) => {
- *   console.log(count);
+ * const tick$ = interval(100);
+ *
+ * const mut_history: number[] = [];
+ *
+ * const subscription = tick$.subscribe((count) => {
+ *   mut_history.push(count);
  * });
- * // logs: 0, 1, 2, 3, ... every second
+ *
+ * await new Promise((resolve) => {
+ *   setTimeout(resolve, 350);
+ * });
+ *
+ * subscription.unsubscribe();
+ *
+ * assert.isTrue(Arr.isArrayAtLeastLength(mut_history, 3));
+ *
+ * assert.deepStrictEqual(mut_history[0], 0);
+ *
+ * assert.deepStrictEqual(mut_history[1], 1);
+ *
+ * assert.deepStrictEqual(mut_history[2], 2);
  * ```
  */
 export declare const interval: (milliSeconds: number, startManually?: boolean) => IntervalObservable;

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

@@ -1 +1 @@
-{"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;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,GACnB,cAAc,MAAM,EACpB,gBAAgB,OAAO,KACtB,kBACuD,CAAC"}
+{"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

@@ -12,12 +12,37 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *
  * @example
  * ```ts
- * const tick$ = interval(1000);
+ * //  Timeline:
+ * //
+ * //  Time(s)   0     1     2     3     4     5
+ * //  tick$     0     1     2     3     4     5     ...
+ * //
+ * //  Explanation:
+ * //  - interval emits incrementing numbers at specified intervals
+ * //  - Starts at 0 and continues indefinitely
+ * //  - Useful for periodic tasks or animations
  *
- * tick$.subscribe((count) => {
- *   console.log(count);
+ * const tick$ = interval(100);
+ *
+ * const mut_history: number[] = [];
+ *
+ * const subscription = tick$.subscribe((count) => {
+ *   mut_history.push(count);
  * });
- * // logs: 0, 1, 2, 3, ... every second
+ *
+ * await new Promise((resolve) => {
+ *   setTimeout(resolve, 350);
+ * });
+ *
+ * subscription.unsubscribe();
+ *
+ * assert.isTrue(Arr.isArrayAtLeastLength(mut_history, 3));
+ *
+ * assert.deepStrictEqual(mut_history[0], 0);
+ *
+ * assert.deepStrictEqual(mut_history[1], 1);
+ *
+ * assert.deepStrictEqual(mut_history[2], 2);
  * ```
  */
 const interval = (milliSeconds, startManually) => new IntervalObservableClass(milliSeconds, startManually);

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

@@ -1 +1 @@
-{"version":3,"file":"interval.mjs","sources":["../../../src/core/create/interval.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;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;;;;"}
+{"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

@@ -9,11 +9,30 @@ import { type OfObservable } from '../types/index.mjs';
  *
  * @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);
  *
- * num$.subscribe((x) => {
- *   console.log(x);
- * }); // logs: 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>;

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

@@ -1 +1 @@
-{"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;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAClB,OAAO,CAAC,EACR,gBAAe,OAAe,KAC7B,YAAY,CAAC,CAAC,CAAmD,CAAC"}
+{"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

@@ -12,11 +12,30 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *
  * @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);
  *
- * num$.subscribe((x) => {
- *   console.log(x);
- * }); // logs: 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);

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

@@ -1 +1 @@
-{"version":3,"file":"of.mjs","sources":["../../../src/core/create/of.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;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;;;;"}
+{"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/create/source.d.mts

@@ -8,21 +8,40 @@ import { type InitializedSourceObservable, type SourceObservable } from '../type
  *
  * @example
  * ```ts
+ * //  Timeline:
+ * //
+ * //  count$    1     2     3     ...
+ * //
+ * //  Explanation:
+ * //  - source creates a new observable that you can manually emit values to
+ * //  - Use .next() to emit values
+ * //  - Foundation for building custom observables
+ *
  * const count$ = source<number>();
  *
+ * const mut_history: number[] = [];
+ *
  * count$.subscribe((value) => {
- *   console.log(value);
+ *   mut_history.push(value);
  * });
  *
  * count$.next(1); // logs: 1
  *
+ * assert.deepStrictEqual(mut_history, [1]);
+ *
  * count$.next(2); // logs: 2
+ *
+ * assert.deepStrictEqual(mut_history, [1, 2]);
+ *
+ * count$.next(3); // logs: 3
+ *
+ * assert.deepStrictEqual(mut_history, [1, 2, 3]);
  * ```
  */
 export declare function source<A>(initialValue: A): InitializedSourceObservable<A>;
 export declare function source<A>(): SourceObservable<A>;
 /**
- * Alias for `source()`. Creates a new Observable source.
+ * Alias for `source`. Creates a new Observable source.
  * @see source
  */
 export declare const subject: typeof source;

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

@@ -1 +1 @@
-{"version":3,"file":"source.d.mts","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAE3E,wBAAgB,MAAM,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAMjD;;;GAGG;AACH,eAAO,MAAM,OAAO,eAAS,CAAC"}
+{"version":3,"file":"source.d.mts","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAE3E,wBAAgB,MAAM,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAMjD;;;GAGG;AACH,eAAO,MAAM,OAAO,eAAS,CAAC"}

package/dist/core/create/source.mjs

@@ -6,10 +6,10 @@ function source(...args) {
     return new SourceObservableClass(...args);
 }
 /**
- * Alias for `source()`. Creates a new Observable source.
+ * Alias for `source`. Creates a new Observable source.
  * @see source
  */
-const subject = source; // alias
+const subject = source;
 class SourceObservableClass extends RootObservableClass {
     constructor(...args) {
         super({

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

@@ -1 +1 @@
-{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AA+BM,SAAU,MAAM,CAAI,GAAG,IAAkB,EAAA;AAC7C,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA;;;AAGG;AACI,MAAM,OAAO,GAAG,OAAO;AAE9B,MAAM,qBACJ,SAAQ,mBAAsB,CAAA;AAG9B,IAAA,WAAA,CAAY,GAAG,IAAkB,EAAA;AAC/B,QAAA,KAAK,CAAC;AACJ,YAAA,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI;kBAC7B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;kBACrB,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;IACJ;AAEA,IAAA,IAAI,CAAC,SAAY,EAAA;QACf,IAAI,IAAI,CAAC,WAAW;YAAE;AAEtB,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IAC7B;AACD;;;;"}
+{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkDM,SAAU,MAAM,CAAI,GAAG,IAAkB,EAAA;AAC7C,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA;;;AAGG;AACI,MAAM,OAAO,GAAG;AAEvB,MAAM,qBACJ,SAAQ,mBAAsB,CAAA;AAG9B,IAAA,WAAA,CAAY,GAAG,IAAkB,EAAA;AAC/B,QAAA,KAAK,CAAC;AACJ,YAAA,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI;kBAC7B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;kBACrB,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;IACJ;AAEA,IAAA,IAAI,CAAC,SAAY,EAAA;QACf,IAAI,IAAI,CAAC,WAAW;YAAE;AAEtB,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IAC7B;AACD;;;;"}

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

@@ -8,12 +8,31 @@ import { type TimerObservable } from '../types/index.mjs';
  *
  * @example
  * ```ts
- * const delayed$ = timer(1000);
+ * //  Timeline:
+ * //
+ * //  Time(ms)  0     ...   1000
+ * //  delayed$                X (emits and completes)
+ * //
+ * //  Explanation:
+ * //  - timer emits once after the specified delay, then completes
+ * //  - Useful for delayed actions or timeouts
  *
- * delayed$.subscribe(() => {
- *   console.log('1 second passed');
+ * const delayed$ = timer(100);
+ *
+ * const mut_history: number[] = [];
+ *
+ * await new Promise<void>((resolve) => {
+ *   delayed$.subscribe(
+ *     () => {
+ *       mut_history.push(1);
+ *     },
+ *     () => {
+ *       resolve();
+ *     },
+ *   );
  * });
- * // After 1 second, logs: 1 second passed
+ *
+ * assert.deepStrictEqual(mut_history, [1]);
  * ```
  */
 export declare const timer: (milliSeconds: number, startManually?: boolean) => TimerObservable;

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

@@ -1 +1 @@
-{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,GAChB,cAAc,MAAM,EACpB,gBAAe,OAAe,KAC7B,eAAwE,CAAC"}
+{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,GAChB,cAAc,MAAM,EACpB,gBAAe,OAAe,KAC7B,eAAwE,CAAC"}

package/dist/core/create/timer.mjs

@@ -11,12 +11,31 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *
  * @example
  * ```ts
- * const delayed$ = timer(1000);
+ * //  Timeline:
+ * //
+ * //  Time(ms)  0     ...   1000
+ * //  delayed$                X (emits and completes)
+ * //
+ * //  Explanation:
+ * //  - timer emits once after the specified delay, then completes
+ * //  - Useful for delayed actions or timeouts
  *
- * delayed$.subscribe(() => {
- *   console.log('1 second passed');
+ * const delayed$ = timer(100);
+ *
+ * const mut_history: number[] = [];
+ *
+ * await new Promise<void>((resolve) => {
+ *   delayed$.subscribe(
+ *     () => {
+ *       mut_history.push(1);
+ *     },
+ *     () => {
+ *       resolve();
+ *     },
+ *   );
  * });
- * // After 1 second, logs: 1 second passed
+ *
+ * assert.deepStrictEqual(mut_history, [1]);
  * ```
  */
 const timer = (milliSeconds, startManually = false) => new TimerObservableClass(milliSeconds, startManually);

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

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,KAAK,GAAG,CACnB,YAAoB,EACpB,aAAA,GAAyB,KAAK,KACV,IAAI,oBAAoB,CAAC,YAAY,EAAE,aAAa;AAE1E,MAAM,oBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAsB,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;QAE3B,IAAI,CAAC,aAAa,EAAE;YAClB,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,wCAAwC,CAAC;AAEtD,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAEnB,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;AAEtB,QAAA,OAAO,IAAI;IACb;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;;;;"}
+{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACI,MAAM,KAAK,GAAG,CACnB,YAAoB,EACpB,aAAA,GAAyB,KAAK,KACV,IAAI,oBAAoB,CAAC,YAAY,EAAE,aAAa;AAE1E,MAAM,oBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAsB,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;QAE3B,IAAI,CAAC,aAAa,EAAE;YAClB,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,wCAAwC,CAAC;AAEtD,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAEnB,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;AAEtB,QAAA,OAAO,IAAI;IACb;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/index.d.mts

@@ -2,6 +2,7 @@ export * from './class/index.mjs';
 export * from './combine/index.mjs';
 export * from './create/index.mjs';
 export * from './operators/index.mjs';
+export * from './predefined/index.mjs';
 export * from './types/index.mjs';
 export * from './utils/index.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/core/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}

package/dist/core/index.mjs

@@ -14,20 +14,32 @@ export { timer } from './create/timer.mjs';
 export { auditTime } from './operators/audit-time.mjs';
 export { debounceTime } from './operators/debounce-time.mjs';
 export { filter } from './operators/filter.mjs';
-export { attachIndex, getKey, map, mapOptional, mapResultErr, mapResultOk, mapTo, mapWithIndex, pluck, unwrapOptional, unwrapResultErr, unwrapResultOk, withIndex } from './operators/map-with-index.mjs';
+export { mapWithIndex } from './operators/map-with-index.mjs';
 export { flatMap, mergeMap } from './operators/merge-map.mjs';
 export { pairwise } from './operators/pairwise.mjs';
 export { scan } from './operators/scan.mjs';
 export { distinctUntilChanged, skipIfNoChange } from './operators/skip-if-no-change.mjs';
 export { skipUntil } from './operators/skip-until.mjs';
-export { skip, skipWhile } from './operators/skip-while.mjs';
+export { skipWhile } from './operators/skip-while.mjs';
 export { switchMap } from './operators/switch-map.mjs';
 export { takeUntil } from './operators/take-until.mjs';
-export { take, takeWhile } from './operators/take-while.mjs';
+export { takeWhile } from './operators/take-while.mjs';
 export { throttleTime } from './operators/throttle-time.mjs';
 export { withBuffered, withBufferedFrom } from './operators/with-buffered-from.mjs';
 export { withCurrentValueFrom, withLatestFrom } from './operators/with-current-value-from.mjs';
 export { withInitialValue } from './operators/with-initial-value.mjs';
+export { attachIndex, withIndex } from './predefined/operators/attach-index.mjs';
+export { mapOptional } from './predefined/operators/map-optional.mjs';
+export { mapResultErr } from './predefined/operators/map-result-err.mjs';
+export { mapResultOk } from './predefined/operators/map-result-ok.mjs';
+export { mapTo } from './predefined/operators/map-to.mjs';
+export { map } from './predefined/operators/map.mjs';
+export { getKey, pluck } from './predefined/operators/pluck.mjs';
+export { skip } from './predefined/operators/skip.mjs';
+export { take } from './predefined/operators/take.mjs';
+export { unwrapOptional } from './predefined/operators/unwrap-optional.mjs';
+export { unwrapResultErr } from './predefined/operators/unwrap-result-err.mjs';
+export { unwrapResultOk } from './predefined/operators/unwrap-result-ok.mjs';
 import 'ts-data-forge';
 export { isChildObservable, isManagerObservable, isRootObservable } from './types/observable.mjs';
 export { issueObservableId, issueSubscriberId, issueUpdaterSymbol } from './utils/id-maker.mjs';

package/dist/core/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,3 +1,62 @@
 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 +1 @@
-{"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,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"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

@@ -2,6 +2,65 @@ 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));

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

@@ -1 +1 @@
-{"version":3,"file":"audit-time.mjs","sources":["../../../src/core/operators/audit-time.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASO,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;;;;"}
+{"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

@@ -9,12 +9,27 @@ import { type KeepInitialValueOperator } from '../types/index.mjs';
  *
  * @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) => {
- *   console.log(value);
+ *   mut_history.push(value);
  * });
  *
  * input$.next('h');
@@ -24,7 +39,12 @@ import { type KeepInitialValueOperator } from '../types/index.mjs';
  * input$.next('hel');
  *
  * input$.next('hello');
- * // After 300ms of silence, logs: hello
+ *
+ * await new Promise((resolve) => {
+ *   setTimeout(resolve, 400);
+ * });
+ *
+ * assert.deepStrictEqual(mut_history, ['hello']);
  * ```
  */
 export declare const debounceTime: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;