synstate 3.0.0 → 3.0.2

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

@@ -1,27 +1,69 @@
-import { Result, Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { createRootObservable } from '../base/create-root-observable.mjs';
-
-const fromPromise = (promise) => createRootObservable(
-  { initialValue: Optional.none },
-  ({ startUpdate, isCompleted, complete }) => {
-    promise.then((value) => {
-      if (isCompleted()) return;
-      startUpdate(Result.ok(value));
-    }).catch((error) => {
-      if (isCompleted()) return;
-      startUpdate(
-        Result.err(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          error
-        )
-      );
-    }).finally(() => {
-      complete();
+import { Optional, Result } from 'ts-data-forge';
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const fromPromise = (promise) => createRootObservable({ initialValue: Optional.none }, ({ startUpdate, isCompleted, complete }) => {
+    promise
+        .then((value) => {
+        if (isCompleted())
+            return;
+        startUpdate(Result.ok(value));
+    })
+        .catch((error) => {
+        if (isCompleted())
+            return;
+        startUpdate(Result.err(
+
+        error));
+    })
+        .finally(() => {
+        complete();
     });
     return {};
-  }
-);
-
-export { fromPromise };
-//# sourceMappingURL=from-promise.mjs.map
+});
+//# 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 { 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;;;;"}
+{"version":3,"file":"from-promise.mjs","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,OAAmB,EACU,EAAE,CAC/B,oBAAoB,CAClB,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,EAC/B,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE;IACzC,OAAO;SACJ,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QACd,IAAI,WAAW,EAAE;YAAE,OAAO;QAE1B,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAChC,CAAC,CAAC;SACD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QACxB,IAAI,WAAW,EAAE;YAAE,OAAO;QAE1B,WAAW,CACT,MAAM,CAAC,GAAG;QACR,oEAAoE;QACpE,KAAU,CACX,CACF,CAAC;IACJ,CAAC,CAAC;SACD,OAAO,CAAC,GAAG,EAAE;QACZ,QAAQ,EAAE,CAAC;IACb,CAAC,CAAC,CAAC;IAEL,OAAO,EAAE,CAAC;AACZ,CAAC,CACF,CAAC"}

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

@@ -1,29 +1,73 @@
-import { Result, Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { createRootObservable } from '../base/create-root-observable.mjs';
-
-const fromSubscribable = (subscribable) => createRootObservable(
-  { initialValue: Optional.none },
-  ({ startUpdate, complete }) => {
-    subscribable.subscribe(
-      (nextValue) => {
+import { Optional, Result } from 'ts-data-forge';
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const fromSubscribable = (subscribable) => createRootObservable({ initialValue: Optional.none }, ({ startUpdate, complete }) => {
+    subscribable.subscribe((nextValue) => {
         startUpdate(Result.ok(nextValue));
-      },
-      (error) => {
-        startUpdate(
-          Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error
-          )
-        );
-      },
-      () => {
+    }, (error) => {
+        startUpdate(Result.err(
+
+        error));
+    }, () => {
         complete();
-      }
-    );
+    });
     return {};
-  }
-);
-
-export { fromSubscribable };
-//# sourceMappingURL=from-subscribable.mjs.map
+});
+//# 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 { 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;;;;"}
+{"version":3,"file":"from-subscribable.mjs","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAMzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,YAA6B,EACK,EAAE,CACpC,oBAAoB,CAClB,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,EAC/B,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE;IAC5B,YAAY,CAAC,SAAS,CACpB,CAAC,SAAS,EAAE,EAAE;QACZ,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IACpC,CAAC,EACD,CAAC,KAAe,EAAE,EAAE;QAClB,WAAW,CACT,MAAM,CAAC,GAAG;QACR,oEAAoE;QACpE,KAAU,CACX,CACF,CAAC;IACJ,CAAC,EACD,GAAG,EAAE;QACH,QAAQ,EAAE,CAAC;IACb,CAAC,CACF,CAAC;IAEF,OAAO,EAAE,CAAC;AACZ,CAAC,CACF,CAAC"}

package/dist/core/create/index.mjs

@@ -1,8 +1,8 @@
-export { counter } from './counter.mjs';
-export { fromAbortablePromise } from './from-abortable-promise.mjs';
-export { fromPromise } from './from-promise.mjs';
-export { fromSubscribable } from './from-subscribable.mjs';
-export { just } from './just.mjs';
-export { source } from './source.mjs';
-export { timer } from './timer.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './counter.mjs';
+export * from './from-abortable-promise.mjs';
+export * from './from-promise.mjs';
+export * from './from-subscribable.mjs';
+export * from './just.mjs';
+export * from './source.mjs';
+export * from './timer.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/core/create/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dist/core/create/just.mjs

@@ -1,15 +1,38 @@
 import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { createRootObservable } from '../base/create-root-observable.mjs';
-
-const just = (value) => {
-  const obs = createRootObservable(
-    { initialValue: Optional.some(value) },
-    () => ({})
-  );
-  obs.complete();
-  return obs;
-};
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-export { just };
-//# sourceMappingURL=just.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const just = (value) => {
+    const obs = createRootObservable({ initialValue: Optional.some(value) }, () => ({}));
+    obs.complete();
+
+    return obs;
+};
+//# sourceMappingURL=just.mjs.map

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 { 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;;;;"}
+{"version":3,"file":"just.mjs","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAW,KAAQ,EAAgC,EAAE;IACvE,MAAM,GAAG,GAAG,oBAAoB,CAC9B,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EACtC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CACX,CAAC;IAEF,GAAG,CAAC,QAAQ,EAAE,CAAC;IAEf,oEAAoE;IACpE,OAAO,GAAmC,CAAC;AAC7C,CAAC,CAAC"}

package/dist/core/create/source.mjs

@@ -1,20 +1,16 @@
-import { Optional, Arr } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { createRootObservable } from '../base/create-root-observable.mjs';
-
-function source(...args) {
-  return createRootObservable(
-    {
-      initialValue: Arr.isNonEmpty(args) ? Optional.some(args[0]) : Optional.none
-    },
-    ({ startUpdate, isCompleted }) => ({
-      next: (nextValue) => {
-        if (isCompleted()) return;
-        startUpdate(nextValue);
-      }
-    })
-  );
+import { Arr, Optional } from 'ts-data-forge';
+import { createRootObservable } from '../base/index.mjs';
+export function source(...args) {
+    return createRootObservable({
+        initialValue: Arr.isNonEmpty(args)
+            ? Optional.some(args[0])
+            : Optional.none,
+    }, ({ startUpdate, isCompleted }) => ({
+        next: (nextValue) => {
+            if (isCompleted())
+                return;
+            startUpdate(nextValue);
+        },
+    }));
 }
-
-export { source };
-//# sourceMappingURL=source.mjs.map
+//# sourceMappingURL=source.mjs.map

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 { 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;;;;"}
+{"version":3,"file":"source.mjs","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAmDzD,MAAM,UAAU,MAAM,CAAU,GAAG,IAAkB;IACnD,OAAO,oBAAoB,CACzB;QACE,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;YAChC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACxB,CAAC,CAAC,QAAQ,CAAC,IAAI;KAClB,EACD,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;QACjC,IAAI,EAAE,CAAC,SAAY,EAAE,EAAE;YACrB,IAAI,WAAW,EAAE;gBAAE,OAAO;YAE1B,WAAW,CAAC,SAAS,CAAC,CAAC;QACzB,CAAC;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/core/create/timer.mjs

@@ -1,40 +1,69 @@
 import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { createRootObservable } from '../base/create-root-observable.mjs';
-
-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;
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const timer = (milliSeconds, options) => {
+    let mut_timerId = undefined;
+    let mut_isStarted = false;
+    const resetTimer = () => {
+        if (mut_timerId !== undefined) {
+            clearTimeout(mut_timerId);
         }
-        mut_timerId = setTimeout(() => {
-          startUpdate(0);
-          complete();
-        }, milliSeconds);
-      }
-    })
-  );
-  if (!(options?.startManually ?? false)) {
-    observable.start();
-  }
-  return observable;
+    };
+    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();
+    }
+    return observable;
 };
-
-export { timer };
-//# sourceMappingURL=timer.mjs.map
+//# 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 { 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;;;;"}
+{"version":3,"file":"timer.mjs","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,YAAoB,EACpB,OAEE,EACe,EAAE;IACnB,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,IAAI,aAAa,GAAG,KAAK,CAAC;IAE1B,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,oBAAoB,CACrC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,EACvD,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;QAC3C,KAAK,EAAE,GAAG,EAAE;YACV,IAAI,aAAa,EAAE,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAEnC,OAAO;YACT,CAAC;YAED,aAAa,GAAG,IAAI,CAAC;YAErB,IAAI,WAAW,EAAE,EAAE,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;gBAEvD,OAAO;YACT,CAAC;YAED,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC5B,WAAW,CAAC,CAAC,CAAC,CAAC;gBAEf,QAAQ,EAAE,CAAC;YACb,CAAC,EAAE,YAAY,CAAC,CAAC;QACnB,CAAC;KACF,CAAC,CACH,CAAC;IAEF,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,IAAI,KAAK,CAAC,EAAE,CAAC;QACvC,UAAU,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC"}

package/dist/core/index.mjs

@@ -1,41 +1,6 @@
-export { combine, combineLatest } from './combine/combine.mjs';
-export { merge } from './combine/merge.mjs';
-export { zip } from './combine/zip.mjs';
-export { counter } from './create/counter.mjs';
-export { fromAbortablePromise } from './create/from-abortable-promise.mjs';
-export { fromPromise } from './create/from-promise.mjs';
-export { fromSubscribable } from './create/from-subscribable.mjs';
-export { just } from './create/just.mjs';
-export { source } from './create/source.mjs';
-export { timer } from './create/timer.mjs';
-export { audit } from './operators/audit.mjs';
-export { debounce } from './operators/debounce.mjs';
-export { filter } from './operators/filter.mjs';
-export { map } from './operators/map.mjs';
-export { flatMap, mergeMap } from './operators/merge-map.mjs';
-export { pairwise } from './operators/pairwise.mjs';
-export { scan } from './operators/scan.mjs';
-export { distinctUntilChanged, skipIfNoChange } from './operators/skip-if-no-change.mjs';
-export { skipUntil } from './operators/skip-until.mjs';
-export { skipWhile } from './operators/skip-while.mjs';
-export { switchMap } from './operators/switch-map.mjs';
-export { takeUntil } from './operators/take-until.mjs';
-export { takeWhile } from './operators/take-while.mjs';
-export { throttle } from './operators/throttle.mjs';
-export { withBuffered, withBufferedFrom } from './operators/with-buffered-from.mjs';
-export { withCurrentValueFrom, withLatestFrom } from './operators/with-current-value-from.mjs';
-export { withInitialValue } from './operators/with-initial-value.mjs';
-export { attachIndex, withIndex } from './predefined/operators/attach-index.mjs';
-export { mapOptional } from './predefined/operators/map-optional.mjs';
-export { mapResultErr } from './predefined/operators/map-result-err.mjs';
-export { mapResultOk } from './predefined/operators/map-result-ok.mjs';
-export { mapTo } from './predefined/operators/map-to.mjs';
-export { getKey, pluck } from './predefined/operators/pluck.mjs';
-export { skip } from './predefined/operators/skip.mjs';
-export { take } from './predefined/operators/take.mjs';
-export { unwrapOptional } from './predefined/operators/unwrap-optional.mjs';
-export { unwrapResultErr } from './predefined/operators/unwrap-result-err.mjs';
-export { unwrapResultOk } from './predefined/operators/unwrap-result-ok.mjs';
-import 'ts-data-forge';
-export { isChildObservable, isManagerObservable, isRootObservable } from './types/observable.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './combine/index.mjs';
+export * from './create/index.mjs';
+export * from './operators/index.mjs';
+export * from './predefined/index.mjs';
+export * from './types/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","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"}