synstate 0.1.1 → 1.0.0

package/dist/core/combine/zip.mjs

@@ -15,38 +15,39 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  letters$  'a'       'b'       'c'
+ * //  letters$  'A'       'B'       'C'
  * //  numbers$  1         2         3
- * //  zipped$   ['a',1]   ['b',2]   ['c',3]
+ * //  zipped$   ['A',1]   ['B',2]   ['C',3]
  * //
  * //  Explanation:
  * //  - zip pairs values by their index from multiple sources
  * //  - Waits for all sources to emit at the same index
  * //  - Completes when any source completes
  *
- * const letters$ = fromArray(['a', 'b', 'c']);
+ * const [letters$, setLetter] = createState<string>('A');
  *
- * const numbers$ = fromArray([1, 2, 3]);
+ * const [numbers$, setNumber] = createState<number>(1);
  *
  * const zipped$ = zip([letters$, numbers$]);
  *
- * const mut_history: (readonly [string, number])[] = [];
+ * const valueHistory: (readonly [string, number])[] = [];
  *
- * await new Promise<void>((resolve) => {
- *   zipped$.subscribe(
- *     ([letter, num]) => {
- *       mut_history.push([letter, num]);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
+ * zipped$.subscribe(([letter, num]) => {
+ *   valueHistory.push([letter, num]);
  * });
  *
- * assert.deepStrictEqual(mut_history, [
- *   ['a', 1],
- *   ['b', 2],
- *   ['c', 3],
+ * for (const letter of ['B', 'C']) {
+ *   setLetter(letter);
+ * }
+ *
+ * for (const num of [2, 3]) {
+ *   setNumber(num);
+ * }
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   ['A', 1],
+ *   ['B', 2],
+ *   ['C', 3],
  * ]);
  * ```
  */
@@ -67,11 +68,11 @@ class ZipObservableClass extends SyncChildObservableClass {
         });
         this.#queues = Arr.map(parents, () => createQueue());
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const queues = this.#queues;
         for (const [index, par] of this.parents.entries()) {
             const sn = par.getSnapshot();
-            if (par.updaterSymbol === updaterSymbol && Optional.isSome(sn)) {
+            if (par.updateToken === updateToken && Optional.isSome(sn)) {
                 queues[index]?.enqueue(sn.value);
             }
         }
@@ -79,7 +80,7 @@ class ZipObservableClass extends SyncChildObservableClass {
             const nextValue = 
             // eslint-disable-next-line total-functions/no-unsafe-type-assertion
             Arr.map(queues, (q) => Optional.unwrap(q.dequeue()));
-            this.setNext(nextValue, updaterSymbol);
+            this.setNext(nextValue, updateToken);
         }
     }
 }

package/dist/core/combine/zip.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"zip.mjs","sources":["../../../src/core/combine/zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACI,MAAM,GAAG,GAAG,CACjB,OAAW;AAEX;AACA,IAAI,kBAAkB,CAAC,OAAO;AAEhC,MAAM,kBACJ,SAAQ,wBAA8B,CAAA;AAG7B,IAAA,OAAO;AAEhB,IAAA,WAAA,CAAY,OAAgB,EAAA;AAC1B,QAAA,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;AAEzD,QAAA,KAAK,CAAC;YACJ,OAAO;YACP,YAAY,EAAE,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM;kBAC7C,QAAQ,CAAC,IAAI;;AAEX,gBAAA,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAM;kBAE7C,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,MAC9B,WAAW,EAAE,CACiB;;AAGzB,IAAA,SAAS,CAAC,aAA4B,EAAA;AAC7C,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO;AAE3B,QAAA,KAAK,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE;AACjD,YAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,YAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;gBAC9D,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC;;;AAIpC,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;AACzC,YAAA,MAAM,SAAS;;YAEb,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAM;AAE3D,YAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,aAAa,CAAC;;;AAG3C;;;;"}
+{"version":3,"file":"zip.mjs","sources":["../../../src/core/combine/zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;AACI,MAAM,GAAG,GAAG,CACjB,OAAW;AAEX;AACA,IAAI,kBAAkB,CAAC,OAAO;AAEhC,MAAM,kBACJ,SAAQ,wBAA8B,CAAA;AAG7B,IAAA,OAAO;AAEhB,IAAA,WAAA,CAAY,OAAgB,EAAA;AAC1B,QAAA,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;AAEzD,QAAA,KAAK,CAAC;YACJ,OAAO;YACP,YAAY,EAAE,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM;kBAC7C,QAAQ,CAAC,IAAI;;AAEX,gBAAA,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAM;kBAE7C,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,MAC9B,WAAW,EAAE,CACiB;;AAGzB,IAAA,SAAS,CAAC,WAAwB,EAAA;AACzC,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO;AAE3B,QAAA,KAAK,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE;AACjD,YAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,YAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;gBAC1D,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC;;;AAIpC,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;AACzC,YAAA,MAAM,SAAS;;YAEb,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAM;AAE3D,YAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;;;AAGzC;;;;"}

package/dist/core/create/{interval.d.mts → counter.d.mts}

@@ -1,9 +1,9 @@
-import { type IntervalObservable } from '../types/index.mjs';
+import { type CounterObservable } from '../types/index.mjs';
 /**
  * Creates an observable that emits incremental numbers at a specified interval.
  * Starts with 0 immediately after subscription, then emits 1, 2, 3, ... every interval.
  *
- * @param milliSeconds - The interval duration in milliseconds
+ * @param intervalMilliSeconds - The interval duration in milliseconds
  * @param startManually - If true, waits for manual start (default: false)
  * @returns An observable that emits sequential numbers
  *
@@ -15,16 +15,16 @@ import { type IntervalObservable } from '../types/index.mjs';
  * //  tick$     0     1     2     3     4     5     ...
  * //
  * //  Explanation:
- * //  - interval emits incrementing numbers at specified intervals
+ * //  - counter emits incrementing numbers at specified intervals
  * //  - Starts at 0 and continues indefinitely
  * //  - Useful for periodic tasks or animations
  *
- * const tick$ = interval(100);
+ * const tick$ = counter(100);
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * const subscription = tick$.subscribe((count) => {
- *   mut_history.push(count);
+ *   valueHistory.push(count);
  * });
  *
  * await new Promise((resolve) => {
@@ -33,14 +33,16 @@ import { type IntervalObservable } from '../types/index.mjs';
  *
  * subscription.unsubscribe();
  *
- * assert.isTrue(Arr.isArrayAtLeastLength(mut_history, 3));
+ * assert.isTrue(Arr.isArrayAtLeastLength(valueHistory, 3));
  *
- * assert.deepStrictEqual(mut_history[0], 0);
+ * assert.deepStrictEqual(valueHistory[0], 0);
  *
- * assert.deepStrictEqual(mut_history[1], 1);
+ * assert.deepStrictEqual(valueHistory[1], 1);
  *
- * assert.deepStrictEqual(mut_history[2], 2);
+ * assert.deepStrictEqual(valueHistory[2], 2);
  * ```
  */
-export declare const interval: (milliSeconds: number, startManually?: boolean) => IntervalObservable;
-//# sourceMappingURL=interval.d.mts.map
+export declare const counter: (intervalMilliSeconds: number, options?: Readonly<{
+    startManually?: boolean;
+}>) => CounterObservable;
+//# sourceMappingURL=counter.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"counter.d.mts","sourceRoot":"","sources":["../../../src/core/create/counter.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,oBAAoB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,OAAO,GAClB,sBAAsB,MAAM,EAC5B,UAAU,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,iBAIA,CAAC"}

package/dist/core/create/{interval.mjs → counter.mjs}

@@ -6,7 +6,7 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  * Creates an observable that emits incremental numbers at a specified interval.
  * Starts with 0 immediately after subscription, then emits 1, 2, 3, ... every interval.
  *
- * @param milliSeconds - The interval duration in milliseconds
+ * @param intervalMilliSeconds - The interval duration in milliseconds
  * @param startManually - If true, waits for manual start (default: false)
  * @returns An observable that emits sequential numbers
  *
@@ -18,16 +18,16 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  * //  tick$     0     1     2     3     4     5     ...
  * //
  * //  Explanation:
- * //  - interval emits incrementing numbers at specified intervals
+ * //  - counter emits incrementing numbers at specified intervals
  * //  - Starts at 0 and continues indefinitely
  * //  - Useful for periodic tasks or animations
  *
- * const tick$ = interval(100);
+ * const tick$ = counter(100);
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * const subscription = tick$.subscribe((count) => {
- *   mut_history.push(count);
+ *   valueHistory.push(count);
  * });
  *
  * await new Promise((resolve) => {
@@ -36,52 +36,50 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *
  * subscription.unsubscribe();
  *
- * assert.isTrue(Arr.isArrayAtLeastLength(mut_history, 3));
+ * assert.isTrue(Arr.isArrayAtLeastLength(valueHistory, 3));
  *
- * assert.deepStrictEqual(mut_history[0], 0);
+ * assert.deepStrictEqual(valueHistory[0], 0);
  *
- * assert.deepStrictEqual(mut_history[1], 1);
+ * assert.deepStrictEqual(valueHistory[1], 1);
  *
- * assert.deepStrictEqual(mut_history[2], 2);
+ * assert.deepStrictEqual(valueHistory[2], 2);
  * ```
  */
-const interval = (milliSeconds, startManually) => new IntervalObservableClass(milliSeconds, startManually);
-class IntervalObservableClass extends RootObservableClass {
-    #milliSeconds;
+const counter = (intervalMilliSeconds, options) => new CounterObservableClass(intervalMilliSeconds, options?.startManually ?? false);
+class CounterObservableClass extends RootObservableClass {
+    #intervalMilliSeconds;
     #mut_counter;
     #mut_timerId0;
     #mut_timerId;
     #mut_isStarted;
-    constructor(milliSeconds, startManually) {
+    constructor(intervalMilliSeconds, startManually) {
         super({ initialValue: Optional.none });
-        this.#milliSeconds = milliSeconds;
+        this.#intervalMilliSeconds = intervalMilliSeconds;
         this.#mut_counter = asSafeUint(0);
         this.#mut_timerId0 = undefined;
         this.#mut_timerId = undefined;
         this.#mut_isStarted = false;
-        if (startManually !== true) {
+        if (!startManually) {
             this.start();
         }
     }
     start() {
         if (this.#mut_isStarted) {
             console.warn('cannot start twice');
-            return this;
+            return;
         }
         this.#mut_isStarted = true;
         if (this.isCompleted) {
-            console.warn('cannot restart stopped IntervalObservable');
-            return this;
+            console.warn('cannot restart stopped CounterObservable');
+            return;
         }
-        // emit zero
         this.#mut_timerId0 = setTimeout(() => {
             this.startUpdate(this.#mut_counter);
         }, 0);
         this.#mut_timerId = setInterval(() => {
             this.#mut_counter = SafeUint.add(1, this.#mut_counter);
             this.startUpdate(this.#mut_counter);
-        }, this.#milliSeconds);
-        return this;
+        }, this.#intervalMilliSeconds);
     }
     #resetTimer() {
         if (this.#mut_timerId0 !== undefined && this.#mut_timerId !== undefined) {
@@ -95,5 +93,5 @@ class IntervalObservableClass extends RootObservableClass {
     }
 }
 
-export { interval };
-//# sourceMappingURL=interval.mjs.map
+export { counter };
+//# sourceMappingURL=counter.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"counter.mjs","sources":["../../../src/core/create/counter.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;MACU,OAAO,GAAG,CACrB,oBAA4B,EAC5B,OAEE,KAEF,IAAI,sBAAsB,CACxB,oBAAoB,EACpB,OAAO,EAAE,aAAa,IAAI,KAAK;AAGnC,MAAM,sBACJ,SAAQ,mBAA6B,CAAA;AAG5B,IAAA,qBAAqB;AAC9B,IAAA,YAAY;AACZ,IAAA,aAAa;AACb,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,oBAA4B,EAAE,aAAsB,EAAA;QAC9D,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,qBAAqB,GAAG,oBAAoB;AAEjD,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,CAAC,CAAC;AAEjC,QAAA,IAAI,CAAC,aAAa,GAAG,SAAS;AAE9B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;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,0CAA0C,CAAC;YAExD;QACF;AAEA,QAAA,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;QACrC,CAAC,EAAE,CAAC,CAAC;AAEL,QAAA,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC;AAEtD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;AACrC,QAAA,CAAC,EAAE,IAAI,CAAC,qBAAqB,CAAC;IAChC;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACvE,YAAA,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC;AAEjC,YAAA,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;QAClC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/create/from-abortable-promise.d.mts

@@ -0,0 +1,29 @@
+import { type FromPromiseObservable } from '../types/index.mjs';
+/**
+ * Creates an observable from a Promise factory that receives an `AbortSignal`.
+ * When the observable is completed (e.g., by `switchMap` switching to a new
+ * inner observable), the `AbortController` is automatically aborted, cancelling
+ * the in-flight request.
+ *
+ * Emits `Result.ok(value)` when the promise resolves, or `Result.err(error)`
+ * when it rejects. Rejections caused by abort (`AbortError`) are silently
+ * ignored and do not emit.
+ *
+ * @template A - The type of the resolved value
+ * @template E - The type of the error (excluding AbortError)
+ * @param factory - A function that receives an `AbortSignal` and returns a Promise
+ * @returns An observable that emits the promise result
+ *
+ * @example
+ * ```ts
+ * const results$ = query.pipe(
+ *   switchMap((q) =>
+ *     fromAbortablePromise((signal) =>
+ *       fetch(`/api/search?q=${q}`, { signal }).then((r) => r.json()),
+ *     ),
+ *   ),
+ * );
+ * ```
+ */
+export declare const fromAbortablePromise: <A, E = unknown>(factory: (signal: AbortSignal) => Promise<A>) => FromPromiseObservable<A, E>;
+//# sourceMappingURL=from-abortable-promise.d.mts.map

package/dist/core/create/from-abortable-promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-abortable-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-abortable-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EAEjD,SAAS,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,KAC3C,qBAAqB,CAAC,CAAC,EAAE,CAAC,CACqB,CAAC"}

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

@@ -0,0 +1,70 @@
+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 factory that receives an `AbortSignal`.
+ * When the observable is completed (e.g., by `switchMap` switching to a new
+ * inner observable), the `AbortController` is automatically aborted, cancelling
+ * the in-flight request.
+ *
+ * Emits `Result.ok(value)` when the promise resolves, or `Result.err(error)`
+ * when it rejects. Rejections caused by abort (`AbortError`) are silently
+ * ignored and do not emit.
+ *
+ * @template A - The type of the resolved value
+ * @template E - The type of the error (excluding AbortError)
+ * @param factory - A function that receives an `AbortSignal` and returns a Promise
+ * @returns An observable that emits the promise result
+ *
+ * @example
+ * ```ts
+ * const results$ = query.pipe(
+ *   switchMap((q) =>
+ *     fromAbortablePromise((signal) =>
+ *       fetch(`/api/search?q=${q}`, { signal }).then((r) => r.json()),
+ *     ),
+ *   ),
+ * );
+ * ```
+ */
+const fromAbortablePromise = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+factory) => new FromAbortablePromiseObservableClass(factory);
+class FromAbortablePromiseObservableClass extends RootObservableClass {
+    #abortController;
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    constructor(factory) {
+        super({ initialValue: Optional.none });
+        this.#abortController = new AbortController();
+        const promise = factory(this.#abortController.signal);
+        promise
+            .then((value) => {
+            if (this.isCompleted)
+                return;
+            this.startUpdate(Result.ok(value));
+        })
+            .catch((error) => {
+            if (this.isCompleted)
+                return;
+            // Silently ignore AbortError — it means the observable was
+            // intentionally completed (e.g., by switchMap).
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                return;
+            }
+            this.startUpdate(Result.err(
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            error));
+        })
+            .finally(() => {
+            this.complete();
+        });
+    }
+    complete() {
+        this.#abortController.abort();
+        super.complete();
+    }
+}
+
+export { fromAbortablePromise };
+//# sourceMappingURL=from-abortable-promise.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-abortable-promise.mjs","sources":["../../../src/core/create/from-abortable-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,oBAAoB,GAAG;AAClC;AACA,OAA4C,KAE5C,IAAI,mCAAmC,CAAC,OAAO;AAEjD,MAAM,mCACJ,SAAQ,mBAAiC,CAAA;AAGhC,IAAA,gBAAgB;;AAGzB,IAAA,WAAA,CAAY,OAA4C,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,gBAAgB,GAAG,IAAI,eAAe,EAAE;QAE7C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC;QAErD;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;;;YAItB,IAAI,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE;gBAChE;YACF;AAEA,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;IAES,QAAQ,GAAA;AACf,QAAA,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE;QAE7B,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/create/from-promise.d.mts

@@ -13,7 +13,7 @@ import { type FromPromiseObservable } from '../types/index.mjs';
  * //  Timeline:
  * //
  * //  promise     [pending...]  -> resolved/rejected
- * //  data$                     Ok(value) or Err(error)
+ * //  data$                        Ok(value) or Err(error)
  * //
  * //  Explanation:
  * //  - fromPromise converts a Promise into an observable
@@ -21,17 +21,20 @@ import { type FromPromiseObservable } from '../types/index.mjs';
  * //  - Completes after emitting the result
  * //  - Useful for integrating async operations into reactive flows
  *
- * const fetchData = async (): Promise<{ value: number }> => ({ value: 42 });
+ * const fetchData = async (): Promise<Readonly<{ value: number }>> =>
+ *   ({
+ *     value: 42,
+ *   }) as const;
  *
  * const data$ = fromPromise(fetchData());
  *
- * const mut_history: { value: number }[] = [];
+ * const valueHistory: Readonly<{ value: number }>[] = [];
  *
  * await new Promise<void>((resolve) => {
  *   data$.subscribe(
  *     (result) => {
  *       if (Result.isOk(result)) {
- *         mut_history.push(result.value);
+ *         valueHistory.push(result.value);
  *       }
  *     },
  *     () => {
@@ -40,8 +43,8 @@ import { type FromPromiseObservable } from '../types/index.mjs';
  *   );
  * });
  *
- * assert.deepStrictEqual(mut_history, [{ value: 42 }]);
+ * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);
  * ```
  */
-export declare const fromPromise: <A, E = unknown>(promise: Readonly<Promise<A>>) => FromPromiseObservable<A, E>;
+export declare const fromPromise: <A, E = unknown>(promise: Promise<A>) => FromPromiseObservable<A, E>;
 //# sourceMappingURL=from-promise.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"from-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EACxC,SAAS,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAC5B,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}
+{"version":3,"file":"from-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EACxC,SAAS,OAAO,CAAC,CAAC,CAAC,KAClB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}

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

@@ -16,7 +16,7 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  * //  Timeline:
  * //
  * //  promise     [pending...]  -> resolved/rejected
- * //  data$                     Ok(value) or Err(error)
+ * //  data$                        Ok(value) or Err(error)
  * //
  * //  Explanation:
  * //  - fromPromise converts a Promise into an observable
@@ -24,17 +24,20 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  * //  - Completes after emitting the result
  * //  - Useful for integrating async operations into reactive flows
  *
- * const fetchData = async (): Promise<{ value: number }> => ({ value: 42 });
+ * const fetchData = async (): Promise<Readonly<{ value: number }>> =>
+ *   ({
+ *     value: 42,
+ *   }) as const;
  *
  * const data$ = fromPromise(fetchData());
  *
- * const mut_history: { value: number }[] = [];
+ * const valueHistory: Readonly<{ value: number }>[] = [];
  *
  * await new Promise<void>((resolve) => {
  *   data$.subscribe(
  *     (result) => {
  *       if (Result.isOk(result)) {
- *         mut_history.push(result.value);
+ *         valueHistory.push(result.value);
  *       }
  *     },
  *     () => {
@@ -43,7 +46,7 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *   );
  * });
  *
- * assert.deepStrictEqual(mut_history, [{ value: 42 }]);
+ * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);
  * ```
  */
 const fromPromise = (promise) => new FromPromiseObservableClass(promise);

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,WAAW,GAAG,CACzB,OAA6B,KACG,IAAI,0BAA0B,CAAC,OAAO;AAExE,MAAM,0BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,OAA6B,EAAA;QACvC,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":[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;;;;"}

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

@@ -35,17 +35,17 @@ import { type FromSubscribableObservable, type Subscribable } from '../types/ind
  *
  *     return { unsubscribe: () => {} };
  *   },
- * };
+ * } as const;
  *
  * const observable$ = fromSubscribable<number>(customSubscribable);
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * await new Promise<void>((resolve) => {
  *   observable$.subscribe(
  *     (result) => {
  *       if (Result.isOk(result)) {
- *         mut_history.push(result.value);
+ *         valueHistory.push(result.value);
  *       }
  *     },
  *     () => {
@@ -54,7 +54,7 @@ import { type FromSubscribableObservable, type Subscribable } from '../types/ind
  *   );
  * });
  *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
  * ```
  */
 export declare const fromSubscribable: <A, E = unknown>(subscribable: Subscribable<A>) => FromSubscribableObservable<A, E>;

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

@@ -38,17 +38,17 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *
  *     return { unsubscribe: () => {} };
  *   },
- * };
+ * } as const;
  *
  * const observable$ = fromSubscribable<number>(customSubscribable);
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * await new Promise<void>((resolve) => {
  *   observable$.subscribe(
  *     (result) => {
  *       if (Result.isOk(result)) {
- *         mut_history.push(result.value);
+ *         valueHistory.push(result.value);
  *       }
  *     },
  *     () => {
@@ -57,7 +57,7 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *   );
  * });
  *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
  * ```
  */
 const fromSubscribable = (subscribable) => new FromSubscribableObservableClass(subscribable);

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

@@ -1,8 +1,8 @@
-export * from './from-array.mjs';
+export * from './counter.mjs';
+export * from './from-abortable-promise.mjs';
 export * from './from-promise.mjs';
 export * from './from-subscribable.mjs';
-export * from './interval.mjs';
-export * from './of.mjs';
+export * from './just.mjs';
 export * from './source.mjs';
 export * from './timer.mjs';
 //# sourceMappingURL=index.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/core/create/index.mts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","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/index.mjs

@@ -1,8 +1,8 @@
-export { fromArray } from './from-array.mjs';
+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 { interval } from './interval.mjs';
-export { of } from './of.mjs';
-export { source, subject } from './source.mjs';
+export { just } from './just.mjs';
+export { source } from './source.mjs';
 export { timer } from './timer.mjs';
 //# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,32 @@
+import { type InitializedRootObservable } from '../types/index.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);
+ * ```
+ */
+export declare const just: <const A>(value: A) => InitializedRootObservable<A>;
+//# sourceMappingURL=just.d.mts.map

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

@@ -0,0 +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"}

package/dist/core/create/just.mjs

@@ -0,0 +1,44 @@
+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;
+};
+
+export { just };
+//# sourceMappingURL=just.mjs.map

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

@@ -0,0 +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;;;;"}