synstate 0.1.0

package/dist/core/combine/merge.mjs

@@ -0,0 +1,52 @@
+import { Optional } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Merges multiple observables into a single observable that emits all values from all sources.
+ * Emits whenever any source observable emits a value.
+ *
+ * @template OS - Tuple type of source observables
+ * @param parents - Array of observables to merge
+ * @returns A merged observable emitting values from any source
+ *
+ * @example
+ * ```ts
+ * const clicks$ = source<MouseEvent>();
+ *
+ * const keys$ = source<KeyboardEvent>();
+ *
+ * const events$ = merge([clicks$, keys$]);
+ *
+ * events$.subscribe((event_) => {
+ *   console.log(event_);
+ * });
+ * // Logs any mouse click or keyboard event
+ * ```
+ *
+ * @note To improve code readability, consider using `createState` instead of `merge`,
+ * subscribing to `parents` and calling `setState` within it.
+ */
+const merge = (parents) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+new MergeObservableClass(parents);
+class MergeObservableClass extends SyncChildObservableClass {
+    constructor(parents) {
+        super({
+            parents,
+            initialValue: Optional.none,
+        });
+    }
+    tryUpdate(updaterSymbol) {
+        const parentToUse = this.parents.find((o) => o.updaterSymbol === updaterSymbol && Optional.isSome(o.getSnapshot()));
+        if (parentToUse === undefined)
+            return;
+        const nextValue = 
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        Optional.unwrap(parentToUse.getSnapshot());
+        this.setNext(nextValue, updaterSymbol);
+    }
+}
+
+export { merge };
+//# sourceMappingURL=merge.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.mjs","sources":["../../../src/core/combine/merge.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,KAAK,GAAG,CACnB,OAAW;AAEX;AACA,IAAI,oBAAoB,CAAC,OAAO;AAElC,MAAM,oBACJ,SAAQ,wBAA4C,CAAA;AAGpD,IAAA,WAAA,CAAY,OAAgB,EAAA;AAC1B,QAAA,KAAK,CAAC;YACJ,OAAO;YACP,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;AAGK,IAAA,SAAS,CAAC,aAA4B,EAAA;AAC7C,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CACnC,CAAC,CAAC,KACA,CAAC,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CACxE;QAED,IAAI,WAAW,KAAK,SAAS;YAAE;AAE/B,QAAA,MAAM,SAAS;;QAEb,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,CAAoB;AAE/D,QAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,aAAa,CAAC;;AAEzC;;;;"}

package/dist/core/combine/zip.d.mts

@@ -0,0 +1,26 @@
+import { type Observable, type ZipObservableRefined } from '../types/index.mjs';
+/**
+ * Combines multiple observables by pairing their emissions by index.
+ * Waits for all sources to emit their nth value before emitting the nth tuple.
+ * Completes when any source completes.
+ *
+ * @template OS - Tuple type of source observables
+ * @param parents - Array of observables to zip
+ * @returns A zipped observable emitting tuples of values
+ *
+ * @example
+ * ```ts
+ * const letters$ = fromArray(['a', 'b', 'c']);
+ *
+ * const numbers$ = fromArray([1, 2, 3]);
+ *
+ * const zipped$ = zip([letters$, numbers$]);
+ *
+ * zipped$.subscribe(([letter, num]) => {
+ *   console.log(letter, num);
+ * });
+ * // logs: a 1, b 2, c 3
+ * ```
+ */
+export declare const zip: <const OS extends NonEmptyArray<Observable<unknown>>>(parents: OS) => ZipObservableRefined<OS>;
+//# sourceMappingURL=zip.d.mts.map

package/dist/core/combine/zip.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.mts","sourceRoot":"","sources":["../../../src/core/combine/zip.mts"],"names":[],"mappings":"AAIA,OAAO,EAIL,KAAK,UAAU,EAMf,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,EACrE,SAAS,EAAE,KACV,oBAAoB,CAAC,EAAE,CAE8C,CAAC"}

package/dist/core/combine/zip.mjs

@@ -0,0 +1,63 @@
+import { Optional, Arr, createQueue } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Combines multiple observables by pairing their emissions by index.
+ * Waits for all sources to emit their nth value before emitting the nth tuple.
+ * Completes when any source completes.
+ *
+ * @template OS - Tuple type of source observables
+ * @param parents - Array of observables to zip
+ * @returns A zipped observable emitting tuples of values
+ *
+ * @example
+ * ```ts
+ * const letters$ = fromArray(['a', 'b', 'c']);
+ *
+ * const numbers$ = fromArray([1, 2, 3]);
+ *
+ * const zipped$ = zip([letters$, numbers$]);
+ *
+ * zipped$.subscribe(([letter, num]) => {
+ *   console.log(letter, num);
+ * });
+ * // logs: a 1, b 2, c 3
+ * ```
+ */
+const zip = (parents) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+new ZipObservableClass(parents);
+class ZipObservableClass extends SyncChildObservableClass {
+    #queues;
+    constructor(parents) {
+        const parentsValues = parents.map((p) => p.getSnapshot());
+        super({
+            parents,
+            initialValue: parentsValues.every(Optional.isSome)
+                ? Optional.some(
+                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                Arr.map(parentsValues, (c) => c.value))
+                : Optional.none,
+        });
+        this.#queues = Arr.map(parents, () => createQueue());
+    }
+    tryUpdate(updaterSymbol) {
+        const queues = this.#queues;
+        for (const [index, par] of this.parents.entries()) {
+            const sn = par.getSnapshot();
+            if (par.updaterSymbol === updaterSymbol && Optional.isSome(sn)) {
+                queues[index]?.enqueue(sn.value);
+            }
+        }
+        if (queues.every((list) => !list.isEmpty)) {
+            const nextValue = 
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            Arr.map(queues, (q) => Optional.unwrap(q.dequeue()));
+            this.setNext(nextValue, updaterSymbol);
+        }
+    }
+}
+
+export { zip };
+//# sourceMappingURL=zip.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip.mjs","sources":["../../../src/core/combine/zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;AAsBG;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;;;;"}

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

@@ -0,0 +1,21 @@
+import { type FromArrayObservable } from '../types/index.mjs';
+/**
+ * Creates an observable that emits all values from an array sequentially, then completes.
+ *
+ * @template A - The type of array elements
+ * @param values - The array of values to emit
+ * @param startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits array values
+ *
+ * @example
+ * ```ts
+ * const nums$ = fromArray([1, 2, 3]);
+ *
+ * nums$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ * // logs: 1, 2, 3
+ * ```
+ */
+export declare const fromArray: <A>(values: readonly A[], startManually?: boolean) => FromArrayObservable<A>;
+//# sourceMappingURL=from-array.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-array.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-array.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,QAAQ,SAAS,CAAC,EAAE,EACpB,gBAAe,OAAe,KAC7B,mBAAmB,CAAC,CAAC,CACgC,CAAC"}

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

@@ -0,0 +1,47 @@
+import { Optional } from 'ts-data-forge';
+import '../utils/id-maker.mjs';
+import { RootObservableClass } from '../class/root-observable-class.mjs';
+
+/**
+ * Creates an observable that emits all values from an array sequentially, then completes.
+ *
+ * @template A - The type of array elements
+ * @param values - The array of values to emit
+ * @param startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits array values
+ *
+ * @example
+ * ```ts
+ * const nums$ = fromArray([1, 2, 3]);
+ *
+ * nums$.subscribe((x) => {
+ *   console.log(x);
+ * });
+ * // logs: 1, 2, 3
+ * ```
+ */
+const fromArray = (values, startManually = false) => new FromArrayObservableClass(values, startManually);
+class FromArrayObservableClass extends RootObservableClass {
+    #values;
+    constructor(values, startManually = false) {
+        super({ initialValue: Optional.none });
+        this.#values = values;
+        if (!startManually) {
+            setTimeout(() => {
+                this.emit();
+            }, 0);
+        }
+    }
+    emit() {
+        if (this.isCompleted)
+            return this;
+        for (const v of this.#values) {
+            this.startUpdate(v);
+        }
+        this.complete();
+        return this;
+    }
+}
+
+export { fromArray };
+//# sourceMappingURL=from-array.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-array.mjs","sources":["../../../src/core/create/from-array.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,SAAS,GAAG,CACvB,MAAoB,EACpB,aAAA,GAAyB,KAAK,KAE9B,IAAI,wBAAwB,CAAI,MAAM,EAAE,aAAa;AAEvD,MAAM,wBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,OAAO;IAEhB,WAAA,CAAY,MAAoB,EAAE,aAAA,GAAyB,KAAK,EAAA;QAC9D,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,OAAO,GAAG,MAAM;QAErB,IAAI,CAAC,aAAa,EAAE;YAClB,UAAU,CAAC,MAAK;gBACd,IAAI,CAAC,IAAI,EAAE;YACb,CAAC,EAAE,CAAC,CAAC;QACP;IACF;IAEA,IAAI,GAAA;QACF,IAAI,IAAI,CAAC,WAAW;AAAE,YAAA,OAAO,IAAI;AAEjC,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE;AAC5B,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACrB;QAEA,IAAI,CAAC,QAAQ,EAAE;AAEf,QAAA,OAAO,IAAI;IACb;AACD;;;;"}

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

@@ -0,0 +1,25 @@
+import { type FromPromiseObservable } from '../types/index.mjs';
+/**
+ * Creates an observable from a Promise.
+ * Emits Result.ok when the promise resolves, or Result.err when it rejects.
+ *
+ * @template A - The type of the resolved value
+ * @template E - The type of the error
+ * @param promise - The promise to convert to observable
+ * @returns An observable that emits the promise result
+ *
+ * @example
+ * ```ts
+ * const data$ = fromPromise(fetch('/api/data').then((r) => r.json()));
+ *
+ * data$.subscribe((result) => {
+ *   if (Result.isOk(result)) {
+ *     console.log('Data:', result.value);
+ *   } else {
+ *     console.error('Error:', result.value);
+ *   }
+ * });
+ * ```
+ */
+export declare const fromPromise: <A, E = unknown>(promise: Readonly<Promise<A>>) => FromPromiseObservable<A, E>;
+//# sourceMappingURL=from-promise.d.mts.map

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

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

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

@@ -0,0 +1,51 @@
+import { Optional, Result } from 'ts-data-forge';
+import '../utils/id-maker.mjs';
+import { RootObservableClass } from '../class/root-observable-class.mjs';
+
+/**
+ * Creates an observable from a Promise.
+ * Emits Result.ok when the promise resolves, or Result.err when it rejects.
+ *
+ * @template A - The type of the resolved value
+ * @template E - The type of the error
+ * @param promise - The promise to convert to observable
+ * @returns An observable that emits the promise result
+ *
+ * @example
+ * ```ts
+ * const data$ = fromPromise(fetch('/api/data').then((r) => r.json()));
+ *
+ * data$.subscribe((result) => {
+ *   if (Result.isOk(result)) {
+ *     console.log('Data:', result.value);
+ *   } else {
+ *     console.error('Error:', result.value);
+ *   }
+ * });
+ * ```
+ */
+const fromPromise = (promise) => new FromPromiseObservableClass(promise);
+class FromPromiseObservableClass extends RootObservableClass {
+    constructor(promise) {
+        super({ initialValue: Optional.none });
+        promise
+            .then((value) => {
+            if (this.isCompleted)
+                return;
+            this.startUpdate(Result.ok(value));
+        })
+            .catch((error) => {
+            if (this.isCompleted)
+                return;
+            this.startUpdate(Result.err(
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            error));
+        })
+            .finally(() => {
+            this.complete();
+        });
+    }
+}
+
+export { fromPromise };
+//# sourceMappingURL=from-promise.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;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;;;;"}

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

@@ -0,0 +1,3 @@
+import { type FromSubscribableObservable, type Subscribable } from '../types/index.mjs';
+export declare const fromSubscribable: <A, E = unknown>(subscribable: Subscribable<A>) => FromSubscribableObservable<A, E>;
+//# sourceMappingURL=from-subscribable.d.mts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOO,MAAM,gBAAgB,GAAG,CAC9B,YAA6B,KAE7B,IAAI,+BAA+B,CAAC,YAAY;AAElD,MAAM,+BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,YAA6B,EAAA;QACvC,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,YAAY,CAAC,SAAS,CACpB,CAAC,SAAS,KAAI;YACZ,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AACxC,QAAA,CAAC,EACD,CAAC,KAAe,KAAI;AAClB,YAAA,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,GAAG;;YAER,KAAU,CACX,CACF;QACH,CAAC,EACD,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CACF;IACH;AACD;;;;"}

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

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

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

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

package/dist/core/create/index.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

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

@@ -0,0 +1,21 @@
+import { type IntervalObservable } 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 startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits sequential numbers
+ *
+ * @example
+ * ```ts
+ * const tick$ = interval(1000);
+ *
+ * tick$.subscribe((count) => {
+ *   console.log(count);
+ * });
+ * // logs: 0, 1, 2, 3, ... every second
+ * ```
+ */
+export declare const interval: (milliSeconds: number, startManually?: boolean) => IntervalObservable;
+//# sourceMappingURL=interval.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.mts","sourceRoot":"","sources":["../../../src/core/create/interval.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,GACnB,cAAc,MAAM,EACpB,gBAAgB,OAAO,KACtB,kBACuD,CAAC"}

package/dist/core/create/interval.mjs

@@ -0,0 +1,74 @@
+import { Optional, asSafeUint, SafeUint } from 'ts-data-forge';
+import '../utils/id-maker.mjs';
+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 startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits sequential numbers
+ *
+ * @example
+ * ```ts
+ * const tick$ = interval(1000);
+ *
+ * tick$.subscribe((count) => {
+ *   console.log(count);
+ * });
+ * // logs: 0, 1, 2, 3, ... every second
+ * ```
+ */
+const interval = (milliSeconds, startManually) => new IntervalObservableClass(milliSeconds, startManually);
+class IntervalObservableClass extends RootObservableClass {
+    #milliSeconds;
+    #mut_counter;
+    #mut_timerId0;
+    #mut_timerId;
+    #mut_isStarted;
+    constructor(milliSeconds, startManually) {
+        super({ initialValue: Optional.none });
+        this.#milliSeconds = milliSeconds;
+        this.#mut_counter = asSafeUint(0);
+        this.#mut_timerId0 = undefined;
+        this.#mut_timerId = undefined;
+        this.#mut_isStarted = false;
+        if (startManually !== true) {
+            this.start();
+        }
+    }
+    start() {
+        if (this.#mut_isStarted) {
+            console.warn('cannot start twice');
+            return this;
+        }
+        this.#mut_isStarted = true;
+        if (this.isCompleted) {
+            console.warn('cannot restart stopped IntervalObservable');
+            return this;
+        }
+        // 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;
+    }
+    #resetTimer() {
+        if (this.#mut_timerId0 !== undefined && this.#mut_timerId !== undefined) {
+            clearInterval(this.#mut_timerId0);
+            clearInterval(this.#mut_timerId);
+        }
+    }
+    complete() {
+        this.#resetTimer();
+        super.complete();
+    }
+}
+
+export { interval };
+//# sourceMappingURL=interval.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interval.mjs","sources":["../../../src/core/create/interval.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,QAAQ,GAAG,CACtB,YAAoB,EACpB,aAAuB,KAEvB,IAAI,uBAAuB,CAAC,YAAY,EAAE,aAAa;AAEzD,MAAM,uBACJ,SAAQ,mBAA6B,CAAA;AAG5B,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,aAAa;AACb,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAuB,EAAA;QACvD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,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;AAE3B,QAAA,IAAI,aAAa,KAAK,IAAI,EAAE;YAC1B,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;AAElC,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,2CAA2C,CAAC;AAEzD,YAAA,OAAO,IAAI;QACb;;AAGA,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,aAAa,CAAC;AAEtB,QAAA,OAAO,IAAI;IACb;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/of.d.mts

@@ -0,0 +1,20 @@
+import { type OfObservable } from '../types/index.mjs';
+/**
+ * Creates an observable that emits a single value and then completes.
+ *
+ * @template A - The type of the value
+ * @param value - The value to emit
+ * @param startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits the value
+ *
+ * @example
+ * ```ts
+ * const num$ = of(42);
+ *
+ * num$.subscribe((x) => {
+ *   console.log(x);
+ * }); // logs: 42
+ * ```
+ */
+export declare const of: <A>(value: A, startManually?: boolean) => OfObservable<A>;
+//# sourceMappingURL=of.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"of.d.mts","sourceRoot":"","sources":["../../../src/core/create/of.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAClB,OAAO,CAAC,EACR,gBAAe,OAAe,KAC7B,YAAY,CAAC,CAAC,CAAmD,CAAC"}

package/dist/core/create/of.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 emits a single value and then completes.
+ *
+ * @template A - The type of the value
+ * @param value - The value to emit
+ * @param startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits the value
+ *
+ * @example
+ * ```ts
+ * const num$ = of(42);
+ *
+ * num$.subscribe((x) => {
+ *   console.log(x);
+ * }); // logs: 42
+ * ```
+ */
+const of = (value, startManually = false) => new OfObservableClass(value, startManually);
+class OfObservableClass extends RootObservableClass {
+    #value;
+    constructor(value, startManually = false) {
+        super({ initialValue: Optional.none });
+        this.#value = value;
+        if (!startManually) {
+            setTimeout(() => {
+                this.emit();
+            }, 0);
+        }
+    }
+    emit() {
+        if (this.isCompleted)
+            return this;
+        this.startUpdate(this.#value);
+        this.complete();
+        return this;
+    }
+}
+
+export { of };
+//# sourceMappingURL=of.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"of.mjs","sources":["../../../src/core/create/of.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,EAAE,GAAG,CAChB,KAAQ,EACR,aAAA,GAAyB,KAAK,KACV,IAAI,iBAAiB,CAAI,KAAK,EAAE,aAAa;AAEnE,MAAM,iBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,MAAM;IAEf,WAAA,CAAY,KAAQ,EAAE,aAAA,GAAyB,KAAK,EAAA;QAClD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;QAEnB,IAAI,CAAC,aAAa,EAAE;YAClB,UAAU,CAAC,MAAK;gBACd,IAAI,CAAC,IAAI,EAAE;YACb,CAAC,EAAE,CAAC,CAAC;QACP;IACF;IAEA,IAAI,GAAA;QACF,IAAI,IAAI,CAAC,WAAW;AAAE,YAAA,OAAO,IAAI;AAEjC,QAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC;QAE7B,IAAI,CAAC,QAAQ,EAAE;AAEf,QAAA,OAAO,IAAI;IACb;AACD;;;;"}

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

@@ -0,0 +1,29 @@
+import { type InitializedSourceObservable, type SourceObservable } from '../types/index.mjs';
+/**
+ * Creates a new Observable source that can manually emit values.
+ * This is the primary way to create root observables that start reactive chains.
+ *
+ * @template A - The type of values emitted by the source
+ * @returns A SourceObservable that can emit values via `.next()` method
+ *
+ * @example
+ * ```ts
+ * const count$ = source<number>();
+ *
+ * count$.subscribe((value) => {
+ *   console.log(value);
+ * });
+ *
+ * count$.next(1); // logs: 1
+ *
+ * count$.next(2); // logs: 2
+ * ```
+ */
+export declare function source<A>(initialValue: A): InitializedSourceObservable<A>;
+export declare function source<A>(): SourceObservable<A>;
+/**
+ * Alias for `source()`. Creates a new Observable source.
+ * @see source
+ */
+export declare const subject: typeof source;
+//# sourceMappingURL=source.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.mts","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAE3E,wBAAgB,MAAM,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAMjD;;;GAGG;AACH,eAAO,MAAM,OAAO,eAAS,CAAC"}

package/dist/core/create/source.mjs

@@ -0,0 +1,29 @@
+import { Optional, Arr } from 'ts-data-forge';
+import '../utils/id-maker.mjs';
+import { RootObservableClass } from '../class/root-observable-class.mjs';
+
+function source(...args) {
+    return new SourceObservableClass(...args);
+}
+/**
+ * Alias for `source()`. Creates a new Observable source.
+ * @see source
+ */
+const subject = source; // alias
+class SourceObservableClass extends RootObservableClass {
+    constructor(...args) {
+        super({
+            initialValue: Arr.isNonEmpty(args)
+                ? Optional.some(args[0])
+                : Optional.none,
+        });
+    }
+    next(nextValue) {
+        if (this.isCompleted)
+            return;
+        this.startUpdate(nextValue);
+    }
+}
+
+export { source, subject };
+//# sourceMappingURL=source.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AA+BM,SAAU,MAAM,CAAI,GAAG,IAAkB,EAAA;AAC7C,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA;;;AAGG;AACI,MAAM,OAAO,GAAG,OAAO;AAE9B,MAAM,qBACJ,SAAQ,mBAAsB,CAAA;AAG9B,IAAA,WAAA,CAAY,GAAG,IAAkB,EAAA;AAC/B,QAAA,KAAK,CAAC;AACJ,YAAA,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI;kBAC7B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;kBACrB,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;IACJ;AAEA,IAAA,IAAI,CAAC,SAAY,EAAA;QACf,IAAI,IAAI,CAAC,WAAW;YAAE;AAEtB,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IAC7B;AACD;;;;"}

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

@@ -0,0 +1,20 @@
+import { type TimerObservable } from '../types/index.mjs';
+/**
+ * Creates an observable that emits 0 after a specified delay and then completes.
+ *
+ * @param milliSeconds - The delay in milliseconds before emission
+ * @param startManually - If true, waits for manual start (default: false)
+ * @returns An observable that emits after delay
+ *
+ * @example
+ * ```ts
+ * const delayed$ = timer(1000);
+ *
+ * delayed$.subscribe(() => {
+ *   console.log('1 second passed');
+ * });
+ * // After 1 second, logs: 1 second passed
+ * ```
+ */
+export declare const timer: (milliSeconds: number, startManually?: boolean) => TimerObservable;
+//# sourceMappingURL=timer.d.mts.map