@ersbeth/picoflow 0.0.1

package/dist/types/derivation.d.ts

@@ -0,0 +1,58 @@
+import { FlowGetter, FlowObservable } from './observable';
+import { FlowWatcher } from './signal';
+/**
+ * Represents a reactive derivation whose value is computed based on other reactive signals.
+ * @remarks
+ * A FlowDerivation automatically tracks its dependencies and recomputes its value when needed.
+ * @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 a getter
+     * and a watcher function to access observables and signals dependencies.
+     * @public
+     */
+    constructor(compute: (get: FlowGetter, watch: FlowWatcher) => T);
+    /**
+     * Gets the current derived value.
+     * @returns The current computed value.
+     * @remarks
+     * This method ensures that the derivation is up-to-date before returning the value.
+     * @public
+     */
+    get(): T;
+    /** @internal */
+    private _initialized;
+    /** @internal */
+    private _dirty;
+    /** @internal */
+    private _trackedGet;
+    /** @internal */
+    private _trackedWatch;
+    /** @internal */
+    private _untrackedGet;
+    /** @internal */
+    private _untrackedWatch;
+    /** @internal */
+    private _trackedExec;
+    /** @internal */
+    private _untrackedExec;
+    /**
+     * @internal
+     * Executes the compute function if necessary to update the derived value.
+     */
+    _exec(): void;
+    /**
+     * @internal
+     * Marks the derivation as dirty and notifies downstream dependencies.
+     */
+    _notify(): void;
+    /**
+     * @internal
+     * Ensures that the derivation is up-to-date when it is watched.
+     */
+    _watch(): void;
+}
+//# sourceMappingURL=derivation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../src/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;;;;;;GAMG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAEpD;;;;;OAKG;gBACS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC;IAM/D;;;;;;OAMG;IACI,GAAG,IAAI,CAAC;IAOf,gBAAgB;IAChB,OAAO,CAAC,YAAY,CAAS;IAE7B,gBAAgB;IAChB,OAAO,CAAC,MAAM,CAAQ;IAEtB,gBAAgB;IAChB,OAAO,CAAC,WAAW,CAAyD;IAE5E,gBAAgB;IAChB,OAAO,CAAC,aAAa,CAAoD;IAEzE,gBAAgB;IAChB,OAAO,CAAC,aAAa,CAAgD;IAErE,gBAAgB;IAChB,OAAO,CAAC,eAAe,CAA4C;IAEnE,gBAAgB;IAChB,OAAO,CAAC,YAAY,CAAU;IAE9B,gBAAgB;IAChB,OAAO,CAAC,cAAc,CAAU;IAEhC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAab;;;OAGG;IACM,OAAO,IAAI,IAAI;IAKxB;;;OAGG;IACM,MAAM,IAAI,IAAI;CAG1B"}

package/dist/types/effect.d.ts

@@ -0,0 +1,108 @@
+import { FlowGetter } from './observable';
+import { FlowSignal, FlowWatcher } from './signal';
+/**
+ * Represents a reactive effect that executes a side‐effect function
+ * based on its tracked dependencies.
+ *
+ * @remarks
+ * A FlowEffect runs an apply function to perform side effects. The apply function
+ * is executed in two modes:
+ * Initially, in a tracked mode to register dependencies.
+ * Subsequently, in an untracked mode to only re-execute the effect .
+ *
+ * @public
+ */
+export declare class FlowEffect {
+    /**
+     * Creates a new FlowEffect.
+     *
+     * @param apply - A function that performs the side effect. It receives a getter and a watcher
+     * function to access and register dependencies on reactive observables and signals.
+     *
+     * @public
+     */
+    constructor(apply: (get: FlowGetter, watch: FlowWatcher) => void);
+    /**
+     * Disposes the effect, unregistering all its dependencies.
+     *
+     * @remarks
+     * After disposal, the effect should no longer be used. Calling this method on an already
+     * disposed effect will throw an error.
+     *
+     * @public
+     */
+    dispose(): void;
+    /**
+     * Indicates whether this effect has been disposed.
+     *
+     * @returns A boolean value indicating if the effect is disposed.
+     *
+     * @public
+     */
+    get disposed(): boolean;
+    /**
+     * @internal
+     */
+    private _disposed;
+    /**
+     * @internal
+     */
+    private _initialized;
+    /**
+     * @internal
+     */
+    private _dependencies;
+    /**
+     * @internal
+     * A tracked getter that registers a dependency when accessing an observable.
+     */
+    private _trackedGet;
+    /**
+     * @internal
+     * A tracked watcher that registers a dependency when watching a signal.
+     */
+    private _trackedWatch;
+    /**
+     * @internal
+     * An untracked getter that simply retrieves the current value from an observable.
+     */
+    private _untrackedGet;
+    /**
+     * @internal
+     * An untracked watcher that calls the default watch on a signal.
+     */
+    private _untrackedWatch;
+    /**
+     * @internal
+     * Execution function used during initialization (tracked mode).
+     */
+    private _trackedExec;
+    /**
+     * @internal
+     * Execution function used after initialization (untracked mode).
+     */
+    private _untrackedExec;
+    /**
+     * @internal
+     * Executes the effect. If the effect has not been initialized, it runs in tracked mode;
+     * otherwise, it runs in untracked mode.
+     *
+     * @throws Error if the effect has been disposed.
+     */
+    _exec(): void;
+    /**
+     * @internal
+     * Registers a dependency on the given signal.
+     *
+     * @param dependency - The FlowSignal to register as a dependency.
+     */
+    _registerDependency(dependency: FlowSignal): void;
+    /**
+     * @internal
+     * Unregisters the given dependency.
+     *
+     * @param dependency - The FlowSignal to unregister.
+     */
+    _unregisterDependency(dependency: FlowSignal): void;
+}
+//# sourceMappingURL=effect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IAGnB;;;;;;;OAOG;gBACS,KAAK,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI;IAMhE;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAQtB;;;;;;OAMG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAID;;OAEG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;IACH,OAAO,CAAC,YAAY,CAAS;IAE7B;;OAEG;IACH,OAAO,CAAC,aAAa,CAAyB;IAE9C;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAyD;IAE5E;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAoD;IAEzE;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAgD;IAErE;;;OAGG;IACH,OAAO,CAAC,eAAe,CAA4C;IAEnE;;;OAGG;IACH,OAAO,CAAC,YAAY,CAAa;IAEjC;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAa;IAEnC;;;;;;OAMG;IACH,KAAK,IAAI,IAAI;IASb;;;;;OAKG;IACH,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAKjD;;;;;OAKG;IACH,qBAAqB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;CAItD"}

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @packageDocumentation
+ *
+ * PicoFlow is a lightweight reactive dataflow library that provides a set of
+ * reactive primitives such as signals, state, resources, streams, derivations,
+ * 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';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACtF,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACxD,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,YAAY,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrC,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/map.d.ts

@@ -0,0 +1,75 @@
+import { FlowState } from './state';
+/**
+ * Represents a reactive map of states that extends {@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:
+ *
+ * **$lastSet**: A FlowState that holds the most recent key-value pair that was set.
+ *
+ * **$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.
+ *
+ * @typeparam K - The type of the map keys.
+ * @typeparam V - The type of the map values.
+ *
+ * @public
+ */
+export declare class FlowMap<K, V> extends FlowState<Map<K, V>> {
+    /**
+     * A reactive state that holds the most recent key and value that were set.
+     *
+     * @remarks
+     * When a key is set via {@link FlowMap.setAt}, this state is updated with
+     * the corresponding key and value.
+     *
+     * @public
+     */
+    $lastSet: FlowState<{
+        key?: K;
+        value?: V;
+    }>;
+    /**
+     * A reactive state that holds the most recent key and value that were deleted.
+     *
+     * @remarks
+     * When a key is deleted via {@link FlowMap.delete}, this state is updated with
+     * the corresponding key and its last known value.
+     *
+     * @public
+     */
+    $lastDeleted: FlowState<{
+        key?: K;
+        value?: V;
+    }>;
+    /**
+     * Sets a value at the specified key in the underlying map.
+     *
+     * @param key - The key at which to set the value.
+     * @param value - The value to set.
+     *
+     * @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.
+     *
+     * @public
+     */
+    setAt(key: K, value: V): void;
+    /**
+     * Deletes the value at the specified key from the underlying map.
+     *
+     * @param key - The key to delete.
+     *
+     * @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.
+     *
+     * @public
+     */
+    delete(key: K): void;
+}
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEnD;;;;;;;;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;;;;;;;;;;;OAWG;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/observable.d.ts

@@ -0,0 +1,40 @@
+import { FlowEffect } from './effect';
+import { FlowSignal } from './signal';
+/**
+ * A function for retrieving the current value from a FlowObservable.
+ * @typeparam T - The type of the value held by the observable.
+ * @param atom - The FlowObservable from which to get the value.
+ * @returns The current value of the observable.
+ * @public
+ */
+export type FlowGetter = <T>(observable: FlowObservable<T>) => T;
+/**
+ * Represents a reactive observable that carries a value.
+ * @typeparam T - The type of the value held by the observable.
+ * @remarks
+ * A FlowObservable extends the basic FlowSignal to store a value. Subclasses must
+ * implement the abstract {@link FlowObservable.get} method to return the current value.
+ * @public
+ */
+export declare abstract class FlowObservable<T> extends FlowSignal {
+    /**
+     * Retrieves the current value of the observable.
+     * @returns The current value.
+     * @public
+     */
+    abstract get(): T;
+    /**
+     * @internal
+     * Internal storage for the observable's value.
+     */
+    protected _value: T;
+    /**
+     * @internal
+     * Retrieves the current value from the observable and registers a dependency
+     * from the provided listener.
+     * @param listener - The FlowObservable or FlowEffect that is accessing this observable.
+     * @returns The current value, as returned by {@link FlowObservable.get}.
+     */
+    _getFrom(listener: FlowObservable<unknown> | FlowEffect): T;
+}
+//# sourceMappingURL=observable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../src/observable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,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;IAGtD;;;;OAIG;IACH,QAAQ,CAAC,GAAG,IAAI,CAAC;IAIjB;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAG,CAAC,CAAC;IAErB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,UAAU,GAAG,CAAC;CAI9D"}

package/dist/types/resource.d.ts

@@ -0,0 +1,46 @@
+import { FlowObservable } from './observable';
+/**
+ * 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.
+ *
+ * @typeparam T - The type of the resource value.
+ *
+ * @public
+ */
+export declare class FlowResource<T> extends FlowObservable<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);
+    /**
+     * Retrieves the current resource value.
+     * @returns The current value.
+     * @throws Error if the resource is disposed.
+     * @public
+     */
+    get(): T;
+    /**
+     * 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>;
+    /**
+     * @internal
+     * The asynchronous function used to fetch the resource value.
+     */
+    private _fetch;
+}
+//# sourceMappingURL=resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAElD;;;;;OAKG;gBACS,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;IAM/C;;;;;OAKG;IACI,GAAG,IAAI,CAAC;IAKf;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUnC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAmB;CACpC"}

package/dist/types/signal.d.ts

@@ -0,0 +1,111 @@
+import { FlowEffect } from './effect';
+/**
+ * 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
+ * A FlowSignal allows you to trigger notifications via {@link FlowSignal.trigger}
+ * and to dispose the signal and all its registered dependencies, listeners, and effects via {@link FlowSignal.dispose}.
+ * @public
+ */
+export declare class FlowSignal {
+    /**
+     * Triggers the signal.
+     * @remarks
+     * This method notifies all registered listeners and causes associated effects to execute.
+     * @throws Error if the signal is disposed.
+     * @public
+     */
+    trigger(): void;
+    /**
+     * Disposes the signal.
+     * @remarks
+     * Disposing a signal will dispose all registered effects and listeners,
+     * and unregister all dependencies. Once disposed, any further calls to the signal
+     * will throw an error.
+     * @throws Error if the signal is already disposed.
+     * @public
+     */
+    dispose(): void;
+    /**
+     * Indicates whether the signal has been disposed.
+     * @remarks
+     * Once disposed, the signal should not be used.
+     * @public
+     */
+    get disposed(): boolean;
+    /**
+     * @internal
+     */
+    protected _disposed: boolean;
+    /**
+     * @internal
+     */
+    protected _dependencies: Set<FlowSignal>;
+    /**
+     * @internal
+     */
+    protected _listeners: Set<FlowSignal>;
+    /**
+     * @internal
+     */
+    protected _effects: Set<FlowEffect>;
+    /**
+     * @internal
+     * Internal method to watch the signal.
+     * @throws Error if the signal is disposed.
+     */
+    _watch(): void;
+    /**
+     * @internal
+     * Notifies all listeners and executes all registered effects.
+     */
+    _notify(): void;
+    /**
+     * @internal
+     * Registers a dependency from the given listener and watches the signal.
+     * @param listener - A FlowSignal or FlowEffect that will depend on this signal.
+     */
+    _watchFrom(listener: FlowSignal | FlowEffect): void;
+    /**
+     * @internal
+     * Registers a dependency with the given FlowSignal.
+     * @param dependency - The FlowSignal to register as a dependency.
+     */
+    _registerDependency(dependency: FlowSignal): void;
+    /**
+     * @internal
+     * Unregisters the given dependency.
+     * @param dependency - The FlowSignal to unregister.
+     */
+    _unregisterDependency(dependency: FlowSignal): void;
+    /**
+     * @internal
+     * Registers a listener (another FlowSignal) to this signal.
+     * @param signal - The FlowSignal to register as a listener.
+     */
+    _registerListener(signal: FlowSignal): void;
+    /**
+     * @internal
+     * Unregisters the given listener.
+     * @param signal - The FlowSignal to unregister.
+     */
+    _unregisterListener(signal: FlowSignal): void;
+    /**
+     * @internal
+     * Registers a FlowEffect to this signal.
+     * @param effect - The FlowEffect to register.
+     */
+    _registerEffect(effect: FlowEffect): void;
+    /**
+     * @internal
+     * Unregisters the given FlowEffect.
+     * @param effect - The FlowEffect to unregister.
+     */
+    _unregisterEffect(effect: FlowEffect): void;
+}
+//# sourceMappingURL=signal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/signal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAEvD;;;;;;GAMG;AACH,qBAAa,UAAU;IAGnB;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;IAKtB;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAUtB;;;;;OAKG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAID;;OAEG;IACH,SAAS,CAAC,SAAS,UAAS;IAE5B;;OAEG;IACH,SAAS,CAAC,aAAa,kBAAyB;IAEhD;;OAEG;IACH,SAAS,CAAC,UAAU,kBAAyB;IAE7C;;OAEG;IACH,SAAS,CAAC,QAAQ,kBAAyB;IAE3C;;;;OAIG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,OAAO,IAAI,IAAI;IAKf;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI;IAKnD;;;;OAIG;IACH,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAKjD;;;;OAIG;IACH,qBAAqB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAKnD;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI3C;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI7C;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAIzC;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;CAG9C"}

package/dist/types/state.d.ts

@@ -0,0 +1,39 @@
+import { FlowObservable } from './observable';
+/**
+ * Represents a reactive state that holds a mutable value.
+ *
+ * @typeparam T - The type of the state value.
+ *
+ * @remarks
+ * FlowState extends FlowObservable to provide a simple reactive state primitive.
+ * Use the {@link FlowState.get} method to read the current state and {@link FlowState.set} to update it.
+ * When the state is updated, subscribers are notified automatically.
+ *
+ * @public
+ */
+export declare class FlowState<T> extends FlowObservable<T> {
+    /**
+     * Creates a new FlowState with the given initial value.
+     * @param value - The initial value for the state.
+     * @public
+     */
+    constructor(value: T);
+    /**
+     * Retrieves the current state value.
+     * @returns The current value of the state.
+     * @throws Error if the state has been disposed.
+     * @public
+     */
+    get(): T;
+    /**
+     * Updates the state with a new value.
+     * @param value - The new value to set.
+     * @remarks
+     * If the new value is identical to the current value, no update or notification occurs.
+     * Otherwise, the state is updated and all subscribers are notified.
+     * @throws Error if the state has been disposed.
+     * @public
+     */
+    set(value: T): void;
+}
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,qBAAa,SAAS,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAE/C;;;;OAIG;gBACS,KAAK,EAAE,CAAC;IAKpB;;;;;OAKG;IACH,GAAG,IAAI,CAAC;IAKR;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;CAMtB"}

package/dist/types/stream.d.ts

@@ -0,0 +1,71 @@
+import { FlowObservable } from './observable';
+/**
+ * A function that sets a new value.
+ * @typeparam T - The type of the value.
+ * @public
+ */
+export type FlowSetter<T> = (value: T) => void;
+/**
+ * A function that disposes of a resource.
+ * @public
+ */
+export type FlowDisposer = () => void;
+/**
+ * A function that performs updates on a stream.
+ * @remarks
+ * The updater receives a setter function that can be used to update the stream's value.
+ * It should return a disposer function to clean up any resources or subscriptions.
+ * @typeparam T - The type of the stream value.
+ * @public
+ */
+export type FlowUpdater<T> = (set: FlowSetter<T>) => FlowDisposer;
+/**
+ * Represents a reactive stream that updates its value based on an updater function.
+ *
+ * @remarks
+ * A FlowStream extends FlowObservable and encapsulates a mechanism for updating its value
+ * via an external updater function. The updater is invoked during construction with a setter,
+ * and it returns a disposer to be called when the stream is disposed.
+ *
+ * @typeparam T - The type of the stream's value.
+ *
+ * @public
+ */
+export declare class FlowStream<T> extends FlowObservable<T> {
+    /**
+     * 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.
+     * @param initial - The initial value of the stream.
+     * @public
+     */
+    constructor(updater: FlowUpdater<T>, initial: T);
+    /**
+     * Retrieves the current value of the stream.
+     * @returns The current value.
+     * @throws Error if the stream is disposed.
+     * @public
+     */
+    get(): 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;
+    /**
+     * @internal
+     * The disposer function returned by the updater.
+     */
+    private _disposer;
+    /**
+     * @internal
+     * Updates the stream's value and notifies subscribers if the value changes.
+     * @param value - The new value to set.
+     * @internal
+     */
+    private _set;
+}
+//# sourceMappingURL=stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAE/C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,YAAY,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAIhD;;;;;;OAMG;gBACS,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;IAQ/C;;;;;OAKG;IACI,GAAG,IAAI,CAAC;IAKf;;;;;;OAMG;IACa,OAAO,IAAI,IAAI;IAO/B;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAe;IAEhC;;;;;OAKG;IACH,OAAO,CAAC,IAAI;CAMf"}

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@ersbeth/picoflow",
+    "version": "0.0.1",
+    "description": "Minimal Dataflow librairy for TypeScript",
+    "type": "module",
+    "exports": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/picoflow.js"
+    },
+    "imports": {
+        "#package": "./src/index.ts"
+    },
+    "scripts": {
+        "build": "npx vite build --config vite.config.ts",
+        "format": "npx biome check --fix",
+        "test": "npx vitest",
+        "lint": "npx biome ci",
+        "api:extract": "api-extractor run --local",
+        "api:generate": "api-documenter markdown -i ./api/temp -o ./api/doc",
+        "api:clean": "rm ./api/temp/*",
+        "api": "npm run api:extract && npm run api:generate && npm run api:clean"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^1.9.4",
+        "@vitest/coverage-v8": "^3.0.9",
+        "vite": "^6.2.3",
+        "vite-plugin-dts": "^4.5.3",
+        "vitest": "^3.0.9"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@gitlab.com/ersbeth-web/picoflow.git"
+    },
+    "author": "Elisabeth Rousset",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://gitlab.com/ersbeth-web/picoflow/issues"
+    },
+    "homepage": "https://gitlab.com/ersbeth-web/picoflow#readme"
+}