synstate 1.0.2 → 2.0.1

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

@@ -2,74 +2,25 @@ import { Optional, Result } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an observable from a Promise.
- * Emits Result.ok when the promise resolves, or Result.err when it rejects.
- *
- * @template A - The type of the resolved value
- * @template E - The type of the error
- * @param promise - The promise to convert to observable
- * @returns An observable that emits the promise result
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  promise     [pending...]  -> resolved/rejected
- * //  data$                        Ok(value) or Err(error)
- * //
- * //  Explanation:
- * //  - fromPromise converts a Promise into an observable
- * //  - Emits a Result type: Ok(value) on success, Err(error) on failure
- * //  - Completes after emitting the result
- * //  - Useful for integrating async operations into reactive flows
- *
- * const fetchData = async (): Promise<Readonly<{ value: number }>> =>
- *   ({
- *     value: 42,
- *   }) as const;
- *
- * const data$ = fromPromise(fetchData());
- *
- * const valueHistory: Readonly<{ value: number }>[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   data$.subscribe(
- *     (result) => {
- *       if (Result.isOk(result)) {
- *         valueHistory.push(result.value);
- *       }
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);
- * ```
- */
 const fromPromise = (promise) => new FromPromiseObservableClass(promise);
 class FromPromiseObservableClass extends RootObservableClass {
-    constructor(promise) {
-        super({ initialValue: Optional.none });
-        promise
-            .then((value) => {
-            if (this.isCompleted)
-                return;
-            this.startUpdate(Result.ok(value));
-        })
-            .catch((error) => {
-            if (this.isCompleted)
-                return;
-            this.startUpdate(Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error));
-        })
-            .finally(() => {
-            this.complete();
-        });
-    }
+  constructor(promise) {
+    super({ initialValue: Optional.none });
+    promise.then((value) => {
+      if (this.isCompleted) return;
+      this.startUpdate(Result.ok(value));
+    }).catch((error) => {
+      if (this.isCompleted) return;
+      this.startUpdate(
+        Result.err(
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          error
+        )
+      );
+    }).finally(() => {
+      this.complete();
+    });
+  }
 }
 
 export { fromPromise };

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

@@ -1 +1 @@
-{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,WAAW,GAAG,CACzB,OAAmB,KACa,IAAI,0BAA0B,CAAC,OAAO;AAExE,MAAM,0BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,OAAmB,EAAA;QAC7B,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;QAEtC;AACG,aAAA,IAAI,CAAC,CAAC,KAAK,KAAI;YACd,IAAI,IAAI,CAAC,WAAW;gBAAE;YAEtB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AACpC,QAAA,CAAC;AACA,aAAA,KAAK,CAAC,CAAC,KAAc,KAAI;YACxB,IAAI,IAAI,CAAC,WAAW;gBAAE;AAEtB,YAAA,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,GAAG;;YAER,KAAU,CACX,CACF;AACH,QAAA,CAAC;aACA,OAAO,CAAC,MAAK;YACZ,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CAAC;IACN;AACD;;;;"}
+{"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;;;;"}

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,EAC7C,cAAc,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,CACiB,CAAC"}

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

@@ -2,78 +2,27 @@ 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: () => {} };
- *   },
- * } as const;
- *
- * const observable$ = fromSubscribable<number>(customSubscribable);
- *
- * const valueHistory: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   observable$.subscribe(
- *     (result) => {
- *       if (Result.isOk(result)) {
- *         valueHistory.push(result.value);
- *       }
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
- * ```
- */
 const fromSubscribable = (subscribable) => new FromSubscribableObservableClass(subscribable);
 class FromSubscribableObservableClass extends RootObservableClass {
-    constructor(subscribable) {
-        super({ initialValue: Optional.none });
-        subscribable.subscribe((nextValue) => {
-            this.startUpdate(Result.ok(nextValue));
-        }, (error) => {
-            this.startUpdate(Result.err(
+  constructor(subscribable) {
+    super({ initialValue: Optional.none });
+    subscribable.subscribe(
+      (nextValue) => {
+        this.startUpdate(Result.ok(nextValue));
+      },
+      (error) => {
+        this.startUpdate(
+          Result.err(
             // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error));
-        }, () => {
-            this.complete();
-        });
-    }
+            error
+          )
+        );
+      },
+      () => {
+        this.complete();
+      }
+    );
+  }
 }
 
 export { fromSubscribable };

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":";;;;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;;;;"}
+{"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;;;;"}

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,EAAG,OAAO,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,CASpE,CAAC"}

package/dist/core/create/just.mjs

@@ -2,42 +2,12 @@ import { Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an Observable that holds a single static value and immediately
- * completes. Useful inside `switchMap` to emit a fallback value when no
- * asynchronous work is needed.
- *
- * @template A - The type of the value
- * @param value - The value to emit
- * @returns An initialized Observable that holds the value and is already completed
- *
- * @example
- * ```ts
- * const greeting$ = just('hello');
- *
- * const valueHistory: string[] = [];
- *
- * greeting$.subscribe(
- *   (value) => {
- *     valueHistory.push(value);
- *   },
- *   () => {
- *     // onComplete — called immediately since just() completes right away
- *   },
- * );
- *
- * assert.deepStrictEqual(valueHistory, ['hello']);
- *
- * assert.strictEqual(greeting$.isCompleted, true);
- * ```
- */
 const just = (value) => {
-    const obs = new RootObservableClass({
-        initialValue: Optional.some(value),
-    });
-    obs.complete();
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    return obs;
+  const obs = new RootObservableClass({
+    initialValue: Optional.some(value)
+  });
+  obs.complete();
+  return obs;
 };
 
 export { just };

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

@@ -1 +1 @@
-{"version":3,"file":"just.mjs","sources":["../../../src/core/create/just.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,IAAI,GAAG,CAAW,KAAQ,KAAkC;AACvE,IAAA,MAAM,GAAG,GAAG,IAAI,mBAAmB,CAAI;AACrC,QAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;AACnC,KAAA,CAAC;IAEF,GAAG,CAAC,QAAQ,EAAE;;AAGd,IAAA,OAAO,GAAmC;AAC5C;;;;"}
+{"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;;;;"}

package/dist/core/create/source.mjs

@@ -3,21 +3,18 @@ import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
 function source(...args) {
-    return new SourceObservableClass(...args);
+  return new SourceObservableClass(...args);
 }
 class SourceObservableClass extends RootObservableClass {
-    constructor(...args) {
-        super({
-            initialValue: Arr.isNonEmpty(args)
-                ? Optional.some(args[0])
-                : Optional.none,
-        });
-    }
-    next(nextValue) {
-        if (this.isCompleted)
-            return;
-        this.startUpdate(nextValue);
-    }
+  constructor(...args) {
+    super({
+      initialValue: Arr.isNonEmpty(args) ? Optional.some(args[0]) : Optional.none
+    });
+  }
+  next(nextValue) {
+    if (this.isCompleted) return;
+    this.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":[null],"names":[],"mappings":";;;;AAoDM,SAAU,MAAM,CAAU,GAAG,IAAkB,EAAA;AACnD,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA,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":["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;;;;"}

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,GAChB,cAAc,MAAM,EACpB,UAAU,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,eACsE,CAAC"}

package/dist/core/create/timer.mjs

@@ -2,80 +2,44 @@ import { Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an observable that emits 0 after a specified delay and then completes.
- *
- * @param milliSeconds - The delay in milliseconds before emission
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits after delay
- *
- * @example
- * ```ts
- * //  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
- *
- * const delayed$ = timer(100);
- *
- * const valueHistory: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   delayed$.subscribe(
- *     () => {
- *       valueHistory.push(1);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(valueHistory, [1]);
- * ```
- */
 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 = undefined;
-        this.#mut_isStarted = false;
-        if (!startManually) {
-            this.start();
-        }
+  #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();
     }
-    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);
+  }
+  #resetTimer() {
+    if (this.#mut_timerId !== void 0) {
+      clearTimeout(this.#mut_timerId);
     }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
+  }
+  start() {
+    if (this.#mut_isStarted) {
+      console.warn("cannot start twice");
+      return;
     }
-    complete() {
-        this.#resetTimer();
-        super.complete();
+    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();
+  }
 }
 
 export { timer };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;MACU,KAAK,GAAG,CACnB,YAAoB,EACpB,OAEE,KAEF,IAAI,oBAAoB,CAAC,YAAY,EAAE,OAAO,EAAE,aAAa,IAAI,KAAK;AAExE,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;YAElC;QACF;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC;YAEtD;QACF;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;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":"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;;;;"}

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,EACrB,cAAc,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,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,gBACP,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}