synstate 2.0.1 → 3.0.0

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

@@ -1,27 +1,27 @@
-import { Optional, Result } from 'ts-data-forge';
+import { Result, Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
-const fromPromise = (promise) => new FromPromiseObservableClass(promise);
-class FromPromiseObservableClass extends RootObservableClass {
-  constructor(promise) {
-    super({ initialValue: Optional.none });
+const fromPromise = (promise) => createRootObservable(
+  { initialValue: Optional.none },
+  ({ startUpdate, isCompleted, complete }) => {
     promise.then((value) => {
-      if (this.isCompleted) return;
-      this.startUpdate(Result.ok(value));
+      if (isCompleted()) return;
+      startUpdate(Result.ok(value));
     }).catch((error) => {
-      if (this.isCompleted) return;
-      this.startUpdate(
+      if (isCompleted()) return;
+      startUpdate(
         Result.err(
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
           error
         )
       );
     }).finally(() => {
-      this.complete();
+      complete();
     });
+    return {};
   }
-}
+);
 
 export { fromPromise };
 //# sourceMappingURL=from-promise.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-promise.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type FromPromiseObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable from a Promise.\n * Emits Result.ok when the promise resolves, or Result.err when it rejects.\n *\n * @template A - The type of the resolved value\n * @template E - The type of the error\n * @param promise - The promise to convert to observable\n * @returns An observable that emits the promise result\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  promise     [pending...]  -> resolved/rejected\n * //  data$                        Ok(value) or Err(error)\n * //\n * //  Explanation:\n * //  - fromPromise converts a Promise into an observable\n * //  - Emits a Result type: Ok(value) on success, Err(error) on failure\n * //  - Completes after emitting the result\n * //  - Useful for integrating async operations into reactive flows\n *\n * const fetchData = async (): Promise<Readonly<{ value: number }>> =>\n *   ({\n *     value: 42,\n *   }) as const;\n *\n * const data$ = fromPromise(fetchData());\n *\n * const valueHistory: Readonly<{ value: number }>[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   data$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);\n * ```\n */\nexport const fromPromise = <A, E = unknown>(\n  promise: Promise<A>,\n): FromPromiseObservable<A, E> => new FromPromiseObservableClass(promise);\n\nclass FromPromiseObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromPromiseObservable<A, E>\n{\n  constructor(promise: Promise<A>) {\n    super({ initialValue: Optional.none });\n\n    promise\n      .then((value) => {\n        if (this.isCompleted) return;\n\n        this.startUpdate(Result.ok(value));\n      })\n      .catch((error: unknown) => {\n        if (this.isCompleted) return;\n\n        this.startUpdate(\n          Result.err(\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            error as E,\n          ),\n        );\n      })\n      .finally(() => {\n        this.complete();\n      });\n  }\n}\n"],"names":[],"mappings":";;;;AAmDO,MAAM,WAAA,GAAc,CACzB,OAAA,KACgC,IAAI,2BAA2B,OAAO;AAExE,MAAM,mCACI,mBAAA,CAEV;AAAA,EACE,YAAY,OAAA,EAAqB;AAC/B,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,OAAA,CACG,IAAA,CAAK,CAAC,KAAA,KAAU;AACf,MAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,MAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,KAAK,CAAC,CAAA;AAAA,IACnC,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAmB;AACzB,MAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,MAAA,IAAA,CAAK,WAAA;AAAA,QACH,MAAA,CAAO,GAAA;AAAA;AAAA,UAEL;AAAA;AACF,OACF;AAAA,IACF,CAAC,CAAA,CACA,OAAA,CAAQ,MAAM;AACb,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,CAAC,CAAA;AAAA,EACL;AACF;;;;"}
+{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-promise.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { createRootObservable } from '../base/index.mjs';\nimport { type FromPromiseObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable from a Promise.\n * Emits Result.ok when the promise resolves, or Result.err when it rejects.\n *\n * @template A - The type of the resolved value\n * @template E - The type of the error\n * @param promise - The promise to convert to observable\n * @returns An observable that emits the promise result\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  promise     [pending...]  -> resolved/rejected\n * //  data$                        Ok(value) or Err(error)\n * //\n * //  Explanation:\n * //  - fromPromise converts a Promise into an observable\n * //  - Emits a Result type: Ok(value) on success, Err(error) on failure\n * //  - Completes after emitting the result\n * //  - Useful for integrating async operations into reactive flows\n *\n * const fetchData = async (): Promise<Readonly<{ value: number }>> =>\n *   ({\n *     value: 42,\n *   }) as const;\n *\n * const data$ = fromPromise(fetchData());\n *\n * const valueHistory: Readonly<{ value: number }>[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   data$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);\n * ```\n */\nexport const fromPromise = <A, E = unknown>(\n  promise: Promise<A>,\n): FromPromiseObservable<A, E> =>\n  createRootObservable<Result<A, E>>(\n    { initialValue: Optional.none },\n    ({ startUpdate, isCompleted, complete }) => {\n      promise\n        .then((value) => {\n          if (isCompleted()) return;\n\n          startUpdate(Result.ok(value));\n        })\n        .catch((error: unknown) => {\n          if (isCompleted()) return;\n\n          startUpdate(\n            Result.err(\n              // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n              error as E,\n            ),\n          );\n        })\n        .finally(() => {\n          complete();\n        });\n\n      return {};\n    },\n  );\n"],"names":[],"mappings":";;;;AAmDO,MAAM,WAAA,GAAc,CACzB,OAAA,KAEA,oBAAA;AAAA,EACE,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAK;AAAA,EAC9B,CAAC,EAAE,WAAA,EAAa,WAAA,EAAa,UAAS,KAAM;AAC1C,IAAA,OAAA,CACG,IAAA,CAAK,CAAC,KAAA,KAAU;AACf,MAAA,IAAI,aAAY,EAAG;AAEnB,MAAA,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,KAAK,CAAC,CAAA;AAAA,IAC9B,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAmB;AACzB,MAAA,IAAI,aAAY,EAAG;AAEnB,MAAA,WAAA;AAAA,QACE,MAAA,CAAO,GAAA;AAAA;AAAA,UAEL;AAAA;AACF,OACF;AAAA,IACF,CAAC,CAAA,CACA,OAAA,CAAQ,MAAM;AACb,MAAA,QAAA,EAAS;AAAA,IACX,CAAC,CAAA;AAEH,IAAA,OAAO,EAAC;AAAA,EACV;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,gBAC/B,YAAY,CAAC,CAAC,CAAC,KAC5B,0BAA0B,CAAC,CAAC,EAAE,CAAC,CACiB,CAAC"}
+{"version":3,"file":"from-subscribable.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,gBAC/B,YAAY,CAAC,CAAC,CAAC,KAC5B,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAuB/B,CAAC"}

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

@@ -1,17 +1,16 @@
-import { Optional, Result } from 'ts-data-forge';
+import { Result, Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
-const fromSubscribable = (subscribable) => new FromSubscribableObservableClass(subscribable);
-class FromSubscribableObservableClass extends RootObservableClass {
-  constructor(subscribable) {
-    super({ initialValue: Optional.none });
+const fromSubscribable = (subscribable) => createRootObservable(
+  { initialValue: Optional.none },
+  ({ startUpdate, complete }) => {
     subscribable.subscribe(
       (nextValue) => {
-        this.startUpdate(Result.ok(nextValue));
+        startUpdate(Result.ok(nextValue));
       },
       (error) => {
-        this.startUpdate(
+        startUpdate(
           Result.err(
             // eslint-disable-next-line total-functions/no-unsafe-type-assertion
             error
@@ -19,11 +18,12 @@ class FromSubscribableObservableClass extends RootObservableClass {
         );
       },
       () => {
-        this.complete();
+        complete();
       }
     );
+    return {};
   }
-}
+);
 
 export { fromSubscribable };
 //# sourceMappingURL=from-subscribable.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport {\n  type FromSubscribableObservable,\n  type Subscribable,\n} from '../types/index.mjs';\n\n/**\n * Converts any subscribable object into a SynState Observable.\n * Works with objects that have a subscribe(onNext, onError, onComplete) method.\n *\n * @template A - The type of values from the subscribable\n * @template E - The type of errors from the subscribable\n * @param subscribable - An object with a subscribe method\n * @returns An observable that wraps values in Result type\n *\n * @example\n * ```ts\n * //  Explanation:\n * //  - fromSubscribable converts any subscribable object into a SynState Observable\n * //  - Works with objects that have a subscribe(onNext, onError, onComplete) method\n * //  - Wraps values in Result type for error handling\n * //  - Useful for integrating with other reactive libraries or custom subscribables\n *\n * // Example: Converting a custom subscribable\n * const customSubscribable = {\n *   subscribe: (\n *     onNext: (value: number) => void,\n *     _onError?: (error: unknown) => void,\n *     onComplete?: () => void,\n *   ) => {\n *     setTimeout(() => {\n *       onNext(1);\n *\n *       onNext(2);\n *\n *       onNext(3);\n *\n *       onComplete?.();\n *     }, 0);\n *\n *     return { unsubscribe: () => {} };\n *   },\n * } as const;\n *\n * const observable$ = fromSubscribable<number>(customSubscribable);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   observable$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport const fromSubscribable = <A, E = unknown>(\n  subscribable: Subscribable<A>,\n): FromSubscribableObservable<A, E> =>\n  new FromSubscribableObservableClass(subscribable);\n\nclass FromSubscribableObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromSubscribableObservable<A, E>\n{\n  constructor(subscribable: Subscribable<A>) {\n    super({ initialValue: Optional.none });\n\n    subscribable.subscribe(\n      (nextValue) => {\n        this.startUpdate(Result.ok(nextValue));\n      },\n      (error?: unknown) => {\n        this.startUpdate(\n          Result.err(\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            error as E,\n          ),\n        );\n      },\n      () => {\n        this.complete();\n      },\n    );\n  }\n}\n"],"names":[],"mappings":";;;;AAiEO,MAAM,gBAAA,GAAmB,CAC9B,YAAA,KAEA,IAAI,gCAAgC,YAAY;AAElD,MAAM,wCACI,mBAAA,CAEV;AAAA,EACE,YAAY,YAAA,EAA+B;AACzC,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,YAAA,CAAa,SAAA;AAAA,MACX,CAAC,SAAA,KAAc;AACb,QAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,SAAS,CAAC,CAAA;AAAA,MACvC,CAAA;AAAA,MACA,CAAC,KAAA,KAAoB;AACnB,QAAA,IAAA,CAAK,WAAA;AAAA,UACH,MAAA,CAAO,GAAA;AAAA;AAAA,YAEL;AAAA;AACF,SACF;AAAA,MACF,CAAA;AAAA,MACA,MAAM;AACJ,QAAA,IAAA,CAAK,QAAA,EAAS;AAAA,MAChB;AAAA,KACF;AAAA,EACF;AACF;;;;"}
+{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { createRootObservable } from '../base/index.mjs';\nimport {\n  type FromSubscribableObservable,\n  type Subscribable,\n} from '../types/index.mjs';\n\n/**\n * Converts any subscribable object into a SynState Observable.\n * Works with objects that have a subscribe(onNext, onError, onComplete) method.\n *\n * @template A - The type of values from the subscribable\n * @template E - The type of errors from the subscribable\n * @param subscribable - An object with a subscribe method\n * @returns An observable that wraps values in Result type\n *\n * @example\n * ```ts\n * //  Explanation:\n * //  - fromSubscribable converts any subscribable object into a SynState Observable\n * //  - Works with objects that have a subscribe(onNext, onError, onComplete) method\n * //  - Wraps values in Result type for error handling\n * //  - Useful for integrating with other reactive libraries or custom subscribables\n *\n * // Example: Converting a custom subscribable\n * const customSubscribable = {\n *   subscribe: (\n *     onNext: (value: number) => void,\n *     _onError?: (error: unknown) => void,\n *     onComplete?: () => void,\n *   ) => {\n *     setTimeout(() => {\n *       onNext(1);\n *\n *       onNext(2);\n *\n *       onNext(3);\n *\n *       onComplete?.();\n *     }, 0);\n *\n *     return { unsubscribe: () => {} };\n *   },\n * } as const;\n *\n * const observable$ = fromSubscribable<number>(customSubscribable);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   observable$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport const fromSubscribable = <A, E = unknown>(\n  subscribable: Subscribable<A>,\n): FromSubscribableObservable<A, E> =>\n  createRootObservable<Result<A, E>>(\n    { initialValue: Optional.none },\n    ({ startUpdate, complete }) => {\n      subscribable.subscribe(\n        (nextValue) => {\n          startUpdate(Result.ok(nextValue));\n        },\n        (error?: unknown) => {\n          startUpdate(\n            Result.err(\n              // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n              error as E,\n            ),\n          );\n        },\n        () => {\n          complete();\n        },\n      );\n\n      return {};\n    },\n  );\n"],"names":[],"mappings":";;;;AAiEO,MAAM,gBAAA,GAAmB,CAC9B,YAAA,KAEA,oBAAA;AAAA,EACE,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAK;AAAA,EAC9B,CAAC,EAAE,WAAA,EAAa,QAAA,EAAS,KAAM;AAC7B,IAAA,YAAA,CAAa,SAAA;AAAA,MACX,CAAC,SAAA,KAAc;AACb,QAAA,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,SAAS,CAAC,CAAA;AAAA,MAClC,CAAA;AAAA,MACA,CAAC,KAAA,KAAoB;AACnB,QAAA,WAAA;AAAA,UACE,MAAA,CAAO,GAAA;AAAA;AAAA,YAEL;AAAA;AACF,SACF;AAAA,MACF,CAAA;AAAA,MACA,MAAM;AACJ,QAAA,QAAA,EAAS;AAAA,MACX;AAAA,KACF;AAEA,IAAA,OAAO,EAAC;AAAA,EACV;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"just.d.mts","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,yBAAyB,CAAC,CAAC,CASpE,CAAC"}
+{"version":3,"file":"just.d.mts","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,yBAAyB,CAAC,CAAC,CAUpE,CAAC"}

package/dist/core/create/just.mjs

@@ -1,11 +1,12 @@
 import { Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
 const just = (value) => {
-  const obs = new RootObservableClass({
-    initialValue: Optional.some(value)
-  });
+  const obs = createRootObservable(
+    { initialValue: Optional.some(value) },
+    () => ({})
+  );
   obs.complete();
   return obs;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"just.mjs","sources":["../../../src/core/create/just.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type InitializedRootObservable } from '../types/index.mjs';\n\n/**\n * Creates an Observable that holds a single static value and immediately\n * completes. Useful inside `switchMap` to emit a fallback value when no\n * asynchronous work is needed.\n *\n * @template A - The type of the value\n * @param value - The value to emit\n * @returns An initialized Observable that holds the value and is already completed\n *\n * @example\n * ```ts\n * const greeting$ = just('hello');\n *\n * const valueHistory: string[] = [];\n *\n * greeting$.subscribe(\n *   (value) => {\n *     valueHistory.push(value);\n *   },\n *   () => {\n *     // onComplete — called immediately since just() completes right away\n *   },\n * );\n *\n * assert.deepStrictEqual(valueHistory, ['hello']);\n *\n * assert.strictEqual(greeting$.isCompleted, true);\n * ```\n */\nexport const just = <const A,>(value: A): InitializedRootObservable<A> => {\n  const obs = new RootObservableClass<A>({\n    initialValue: Optional.some(value),\n  });\n\n  obs.complete();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return obs as InitializedRootObservable<A>;\n};\n"],"names":[],"mappings":";;;;AAiCO,MAAM,IAAA,GAAO,CAAW,KAAA,KAA2C;AACxE,EAAA,MAAM,GAAA,GAAM,IAAI,mBAAA,CAAuB;AAAA,IACrC,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,KAAK;AAAA,GAClC,CAAA;AAED,EAAA,GAAA,CAAI,QAAA,EAAS;AAGb,EAAA,OAAO,GAAA;AACT;;;;"}
+{"version":3,"file":"just.mjs","sources":["../../../src/core/create/just.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createRootObservable } from '../base/index.mjs';\nimport { type InitializedRootObservable } from '../types/index.mjs';\n\n/**\n * Creates an Observable that holds a single static value and immediately\n * completes. Useful inside `switchMap` to emit a fallback value when no\n * asynchronous work is needed.\n *\n * @template A - The type of the value\n * @param value - The value to emit\n * @returns An initialized Observable that holds the value and is already completed\n *\n * @example\n * ```ts\n * const greeting$ = just('hello');\n *\n * const valueHistory: string[] = [];\n *\n * greeting$.subscribe(\n *   (value) => {\n *     valueHistory.push(value);\n *   },\n *   () => {\n *     // onComplete — called immediately since just() completes right away\n *   },\n * );\n *\n * assert.deepStrictEqual(valueHistory, ['hello']);\n *\n * assert.strictEqual(greeting$.isCompleted, true);\n * ```\n */\nexport const just = <const A,>(value: A): InitializedRootObservable<A> => {\n  const obs = createRootObservable<A>(\n    { initialValue: Optional.some(value) },\n    () => ({}),\n  );\n\n  obs.complete();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return obs as InitializedRootObservable<A>;\n};\n"],"names":[],"mappings":";;;;AAiCO,MAAM,IAAA,GAAO,CAAW,KAAA,KAA2C;AACxE,EAAA,MAAM,GAAA,GAAM,oBAAA;AAAA,IACV,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,KAAK,CAAA,EAAE;AAAA,IACrC,OAAO,EAAC;AAAA,GACV;AAEA,EAAA,GAAA,CAAI,QAAA,EAAS;AAGb,EAAA,OAAO,GAAA;AACT;;;;"}

package/dist/core/create/source.mjs

@@ -1,20 +1,19 @@
 import { Optional, Arr } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
 function source(...args) {
-  return new SourceObservableClass(...args);
-}
-class SourceObservableClass extends RootObservableClass {
-  constructor(...args) {
-    super({
+  return createRootObservable(
+    {
       initialValue: Arr.isNonEmpty(args) ? Optional.some(args[0]) : Optional.none
-    });
-  }
-  next(nextValue) {
-    if (this.isCompleted) return;
-    this.startUpdate(nextValue);
-  }
+    },
+    ({ startUpdate, isCompleted }) => ({
+      next: (nextValue) => {
+        if (isCompleted()) return;
+        startUpdate(nextValue);
+      }
+    })
+  );
 }
 
 export { source };

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

@@ -1 +1 @@
-{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport {\n  type InitializedSourceObservable,\n  type SourceObservable,\n} from '../types/index.mjs';\n\n/**\n * Creates a new Observable source that can manually emit values.\n * This is the primary way to create root observables that start reactive chains.\n *\n * @template A - The type of values emitted by the source\n * @returns A SourceObservable that can emit values via `.next()` method\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  count$    1     2     3     ...\n * //\n * //  Explanation:\n * //  - source creates a new observable that you can manually emit values to\n * //  - Use .next() to emit values\n * //  - Foundation for building custom observables\n *\n * const count$ = source<number>();\n *\n * const valueHistory: number[] = [];\n *\n * count$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * count$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * count$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * count$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport function source<const A>(\n  initialValue: A,\n): InitializedSourceObservable<A>;\n\nexport function source<const A>(): SourceObservable<A>;\n\nexport function source<const A>(...args: readonly A[]): SourceObservable<A> {\n  return new SourceObservableClass<A>(...args);\n}\n\nclass SourceObservableClass<A>\n  extends RootObservableClass<A>\n  implements SourceObservable<A>\n{\n  constructor(...args: readonly A[]) {\n    super({\n      initialValue: Arr.isNonEmpty(args)\n        ? Optional.some(args[0])\n        : Optional.none,\n    });\n  }\n\n  next(nextValue: A): void {\n    if (this.isCompleted) return;\n\n    this.startUpdate(nextValue);\n  }\n}\n"],"names":[],"mappings":";;;;AAoDO,SAAS,UAAmB,IAAA,EAAyC;AAC1E,EAAA,OAAO,IAAI,qBAAA,CAAyB,GAAG,IAAI,CAAA;AAC7C;AAEA,MAAM,8BACI,mBAAA,CAEV;AAAA,EACE,eAAe,IAAA,EAAoB;AACjC,IAAA,KAAA,CAAM;AAAA,MACJ,YAAA,EAAc,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,GAC7B,QAAA,CAAS,IAAA,CAAK,IAAA,CAAK,CAAC,CAAC,CAAA,GACrB,QAAA,CAAS;AAAA,KACd,CAAA;AAAA,EACH;AAAA,EAEA,KAAK,SAAA,EAAoB;AACvB,IAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,IAAA,IAAA,CAAK,YAAY,SAAS,CAAA;AAAA,EAC5B;AACF;;;;"}
+{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { createRootObservable } from '../base/index.mjs';\nimport {\n  type InitializedSourceObservable,\n  type SourceObservable,\n} from '../types/index.mjs';\n\n/**\n * Creates a new Observable source that can manually emit values.\n * This is the primary way to create root observables that start reactive chains.\n *\n * @template A - The type of values emitted by the source\n * @returns A SourceObservable that can emit values via `.next()` method\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  count$    1     2     3     ...\n * //\n * //  Explanation:\n * //  - source creates a new observable that you can manually emit values to\n * //  - Use .next() to emit values\n * //  - Foundation for building custom observables\n *\n * const count$ = source<number>();\n *\n * const valueHistory: number[] = [];\n *\n * count$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * count$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * count$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * count$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport function source<const A>(\n  initialValue: A,\n): InitializedSourceObservable<A>;\n\nexport function source<const A>(): SourceObservable<A>;\n\nexport function source<const A>(...args: readonly A[]): SourceObservable<A> {\n  return createRootObservable<A, Readonly<{ next: (nextValue: A) => void }>>(\n    {\n      initialValue: Arr.isNonEmpty(args)\n        ? Optional.some(args[0])\n        : Optional.none,\n    },\n    ({ startUpdate, isCompleted }) => ({\n      next: (nextValue: A) => {\n        if (isCompleted()) return;\n\n        startUpdate(nextValue);\n      },\n    }),\n  );\n}\n"],"names":[],"mappings":";;;;AAoDO,SAAS,UAAmB,IAAA,EAAyC;AAC1E,EAAA,OAAO,oBAAA;AAAA,IACL;AAAA,MACE,YAAA,EAAc,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,GAC7B,QAAA,CAAS,IAAA,CAAK,IAAA,CAAK,CAAC,CAAC,CAAA,GACrB,QAAA,CAAS;AAAA,KACf;AAAA,IACA,CAAC,EAAE,WAAA,EAAa,WAAA,EAAY,MAAO;AAAA,MACjC,IAAA,EAAM,CAAC,SAAA,KAAiB;AACtB,QAAA,IAAI,aAAY,EAAG;AAEnB,QAAA,WAAA,CAAY,SAAS,CAAA;AAAA,MACvB;AAAA,KACF;AAAA,GACF;AACF;;;;"}

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,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,iBACF,MAAM,YACV,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eACsE,CAAC"}
+{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,iBACF,MAAM,YACV,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eA2CF,CAAC"}

package/dist/core/create/timer.mjs

@@ -1,46 +1,40 @@
 import { Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
-const timer = (milliSeconds, options) => new TimerObservableClass(milliSeconds, options?.startManually ?? false);
-class TimerObservableClass extends RootObservableClass {
-  #milliSeconds;
-  #mut_timerId;
-  #mut_isStarted;
-  constructor(milliSeconds, startManually) {
-    super({ initialValue: Optional.none });
-    this.#milliSeconds = milliSeconds;
-    this.#mut_timerId = void 0;
-    this.#mut_isStarted = false;
-    if (!startManually) {
-      this.start();
+const timer = (milliSeconds, options) => {
+  let mut_timerId = void 0;
+  let mut_isStarted = false;
+  const resetTimer = () => {
+    if (mut_timerId !== void 0) {
+      clearTimeout(mut_timerId);
     }
+  };
+  const observable = createRootObservable(
+    { initialValue: Optional.none, onComplete: resetTimer },
+    ({ startUpdate, isCompleted, complete }) => ({
+      start: () => {
+        if (mut_isStarted) {
+          console.warn("cannot start twice");
+          return;
+        }
+        mut_isStarted = true;
+        if (isCompleted()) {
+          console.warn("cannot restart stopped TimerObservable");
+          return;
+        }
+        mut_timerId = setTimeout(() => {
+          startUpdate(0);
+          complete();
+        }, milliSeconds);
+      }
+    })
+  );
+  if (!(options?.startManually ?? false)) {
+    observable.start();
   }
-  #resetTimer() {
-    if (this.#mut_timerId !== void 0) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-  start() {
-    if (this.#mut_isStarted) {
-      console.warn("cannot start twice");
-      return;
-    }
-    this.#mut_isStarted = true;
-    if (this.isCompleted) {
-      console.warn("cannot restart stopped TimerObservable");
-      return;
-    }
-    this.#mut_timerId = setTimeout(() => {
-      this.startUpdate(0);
-      this.complete();
-    }, this.#milliSeconds);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
+  return observable;
+};
 
 export { timer };
 //# sourceMappingURL=timer.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type TimerId, type TimerObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable that emits 0 after a specified delay and then completes.\n *\n * @param milliSeconds - The delay in milliseconds before emission\n * @param startManually - If true, waits for manual start (default: false)\n * @returns An observable that emits after delay\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  Time(ms)  0     ...   1000\n * //  delayed$                X (emits and completes)\n * //\n * //  Explanation:\n * //  - timer emits once after the specified delay, then completes\n * //  - Useful for delayed actions or timeouts\n *\n * const delayed$ = timer(100);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   delayed$.subscribe(\n *     () => {\n *       valueHistory.push(1);\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n * ```\n */\nexport const timer = (\n  milliSeconds: number,\n  options?: Readonly<{\n    startManually?: boolean;\n  }>,\n): TimerObservable =>\n  new TimerObservableClass(milliSeconds, options?.startManually ?? false);\n\nclass TimerObservableClass\n  extends RootObservableClass<0>\n  implements TimerObservable\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isStarted: boolean;\n\n  constructor(milliSeconds: number, startManually: boolean) {\n    super({ initialValue: Optional.none });\n\n    this.#milliSeconds = milliSeconds;\n\n    this.#mut_timerId = undefined;\n\n    this.#mut_isStarted = false;\n\n    if (!startManually) {\n      this.start();\n    }\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  start(): void {\n    if (this.#mut_isStarted) {\n      console.warn('cannot start twice');\n\n      return;\n    }\n\n    this.#mut_isStarted = true;\n\n    if (this.isCompleted) {\n      console.warn('cannot restart stopped TimerObservable');\n\n      return;\n    }\n\n    this.#mut_timerId = setTimeout(() => {\n      this.startUpdate(0);\n\n      this.complete();\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwCO,MAAM,KAAA,GAAQ,CACnB,YAAA,EACA,OAAA,KAIA,IAAI,oBAAA,CAAqB,YAAA,EAAc,OAAA,EAAS,aAAA,IAAiB,KAAK;AAExE,MAAM,6BACI,mBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,cAAA;AAAA,EAEA,WAAA,CAAY,cAAsB,aAAA,EAAwB;AACxD,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAErB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,cAAA,GAAiB,KAAA;AAEtB,IAAA,IAAI,CAAC,aAAA,EAAe;AAClB,MAAA,IAAA,CAAK,KAAA,EAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAEA,KAAA,GAAc;AACZ,IAAA,IAAI,KAAK,cAAA,EAAgB;AACvB,MAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,cAAA,GAAiB,IAAA;AAEtB,IAAA,IAAI,KAAK,WAAA,EAAa;AACpB,MAAA,OAAA,CAAQ,KAAK,wCAAwC,CAAA;AAErD,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAA,CAAK,YAAY,CAAC,CAAA;AAElB,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createRootObservable } from '../base/index.mjs';\nimport { type TimerId, type TimerObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable that emits 0 after a specified delay and then completes.\n *\n * @param milliSeconds - The delay in milliseconds before emission\n * @param startManually - If true, waits for manual start (default: false)\n * @returns An observable that emits after delay\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  Time(ms)  0     ...   1000\n * //  delayed$                X (emits and completes)\n * //\n * //  Explanation:\n * //  - timer emits once after the specified delay, then completes\n * //  - Useful for delayed actions or timeouts\n *\n * const delayed$ = timer(100);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   delayed$.subscribe(\n *     () => {\n *       valueHistory.push(1);\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n * ```\n */\nexport const timer = (\n  milliSeconds: number,\n  options?: Readonly<{\n    startManually?: boolean;\n  }>,\n): TimerObservable => {\n  let mut_timerId: TimerId | undefined = undefined;\n\n  let mut_isStarted = false;\n\n  const resetTimer = (): void => {\n    if (mut_timerId !== undefined) {\n      clearTimeout(mut_timerId);\n    }\n  };\n\n  const observable = createRootObservable<0, Readonly<{ start: () => void }>>(\n    { initialValue: Optional.none, onComplete: resetTimer },\n    ({ startUpdate, isCompleted, complete }) => ({\n      start: () => {\n        if (mut_isStarted) {\n          console.warn('cannot start twice');\n\n          return;\n        }\n\n        mut_isStarted = true;\n\n        if (isCompleted()) {\n          console.warn('cannot restart stopped TimerObservable');\n\n          return;\n        }\n\n        mut_timerId = setTimeout(() => {\n          startUpdate(0);\n\n          complete();\n        }, milliSeconds);\n      },\n    }),\n  );\n\n  if (!(options?.startManually ?? false)) {\n    observable.start();\n  }\n\n  return observable;\n};\n"],"names":[],"mappings":";;;;AAwCO,MAAM,KAAA,GAAQ,CACnB,YAAA,EACA,OAAA,KAGoB;AACpB,EAAA,IAAI,WAAA,GAAmC,MAAA;AAEvC,EAAA,IAAI,aAAA,GAAgB,KAAA;AAEpB,EAAA,MAAM,aAAa,MAAY;AAC7B,IAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,MAAA,YAAA,CAAa,WAAW,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAEA,EAAA,MAAM,UAAA,GAAa,oBAAA;AAAA,IACjB,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,YAAY,UAAA,EAAW;AAAA,IACtD,CAAC,EAAE,WAAA,EAAa,WAAA,EAAa,UAAS,MAAO;AAAA,MAC3C,OAAO,MAAM;AACX,QAAA,IAAI,aAAA,EAAe;AACjB,UAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,UAAA;AAAA,QACF;AAEA,QAAA,aAAA,GAAgB,IAAA;AAEhB,QAAA,IAAI,aAAY,EAAG;AACjB,UAAA,OAAA,CAAQ,KAAK,wCAAwC,CAAA;AAErD,UAAA;AAAA,QACF;AAEA,QAAA,WAAA,GAAc,WAAW,MAAM;AAC7B,UAAA,WAAA,CAAY,CAAC,CAAA;AAEb,UAAA,QAAA,EAAS;AAAA,QACX,GAAG,YAAY,CAAA;AAAA,MACjB;AAAA,KACF;AAAA,GACF;AAEA,EAAA,IAAI,EAAE,OAAA,EAAS,aAAA,IAAiB,KAAA,CAAA,EAAQ;AACtC,IAAA,UAAA,CAAW,KAAA,EAAM;AAAA,EACnB;AAEA,EAAA,OAAO,UAAA;AACT;;;;"}

package/dist/core/index.d.mts

@@ -1,4 +1,3 @@
-export * from './class/index.mjs';
 export * from './combine/index.mjs';
 export * from './create/index.mjs';
 export * from './operators/index.mjs';

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,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

package/dist/core/index.mjs

@@ -1,6 +1,3 @@
-export { AsyncChildObservableClass, InitializedSyncChildObservableClass, SyncChildObservableClass } from './class/child-observable-class.mjs';
-export { ObservableBaseClass } from './class/observable-base-class.mjs';
-export { RootObservableClass } from './class/root-observable-class.mjs';
 export { combine, combineLatest } from './combine/combine.mjs';
 export { merge } from './combine/merge.mjs';
 export { zip } from './combine/zip.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.d.mts.map

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

package/dist/core/operators/audit.mjs

@@ -1,50 +1,42 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createAsyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const audit = (milliSeconds) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new AuditObservableClass(
+  ((parentObservable) => createAuditObservable(
     parentObservable,
     milliSeconds
   ))
 );
-class AuditObservableClass extends AsyncChildObservableClass {
-  #milliSeconds;
-  #mut_timerId;
-  #mut_isSkipping;
-  constructor(parentObservable, milliSeconds) {
-    super({
-      parents: [parentObservable],
-      initialValue: parentObservable.getSnapshot()
-    });
-    this.#mut_isSkipping = false;
-    this.#mut_timerId = void 0;
-    this.#milliSeconds = milliSeconds;
-  }
-  #resetTimer() {
-    if (this.#mut_timerId !== void 0) {
-      clearTimeout(this.#mut_timerId);
+const createAuditObservable = (parentObservable, milliSeconds) => {
+  let mut_timerId = void 0;
+  let mut_isSkipping = false;
+  const resetTimer = () => {
+    if (mut_timerId !== void 0) {
+      clearTimeout(mut_timerId);
     }
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    if (par.updateToken !== updateToken || Optional.isNone(par.getSnapshot()) || this.#mut_isSkipping) {
-      return;
+  };
+  return createAsyncChildObservable(
+    {
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+      onComplete: resetTimer
+    },
+    ({ startUpdate }) => (updateToken) => {
+      if (mut_isSkipping || parentObservable.updateToken !== updateToken || Optional.isNone(parentObservable.getSnapshot())) {
+        return;
+      }
+      mut_isSkipping = true;
+      mut_timerId = setTimeout(() => {
+        const sn = parentObservable.getSnapshot();
+        if (Optional.isNone(sn)) return;
+        startUpdate(sn.value);
+        mut_isSkipping = false;
+      }, milliSeconds);
     }
-    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);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
+  );
+};
 
 export { audit };
 //# sourceMappingURL=audit.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"audit.mjs","sources":["../../../src/core/operators/audit.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type AuditOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.\n *\n * Unlike `throttle` which emits the first value, `audit` emits the last value.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The audit time window in milliseconds\n * @returns An operator that audits emissions from the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms audit):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->\n * //  audited$               2           3                   11          14   (emitted at end of window)\n * //\n * //  Explanation:\n * //  - audit emits the LAST value received during each time window\n * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST\n * //  - Useful when you want the most recent value after a burst of events\n *\n * const input$ = source<number>();\n *\n * const audited$ = input$.pipe(audit(250));\n *\n * const valueHistory: number[] = [];\n *\n * audited$.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 * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2]);\n *\n * input$.next(3);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);\n * ```\n */\nexport const audit = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new AuditObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass AuditObservableClass<A>\n  extends AsyncChildObservableClass<A, readonly [A]>\n  implements AuditOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isSkipping: boolean;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_isSkipping = false;\n\n    this.#mut_timerId = undefined;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    if (\n      par.updateToken !== updateToken ||\n      Optional.isNone(par.getSnapshot()) ||\n      this.#mut_isSkipping\n    ) {\n      return; // skip update\n    }\n\n    // set timer\n    this.#mut_isSkipping = true;\n\n    this.#mut_timerId = setTimeout(() => {\n      const sn = par.getSnapshot();\n\n      if (Optional.isNone(sn)) return;\n\n      this.startUpdate(sn.value);\n\n      this.#mut_isSkipping = false;\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwGO,MAAM,QAAQ,CACnB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,oBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,6BACI,yBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,eAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAEvB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,IACE,GAAA,CAAI,WAAA,KAAgB,WAAA,IACpB,QAAA,CAAS,MAAA,CAAO,IAAI,WAAA,EAAa,CAAA,IACjC,IAAA,CAAK,eAAA,EACL;AACA,MAAA;AAAA,IACF;AAGA,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AAEvB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,MAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,KAAK,CAAA;AAEzB,MAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAAA,IACzB,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"audit.mjs","sources":["../../../src/core/operators/audit.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createAsyncChildObservable } from '../base/index.mjs';\nimport {\n  type AuditOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n} from '../types/index.mjs';\n\n/**\n * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.\n *\n * Unlike `throttle` which emits the first value, `audit` emits the last value.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The audit time window in milliseconds\n * @returns An operator that audits emissions from the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms audit):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->\n * //  audited$               2           3                   11          14   (emitted at end of window)\n * //\n * //  Explanation:\n * //  - audit emits the LAST value received during each time window\n * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST\n * //  - Useful when you want the most recent value after a burst of events\n *\n * const input$ = source<number>();\n *\n * const audited$ = input$.pipe(audit(250));\n *\n * const valueHistory: number[] = [];\n *\n * audited$.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 * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2]);\n *\n * input$.next(3);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);\n * ```\n */\nexport const audit = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    createAuditObservable(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nconst createAuditObservable = <A,>(\n  parentObservable: Observable<A>,\n  milliSeconds: number,\n): AuditOperatorObservable<A> => {\n  let mut_timerId: TimerId | undefined = undefined;\n\n  let mut_isSkipping = false;\n\n  const resetTimer = (): void => {\n    if (mut_timerId !== undefined) {\n      clearTimeout(mut_timerId);\n    }\n  };\n\n  return createAsyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n      onComplete: resetTimer,\n    },\n    ({ startUpdate }) =>\n      (updateToken) => {\n        if (\n          mut_isSkipping ||\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(parentObservable.getSnapshot())\n        ) {\n          return; // skip update\n        }\n\n        // set timer\n        mut_isSkipping = true;\n\n        mut_timerId = setTimeout(() => {\n          const sn = parentObservable.getSnapshot();\n\n          if (Optional.isNone(sn)) return;\n\n          startUpdate(sn.value);\n\n          mut_isSkipping = false;\n        }, milliSeconds);\n      },\n  );\n};\n"],"names":[],"mappings":";;;;AAuGO,MAAM,QAAQ,CACnB,YAAA;AAAA;AAAA,GAGC,CAAC,gBAAA,KACA,qBAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,qBAAA,GAAwB,CAC5B,gBAAA,EACA,YAAA,KAC+B;AAC/B,EAAA,IAAI,WAAA,GAAmC,MAAA;AAEvC,EAAA,IAAI,cAAA,GAAiB,KAAA;AAErB,EAAA,MAAM,aAAa,MAAY;AAC7B,IAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,MAAA,YAAA,CAAa,WAAW,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAEA,EAAA,OAAO,0BAAA;AAAA,IACL;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA,EAAY;AAAA,MAC3C,UAAA,EAAY;AAAA,KACd;AAAA,IACA,CAAC,EAAE,WAAA,EAAY,KACb,CAAC,WAAA,KAAgB;AACf,MAAA,IACE,cAAA,IACA,iBAAiB,WAAA,KAAgB,WAAA,IACjC,SAAS,MAAA,CAAO,gBAAA,CAAiB,WAAA,EAAa,CAAA,EAC9C;AACA,QAAA;AAAA,MACF;AAGA,MAAA,cAAA,GAAiB,IAAA;AAEjB,MAAA,WAAA,GAAc,WAAW,MAAM;AAC7B,QAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,QAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,QAAA,WAAA,CAAY,GAAG,KAAK,CAAA;AAEpB,QAAA,cAAA,GAAiB,KAAA;AAAA,MACnB,GAAG,YAAY,CAAA;AAAA,IACjB;AAAA,GACJ;AACF,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,gBACV,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,gBACV,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/debounce.mjs

@@ -1,47 +1,40 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createAsyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const debounce = (milliSeconds) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new DebounceObservableClass(
+  ((parentObservable) => createDebounceObservable(
     parentObservable,
     milliSeconds
   ))
 );
-class DebounceObservableClass extends AsyncChildObservableClass {
-  #milliSeconds;
-  #mut_timerId;
-  constructor(parentObservable, milliSeconds) {
-    super({
-      parents: [parentObservable],
-      initialValue: parentObservable.getSnapshot()
-    });
-    this.#mut_timerId = void 0;
-    this.#milliSeconds = milliSeconds;
-  }
-  #resetTimer() {
-    if (this.#mut_timerId !== void 0) {
-      clearTimeout(this.#mut_timerId);
+const createDebounceObservable = (parentObservable, milliSeconds) => {
+  let mut_timerId = void 0;
+  const resetTimer = () => {
+    if (mut_timerId !== void 0) {
+      clearTimeout(mut_timerId);
     }
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return;
+  };
+  return createAsyncChildObservable(
+    {
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+      onComplete: resetTimer
+    },
+    ({ startUpdate }) => (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
+      }
+      resetTimer();
+      mut_timerId = setTimeout(() => {
+        if (Optional.isNone(sn)) return;
+        startUpdate(sn.value);
+      }, milliSeconds);
     }
-    this.#resetTimer();
-    this.#mut_timerId = setTimeout(() => {
-      if (Optional.isNone(sn)) return;
-      this.startUpdate(sn.value);
-    }, this.#milliSeconds);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
+  );
+};
 
 export { debounce };
 //# sourceMappingURL=debounce.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.mjs","sources":["../../../src/core/operators/debounce.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DebounceOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Delays emissions from the source observable until a specified time has passed without another emission.\n * Useful for handling user input events like typing or scrolling.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The debounce duration in milliseconds\n * @returns An operator that debounces the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms debounce):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //                               |- 250ms ->                         |- 250ms ->\n * //  debounced$                   3                                             14   (emitted after 250ms silence)\n * //\n * //  Explanation:\n * //  - debounce emits the latest value AFTER a quiet period with no new emissions\n * //  - Unlike audit (which uses a fixed window), debounce resets the timer on every emission\n * //  - Useful for search-as-you-type and form validation\n *\n * const input$ = source<number>();\n *\n * const debounced$ = input$.pipe(debounce(250));\n *\n * const valueHistory: number[] = [];\n *\n * debounced$.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 * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * await sleep(100);\n *\n * input$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * await sleep(100);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3, 14]);\n * ```\n */\nexport const debounce = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new DebounceObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass DebounceObservableClass<A>\n  extends AsyncChildObservableClass<A, readonly [A]>\n  implements DebounceOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_timerId = undefined;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.#resetTimer();\n\n    // set timer\n    this.#mut_timerId = setTimeout(() => {\n      if (Optional.isNone(sn)) return;\n\n      this.startUpdate(sn.value);\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA+FO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,uBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,gCACI,yBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,WAAA,EAAY;AAGjB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,KAAK,CAAA;AAAA,IAC3B,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"debounce.mjs","sources":["../../../src/core/operators/debounce.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createAsyncChildObservable } from '../base/index.mjs';\nimport {\n  type DebounceOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n} from '../types/index.mjs';\n\n/**\n * Delays emissions from the source observable until a specified time has passed without another emission.\n * Useful for handling user input events like typing or scrolling.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The debounce duration in milliseconds\n * @returns An operator that debounces the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms debounce):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //                               |- 250ms ->                         |- 250ms ->\n * //  debounced$                   3                                             14   (emitted after 250ms silence)\n * //\n * //  Explanation:\n * //  - debounce emits the latest value AFTER a quiet period with no new emissions\n * //  - Unlike audit (which uses a fixed window), debounce resets the timer on every emission\n * //  - Useful for search-as-you-type and form validation\n *\n * const input$ = source<number>();\n *\n * const debounced$ = input$.pipe(debounce(250));\n *\n * const valueHistory: number[] = [];\n *\n * debounced$.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 * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * await sleep(100);\n *\n * input$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * await sleep(100);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3, 14]);\n * ```\n */\nexport const debounce = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    createDebounceObservable(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nconst createDebounceObservable = <A,>(\n  parentObservable: Observable<A>,\n  milliSeconds: number,\n): DebounceOperatorObservable<A> => {\n  let mut_timerId: TimerId | undefined = undefined;\n\n  const resetTimer = (): void => {\n    if (mut_timerId !== undefined) {\n      clearTimeout(mut_timerId);\n    }\n  };\n\n  return createAsyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n      onComplete: resetTimer,\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        resetTimer();\n\n        // set timer\n        mut_timerId = setTimeout(() => {\n          if (Optional.isNone(sn)) return;\n\n          startUpdate(sn.value);\n        }, milliSeconds);\n      },\n  );\n};\n"],"names":[],"mappings":";;;;AA8FO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,gBAAA,KACA,wBAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,wBAAA,GAA2B,CAC/B,gBAAA,EACA,YAAA,KACkC;AAClC,EAAA,IAAI,WAAA,GAAmC,MAAA;AAEvC,EAAA,MAAM,aAAa,MAAY;AAC7B,IAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,MAAA,YAAA,CAAa,WAAW,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAEA,EAAA,OAAO,0BAAA;AAAA,IACL;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA,EAAY;AAAA,MAC3C,UAAA,EAAY;AAAA,KACd;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,UAAA,EAAW;AAGX,MAAA,WAAA,GAAc,WAAW,MAAM;AAC7B,QAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,QAAA,WAAA,CAAY,GAAG,KAAK,CAAA;AAAA,MACtB,GAAG,YAAY,CAAA;AAAA,IACjB;AAAA,GACJ;AACF,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"filter.d.mts","sourceRoot":"","sources":["../../../src/core/operators/filter.mts"],"names":[],"mappings":"AAAA,OAAO,EAKL,QAAQ,EACT,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACnC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,GACxD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAElC,wBAAgB,MAAM,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,GACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"filter.d.mts","sourceRoot":"","sources":["../../../src/core/operators/filter.mts"],"names":[],"mappings":"AAAA,OAAO,EAKL,QAAQ,EACT,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACnC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,GACxD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAElC,wBAAgB,MAAM,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,GACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}