@ersbeth/picoflow 0.0.1 → 0.1.0

package/dist/types/advanced/index.d.ts

@@ -0,0 +1,7 @@
+export { FlowMap } from './map';
+export { FlowStream } from './stream';
+export { FlowStreamAsync } from './streamAsync';
+export { FlowResource } from './resource';
+export { FlowResourceAsync } from './resourceAsync';
+export type { FlowStreamUpdater, FlowStreamDisposer, FlowStreamSetter, } from './stream';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/advanced/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EACR,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACnB,MAAM,UAAU,CAAC"}

package/dist/types/{map.d.ts → advanced/map.d.ts}

@@ -1,17 +1,16 @@
-import { FlowState } from './state';
+import { FlowState } from '../basic/';
 /**
- * Represents a reactive map of states that extends {@link FlowState} for a Map of key/value pairs.
+ * Represents a reactive map of states extending {@link FlowState} for a Map of key/value pairs.
  *
  * @remarks
  * FlowMap wraps a native Map and provides reactive signals for fine-grained tracking
  * of updates to the map. In addition to the reactive capabilities inherited from FlowState,
- * it exposes two public signals:
+ * it exposes two reactive signals:
  *
- * **$lastSet**: A FlowState that holds the most recent key-value pair that was set.
+ * • $lastSet: Holds the most recent key-value pair that was set.
+ * • $lastDeleted: Holds the most recent key-value pair that was deleted.
  *
- * **$lastDeleted**: A FlowState that holds the most recent key-value pair that was deleted.
- *
- * Use {@link FlowMap.setAt} to set a key-value pair and {@link FlowMap.delete} to remove a key.
+ * Use {@link FlowMap.setAt} to add or update a key-value pair and {@link FlowMap.delete} to remove a key.
  *
  * @typeparam K - The type of the map keys.
  * @typeparam V - The type of the map values.
@@ -50,10 +49,11 @@ export declare class FlowMap<K, V> extends FlowState<Map<K, V>> {
      *
      * @param key - The key at which to set the value.
      * @param value - The value to set.
+     * @throws If the FlowMap instance is disposed.
      *
      * @remarks
-     * This method updates the internal map with the given key and value, emits the new
-     * key-value pair via {@link FlowMap.$lastSet}, and notifies subscribers of the change.
+     * Updates the internal map, emits the key-value pair via {@link FlowMap.$lastSet},
+     * and notifies all subscribers of the change.
      *
      * @public
      */
@@ -62,11 +62,11 @@ export declare class FlowMap<K, V> extends FlowState<Map<K, V>> {
      * Deletes the value at the specified key from the underlying map.
      *
      * @param key - The key to delete.
+     * @throws If the FlowMap instance is disposed.
      *
      * @remarks
-     * This method removes the key from the internal map, emits the deleted key and its
-     * corresponding value via {@link FlowMap.$lastDeleted}, and notifies subscribers
-     * of the change.
+     * Removes the key from the internal map, emits the deleted key and its value via {@link FlowMap.$lastDeleted},
+     * and notifies all subscribers of the change.
      *
      * @public
      */

package/dist/types/advanced/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/advanced/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD;;;;;;;;OAQG;IACI,QAAQ,EAAE,SAAS,CAAC;QAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,CAAA;KAAE,CAAC,CAAqB;IAEvE;;;;;;;;OAQG;IACI,YAAY,EAAE,SAAS,CAAC;QAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,CAAA;KAAE,CAAC,CAAqB;IAE3E;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAOpC;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;CAO9B"}

package/dist/types/advanced/resource.d.ts

@@ -0,0 +1,39 @@
+import { FlowObservable } from '../basic';
+/**
+ * Represents a reactive resource that asynchronously fetches its value.
+ *
+ * @remarks A FlowResource extends FlowObservable and encapsulates an asynchronous fetch function.
+ * It is used to retrieve and update its value asynchronously. When the fetch is executed,
+ * if the new value differs from the current value, the resource is updated and its subscribers
+ * are notified.
+ *
+ * @public
+ */
+export declare class FlowResource<T> extends FlowObservable<T | undefined> {
+    /**
+     * Creates a new FlowResource.
+     * @param fetch - An asynchronous function that retrieves the resource's value.
+     *
+     * @public
+     */
+    constructor(fetch: () => Promise<T>);
+    /**
+     * Retrieves the current resource value.
+     * @returns The current value, or undefined if the resource has not been fetched yet.
+     * @throws Error if the resource is disposed.
+     * @public
+     */
+    get(): T | undefined;
+    /**
+     * Asynchronously fetches a new value for the resource.
+     * @remarks
+     * Executes the internal fetch function. If the fetched value differs from the current one,
+     * updates the resource's value and notifies subscribers.
+     * @returns A Promise that resolves when the fetch operation is complete.
+     * @throws Error if the resource is disposed.
+     * @public
+     */
+    fetch(): Promise<void>;
+    private _fetch;
+}
+//# sourceMappingURL=resource.d.ts.map

package/dist/types/advanced/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/advanced/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;GASG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC;IAC9D;;;;;OAKG;gBACS,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAKnC;;;;;OAKG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAK3B;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUnC,OAAO,CAAC,MAAM,CAAmB;CACpC"}

package/dist/types/{resource.d.ts → advanced/resourceAsync.d.ts}

@@ -1,4 +1,4 @@
-import { FlowObservable } from './observable';
+import { FlowObservable } from '../basic/';
 /**
  * Represents a reactive resource that asynchronously fetches its value.
  *
@@ -12,21 +12,20 @@ import { FlowObservable } from './observable';
  *
  * @public
  */
-export declare class FlowResource<T> extends FlowObservable<T> {
+export declare class FlowResourceAsync<T> extends FlowObservable<Promise<T>> {
     /**
      * Creates a new FlowResource.
      * @param fetch - An asynchronous function that retrieves the resource's value.
-     * @param initial - The initial value of the resource.
      * @public
      */
-    constructor(fetch: () => Promise<T>, initial: T);
+    constructor(fetch: () => Promise<T>);
     /**
      * Retrieves the current resource value.
-     * @returns The current value.
+     * @returns The current value, or undefined if the resource has not been fetched yet.
      * @throws Error if the resource is disposed.
      * @public
      */
-    get(): T;
+    get(): Promise<T>;
     /**
      * Asynchronously fetches a new value for the resource.
      * @remarks
@@ -37,10 +36,6 @@ export declare class FlowResource<T> extends FlowObservable<T> {
      * @public
      */
     fetch(): Promise<void>;
-    /**
-     * @internal
-     * The asynchronous function used to fetch the resource value.
-     */
     private _fetch;
 }
-//# sourceMappingURL=resource.d.ts.map
+//# sourceMappingURL=resourceAsync.d.ts.map

package/dist/types/advanced/resourceAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceAsync.d.ts","sourceRoot":"","sources":["../../../src/advanced/resourceAsync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAChE;;;;OAIG;gBACS,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAKnC;;;;;OAKG;IACI,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;IAMxB;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQnC,OAAO,CAAC,MAAM,CAAmB;CACpC"}

package/dist/types/advanced/stream.d.ts

@@ -0,0 +1,59 @@
+import { FlowObservable } from '../basic/';
+/**
+ * A function type that sets a new value for the reactive stream.
+ * @typeparam T - The type of the value.
+ * @public
+ */
+export type FlowStreamSetter<T> = (value: T) => void;
+/**
+ * A function type that disposes of a resource.
+ * @public
+ */
+export type FlowStreamDisposer = () => void;
+/**
+ * A function type that updates a stream and returns a disposer for cleanup.
+ * @remarks
+ * The updater receives a setter function to update the stream's value.
+ * It should return a disposer function to release any resources or subscriptions.
+ * @typeparam T - The type of the stream value.
+ * @public
+ */
+export type FlowStreamUpdater<T> = (set: FlowStreamSetter<T>) => FlowStreamDisposer;
+/**
+ * Represents a reactive stream that updates its value based on an updater function.
+ *
+ * @remarks
+ * FlowStream extends FlowObservable to encapsulate an update mechanism provided by an external updater function.
+ * The updater is invoked during construction with a setter, and it returns a disposer to be called upon disposal.
+ * Note: The stream's current value may be undefined until explicitly set.
+ *
+ * @typeparam T - The type of the stream's value.
+ * @public
+ */
+export declare class FlowStream<T> extends FlowObservable<T | undefined> {
+    /**
+     * Creates a new FlowStream.
+     * @param updater - A function that receives a setter to update the stream's value.
+     * It should return a disposer function that will be called upon disposal.
+     * @public
+     */
+    constructor(updater: FlowStreamUpdater<T>);
+    /**
+     * Retrieves the current value of the stream.
+     * @returns The current value, or undefined if no value has been set yet.
+     * @throws Error if the stream is disposed.
+     * @public
+     */
+    get(): T | undefined;
+    /**
+     * Disposes the stream, releasing all resources.
+     * @remarks
+     * In addition to disposing the underlying observable, this method calls the disposer
+     * returned by the updater.
+     * @public
+     */
+    dispose(): void;
+    private _disposer;
+    private _set;
+}
+//# sourceMappingURL=stream.d.ts.map

package/dist/types/advanced/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/advanced/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAErD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAC/B,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACvB,kBAAkB,CAAC;AAExB;;;;;;;;;;GAUG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC;IAC5D;;;;;OAKG;gBACS,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAOzC;;;;;OAKG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAK3B;;;;;;OAMG;IACa,OAAO,IAAI,IAAI;IAO/B,OAAO,CAAC,SAAS,CAAqB;IAEtC,OAAO,CAAC,IAAI;CAOf"}

package/dist/types/advanced/streamAsync.d.ts

@@ -0,0 +1,43 @@
+import { FlowObservable } from '../basic';
+import { FlowStreamUpdater } from './stream';
+/**
+ * Represents an asynchronous reactive stream that updates its value based on an updater function.
+ *
+ * @remarks
+ * A FlowStreamAsync extends FlowObservable and encapsulates a mechanism for asynchronously updating its value.
+ * The updater is invoked during construction with a setter, and its returned disposer is called upon disposal.
+ * Note: The stream's current value may be undefined until it is set.
+ *
+ * @typeparam T - The type of the stream's value.
+ * @public
+ */
+export declare class FlowStreamAsync<T> extends FlowObservable<Promise<T>> {
+    /**
+     * Creates a new asynchronous FlowStream.
+     * @param updater - A function that receives a setter to update the stream's value.
+     * It should return a disposer function that will be called upon disposal.
+     * @remarks The updater function can invoke the setter asynchronously to update the stream.
+     * @public
+     */
+    constructor(updater: FlowStreamUpdater<T>);
+    /**
+     * Retrieves the current value of the stream as a Promise.
+     * @returns A Promise that resolves to the current value.
+     * @throws Error if the stream is disposed.
+     * @public
+     */
+    get(): Promise<T>;
+    /**
+     * Disposes the stream, releasing all resources.
+     * @remarks In addition to disposing the underlying observable, this method calls the disposer
+     * returned by the updater.
+     * @public
+     */
+    dispose(): void;
+    private _initialized;
+    private _awaitedValue?;
+    private _resolve;
+    private _disposer;
+    private _set;
+}
+//# sourceMappingURL=streamAsync.d.ts.map

package/dist/types/advanced/streamAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamAsync.d.ts","sourceRoot":"","sources":["../../../src/advanced/streamAsync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9D;;;;;;OAMG;gBACS,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAWzC;;;;;OAKG;IACI,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;IAKxB;;;;;OAKG;IACa,OAAO,IAAI,IAAI;IAO/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAC,CAAI;IAE1B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAqB;IAEtC,OAAO,CAAC,IAAI;CAkBf"}

package/dist/types/basic/constant.d.ts

@@ -0,0 +1,32 @@
+import { FlowObservable } from './observable';
+/**
+ * Represents a reactive and immutable constant value computed lazily upon first access.
+ *
+ * @remarks This class extends FlowObservable and supports initializing the constant using either a direct value
+ * or a lazy initializer function. Once computed, the value is cached for all subsequent accesses.
+ *
+ * @typeparam T - The type of the constant value.
+ *
+ * @public
+ */
+export declare class FlowConstant<T> extends FlowObservable<T> {
+    /**
+     * Creates a new FlowConstant instance.
+     *
+     * @param value - Either a direct value of type T or a function returning a value of type T for lazy initialization.
+     * @public
+     */
+    constructor(value: T | (() => T));
+    /**
+     * Retrieves the constant value, computing it lazily if needed.
+     *
+     * Accessing this method will initialize the value if it has not been computed already.
+     * Throws an error if the instance has been disposed or if lazy initialization fails.
+     *
+     * @returns The cached constant value.
+     * @throws Error if the constant is disposed or cannot be initialized.
+     * @public
+     */
+    get(): T;
+}
+//# sourceMappingURL=constant.d.ts.map

package/dist/types/basic/constant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../../src/basic/constant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;GASG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAClD;;;;;OAKG;gBACS,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAKhC;;;;;;;;;OASG;IACH,GAAG,IAAI,CAAC;CA6BX"}

package/dist/types/basic/derivation.d.ts

@@ -0,0 +1,40 @@
+import { FlowGetter, FlowObservable } from './observable';
+import { FlowWatcher } from './signal';
+/**
+ * Represents a reactive derivation whose value is computed based on other reactive signals.
+ * @remarks
+ * It tracks dependencies automatically and recomputes its value when any dependency changes.
+ * Use FlowDerivation to create derived values in a reactive manner. It lazily initializes the computed value,
+ * ensuring that computations only occur when necessary.
+ * @typeparam T - The type of the computed value.
+ * @public
+ */
+export declare class FlowDerivation<T> extends FlowObservable<T> {
+    /**
+     * Creates a new FlowDerivation.
+     * @param compute - A function that computes the derived value. It is provided with two parameters:
+     * a getter and a watcher that respect dependency tracking.
+     * @public
+     */
+    constructor(compute: (get: FlowGetter, watch: FlowWatcher) => T);
+    /**
+     * Gets the current derived value.
+     * @returns The current computed value.
+     * @remarks
+     * This method lazily initializes and updates the derivation if it is marked as dirty. It throws an error
+     * if the derivation has been disposed.
+     * @public
+     */
+    get(): T;
+    private _initialized;
+    private _dirty;
+    private _trackedGet;
+    private _trackedWatch;
+    private _untrackedGet;
+    private _untrackedWatch;
+    private _trackedCompute;
+    private _untrackedCompute;
+    private _initEager;
+    private _initLazy;
+}
+//# sourceMappingURL=derivation.d.ts.map

package/dist/types/basic/derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../../src/basic/derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;GAQG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACpD;;;;;OAKG;gBACS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC;IAK/D;;;;;;;OAOG;IACI,GAAG,IAAI,CAAC;IASf,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,WAAW,CAAyD;IAC5E,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,aAAa,CAAgD;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAW;IAEpC,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;CAyBpB"}

package/dist/types/basic/effect.d.ts

@@ -0,0 +1,56 @@
+import { FlowGetter } from './observable';
+import { FlowWatcher } from './signal';
+/**
+ * Represents a reactive effect that executes side-effect functions based
+ * on its tracked dependencies.
+ *
+ * @remarks
+ * The FlowEffect executes an apply function that performs side effects,
+ * running initially in a tracked mode to register dependencies and then in
+ * an untracked mode to re-execute the effect on updates.
+ *
+ * @public
+ */
+export declare class FlowEffect {
+    /**
+     * Creates a new FlowEffect.
+     *
+     * @param apply - A side-effect function that receives a getter and a watcher to
+     * access and register dependencies on reactive observables and signals.
+     *
+     * @remarks
+     * The provided function is executed immediately in a tracked mode to collect dependencies.
+     * On subsequent executions, it runs in an untracked mode.
+     *
+     * @public
+     */
+    constructor(apply: (get: FlowGetter, watch: FlowWatcher) => void);
+    /**
+     * Disposes the effect, unregistering all its tracked dependencies.
+     *
+     * @remarks
+     * Once disposed, the effect must no longer be used. Trying to dispose an effect
+     * that is already disposed will throw an error.
+     *
+     * @public
+     */
+    dispose(): void;
+    /**
+     * Indicates whether this effect has been disposed.
+     *
+     * @returns A boolean value that is true if the effect is disposed, false otherwise.
+     *
+     * @public
+     */
+    get disposed(): boolean;
+    private _disposed;
+    private _initialized;
+    private _dependencies;
+    private _trackedGet;
+    private _trackedWatch;
+    private _untrackedGet;
+    private _untrackedWatch;
+    private _trackedExec;
+    private _untrackedExec;
+}
+//# sourceMappingURL=effect.d.ts.map

package/dist/types/basic/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../src/basic/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACnB;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI;IAOhE;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAQtB;;;;;;OAMG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAID,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAyB;IAE9C,OAAO,CAAC,WAAW,CAAyD;IAC5E,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,aAAa,CAAgD;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,cAAc,CAAa;CAsBtC"}

package/dist/types/basic/index.d.ts

@@ -0,0 +1,9 @@
+export { FlowSignal } from './signal';
+export { FlowState } from './state';
+export { FlowObservable } from './observable';
+export { FlowDerivation } from './derivation';
+export { FlowEffect } from './effect';
+export { FlowConstant } from './constant';
+export type { FlowGetter } from './observable';
+export type { FlowWatcher } from './signal';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/basic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/basic/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/basic/observable.d.ts

@@ -0,0 +1,34 @@
+import { FlowSignal } from './signal';
+/**
+ * A function that retrieves the current value from a FlowObservable.
+ * @typeparam T - The type of the value held by the observable.
+ * @param observable - The FlowObservable instance to retrieve the value from.
+ * @returns The current value of the observable.
+ * @public
+ */
+export type FlowGetter = <T>(observable: FlowObservable<T>) => T;
+/**
+ * Represents a reactive observable that holds and tracks a value.
+ *
+ *
+ * @remarks Subclasses must implement the {@link FlowObservable.get} method to return the current value.
+ * @typeparam T - The type of the value held by the observable.
+ * @public
+ */
+export declare abstract class FlowObservable<T> extends FlowSignal {
+    /**
+     * Retrieves the current value stored in the observable.
+     * Subclasses must override this method to provide the current value.
+     * @returns The current value of type T.
+     * @public
+     */
+    abstract get(): T;
+    /**
+     * Subscribes a listener function to changes of the observable.
+     * The listener is executed immediately with the current value and on subsequent updates.
+     * @param listener - A callback function that receives the new value.
+     * @returns A disposer function to cancel the subscription.
+     */
+    subscribe(listener: (value: T) => void): () => void;
+}
+//# sourceMappingURL=observable.d.ts.map

package/dist/types/basic/observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../../src/basic/observable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAEjE;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU;IACtD;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,IAAI,CAAC;IAWjB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;CAMtD"}

package/dist/types/basic/signal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A function for watching a FlowSignal.
+ * @param signal - The FlowSignal that is being observed.
+ * @public
+ */
+export type FlowWatcher = (signal: FlowSignal) => void;
+/**
+ * Represents a reactive signal.
+ *
+ * @remarks Use FlowSignal to create reactive streams that notify listeners and execute associated effects.
+ * Signals can be triggered and disposed. Once disposed, interactions with the signal will throw errors.
+ * @public
+ */
+export declare class FlowSignal {
+    /**
+     * Triggers the FlowSignal.
+     * Notifies all registered listeners and schedules execution of associated effects.
+     * @throws If the FlowSignal has already been disposed.
+     * @public
+     */
+    trigger(): void;
+    /**
+     * Disposes the FlowSignal.
+     * Cleans up all registered effects, listeners, and dependencies.
+     * Once disposed, further usage of the signal will throw an error.
+     * @throws If the FlowSignal is already disposed.
+     * @public
+     */
+    dispose(): void;
+    /**
+     * Indicates whether the FlowSignal has been disposed.
+     * @remarks Once disposed, the signal should not be used.
+     * @public
+     */
+    get disposed(): boolean;
+}
+//# sourceMappingURL=signal.d.ts.map

package/dist/types/basic/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../../src/basic/signal.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAEvD;;;;;;GAMG;AACH,qBAAa,UAAU;IACnB;;;;;OAKG;IACI,OAAO,IAAI,IAAI;IAKtB;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;IAUtB;;;;OAIG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;CAoDJ"}

package/dist/types/basic/state.d.ts

@@ -0,0 +1,26 @@
+import { FlowConstant } from './constant';
+/**
+ * Represents a reactive state that holds a mutable value.
+ *
+ * @typeparam T - The type of the state value.
+ *
+ * @remarks
+ * FlowState extends FlowConstant, which provides the {@link FlowConstant.get} method to read
+ * the current state. Use the {@link FlowState.set} method to update the state. When the state is updated,
+ * subscribers are notified automatically. This class notifies subscribers only when the value changes.
+ *
+ * @public
+ */
+export declare class FlowState<T> extends FlowConstant<T> {
+    /**
+     * Updates the state with a new value.
+     * @param value - A new value or a callback function that computes a new value based on the current state.
+     * @remarks
+     * If the computed new value is strictly equal to the current state value, no change is made and subscribers
+     * will not be notified. Otherwise, the state is updated and all subscribers are informed of the change.
+     * @throws Error if the state has been disposed.
+     * @public
+     */
+    set(value: T | ((current: T) => T)): void;
+}
+//# sourceMappingURL=state.d.ts.map

package/dist/types/basic/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/basic/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;GAWG;AACH,qBAAa,SAAS,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAC7C;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI;CAc5C"}

package/dist/types/creators.d.ts

@@ -1,17 +1,18 @@
-import { FlowDerivation } from './derivation';
-import { FlowEffect } from './effect';
-import { FlowGetter } from './observable';
-import { FlowResource } from './resource';
-import { FlowSignal, FlowWatcher } from './signal';
-import { FlowState } from './state';
-import { FlowMap } from './map';
-import { FlowStream } from './stream';
+import { FlowMap, FlowResource, FlowResourceAsync, FlowStream, FlowStreamAsync } from './advanced/';
+import { FlowConstant, FlowDerivation, FlowEffect, FlowSignal, FlowState, FlowGetter, FlowWatcher } from './basic/';
 /**
  * Creates a new reactive signal.
  * @returns A new instance of {@link FlowSignal}.
  * @public
  */
 export declare function signal(): FlowSignal;
+/**
+ * Creates a new reactive constant.
+ * @param value - The value or a function that returns the value.
+ * @returns A new instance of {@link FlowConstant}.
+ * @public
+ */
+export declare function constant<T>(value: T | (() => T)): FlowConstant<T>;
 /**
  * Creates a new reactive state holding a value.
  * @typeparam T - The type of the state value.
@@ -19,26 +20,41 @@ export declare function signal(): FlowSignal;
  * @returns A new instance of {@link FlowState}.
  * @public
  */
-export declare function state<T>(value: T): FlowState<T>;
+export declare function state<T>(value: T | (() => T)): FlowState<T>;
 /**
  * Creates a new reactive resource that asynchronously fetches its value.
  * @typeparam T - The type of the resource value.
  * @param fn - An asynchronous function that fetches the resource value.
- * @param initial - The initial value of the resource.
  * @returns A new instance of {@link FlowResource}.
  * @public
  */
-export declare function resource<T>(fn: () => Promise<T>, initial: T): FlowResource<T>;
+export declare function resource<T>(fn: () => Promise<T>): FlowResource<T>;
+/**
+ * Creates a new reactive asynchronous resource that fetches its value.
+ * @typeparam T - The type of the resource value.
+ * @param fn - An asynchronous function that fetches the resource value.
+ * @returns A new instance of {@link FlowResourceAsync}.
+ * @public
+ */
+export declare function resourceAsync<T>(fn: () => Promise<T>): FlowResourceAsync<T>;
 /**
  * Creates a new reactive stream.
  * @typeparam T - The type of the stream value.
  * @param updater - A function that receives a setter to update the stream's value.
  * It should return a disposer function to clean up resources.
- * @param initial - The initial value of the stream.
  * @returns A new instance of {@link FlowStream}.
  * @public
  */
-export declare function stream<T>(updater: (set: (value: T) => void) => () => void, initial: T): FlowStream<T>;
+export declare function stream<T>(updater: (set: (value: T) => void) => () => void): FlowStream<T>;
+/**
+ * Creates a new reactive asynchronous stream.
+ * @typeparam T - The type of the stream value.
+ * @param updater - A function that receives a setter to update the stream's value.
+ * It should return a disposer function to clean up resources.
+ * @returns A new instance of {@link FlowStreamAsync}.
+ * @public
+ */
+export declare function streamAsync<T>(updater: (set: (value: T) => void) => () => void): FlowStreamAsync<T>;
 /**
  * Creates a new reactive derivation whose value is computed based on other reactive signals.
  * @typeparam T - The type of the derived value.

package/dist/types/creators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"creators.d.ts","sourceRoot":"","sources":["../../src/creators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,UAAU,CAEnC;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAE/C;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAE7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACpB,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI,EAChD,OAAO,EAAE,CAAC,GACX,UAAU,CAAC,CAAC,CAAC,CAEf;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAE/F;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,UAAU,CAEpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,EACrD,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAIf"}
+{"version":3,"file":"creators.d.ts","sourceRoot":"","sources":["../../src/creators.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,eAAe,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,YAAY,EACZ,cAAc,EACd,UAAU,EACV,UAAU,EACV,SAAS,EACZ,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,UAAU,CAEnC;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAE3E;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACpB,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI,GACjD,UAAU,CAAC,CAAC,CAAC,CAEf;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EACzB,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI,GACjD,eAAe,CAAC,CAAC,CAAC,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EACxB,EAAE,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC,GAC/C,cAAc,CAAC,CAAC,CAAC,CAEnB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAClB,EAAE,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,GAClD,UAAU,CAEZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,EACrD,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAIf"}

package/dist/types/index.d.ts

@@ -6,13 +6,7 @@
  * effects, and reactive maps.
  *
  */
-export { signal, state, resource, stream, derivation, effect, map } from './creators';
-export type { FlowDerivation } from './derivation';
-export type { FlowEffect } from './effect';
-export type { FlowGetter, FlowObservable } from './observable';
-export type { FlowResource } from './resource';
-export type { FlowSignal, FlowWatcher } from './signal';
-export type { FlowState } from './state';
-export type { FlowMap } from './map';
-export type { FlowStream, FlowDisposer, FlowSetter, FlowUpdater } from './stream';
+export { signal, state, constant, resource, stream, derivation, effect, map, streamAsync, resourceAsync, } from './creators';
+export type { FlowDerivation, FlowEffect, FlowGetter, FlowObservable, FlowSignal, FlowWatcher, FlowState, FlowConstant, } from './basic/';
+export type { FlowResource, FlowMap, FlowResourceAsync, FlowStreamAsync, FlowStream, FlowStreamDisposer, FlowStreamSetter, FlowStreamUpdater, } from './advanced/';
 //# sourceMappingURL=index.d.ts.map