synstate 3.0.0 → 3.0.1

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"}

package/dist/core/operators/audit.mjs

@@ -1,42 +1,129 @@
 import { Optional } from 'ts-data-forge';
-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) => createAuditObservable(
-    parentObservable,
-    milliSeconds
-  ))
-);
+import { createAsyncChildObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const audit = (milliSeconds) => 
+
+((parentObservable) => createAuditObservable(parentObservable, milliSeconds));
 const createAuditObservable = (parentObservable, milliSeconds) => {
-  let mut_timerId = void 0;
-  let mut_isSkipping = false;
-  const resetTimer = () => {
-    if (mut_timerId !== void 0) {
-      clearTimeout(mut_timerId);
-    }
-  };
-  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);
-    }
-  );
-};
+    let mut_timerId = undefined;
+    let mut_isSkipping = false;
+    const resetTimer = () => {
+        if (mut_timerId !== undefined) {
+            clearTimeout(mut_timerId);
+        }
+    };
+    return createAsyncChildObservable({
+        parents: [parentObservable],
+        initialValue: parentObservable.getSnapshot(),
+        onComplete: resetTimer,
+    }, ({ startUpdate }) => (updateToken) => {
+        if (mut_isSkipping ||
+            parentObservable.updateToken !== updateToken ||
+            Optional.isNone(parentObservable.getSnapshot())) {
+            return;
+        }
 
-export { audit };
-//# sourceMappingURL=audit.mjs.map
+        mut_isSkipping = true;
+        mut_timerId = setTimeout(() => {
+            const sn = parentObservable.getSnapshot();
+            if (Optional.isNone(sn))
+                return;
+            startUpdate(sn.value);
+            mut_isSkipping = false;
+        }, milliSeconds);
+    });
+};
+//# 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 { 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;;;;"}
+{"version":3,"file":"audit.mjs","sourceRoot":"","sources":["../../../src/core/operators/audit.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAQ/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,YAAoB,EACY,EAAE;AAClC,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,qBAAqB,CACnB,gBAAgB,EAChB,YAAY,CACb,CAAmC,CAAC;AAEzC,MAAM,qBAAqB,GAAG,CAC5B,gBAA+B,EAC/B,YAAoB,EACQ,EAAE;IAC9B,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,IAAI,cAAc,GAAG,KAAK,CAAC;IAE3B,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,0BAA0B,CAC/B;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;QAC5C,UAAU,EAAE,UAAU;KACvB,EACD,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAClB,CAAC,WAAW,EAAE,EAAE;QACd,IACE,cAAc;YACd,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,EAC/C,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,YAAY;QACZ,cAAc,GAAG,IAAI,CAAC;QAEtB,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;YAE1C,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE,OAAO;YAEhC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;YAEtB,cAAc,GAAG,KAAK,CAAC;QACzB,CAAC,EAAE,YAAY,CAAC,CAAC;IACnB,CAAC,CACJ,CAAC;AACJ,CAAC,CAAC"}