@ersbeth/picoflow 0.0.1 → 0.2.0

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

@@ -1 +0,0 @@
-{"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.map

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

@@ -1,111 +0,0 @@
-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

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

@@ -1,39 +0,0 @@
-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

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

@@ -1,71 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/src/derivation.ts

@@ -1,96 +0,0 @@
-import { type FlowGetter, FlowObservable } from "./observable";
-import type { 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 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) {
-        super();
-        this._trackedExec = () => compute(this._trackedGet, this._trackedWatch);
-        this._untrackedExec = () =>
-            compute(this._untrackedGet, this._untrackedWatch);
-    }
-
-    /**
-     * 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
-     */
-    public get(): T {
-        this._exec();
-        return this._value;
-    }
-
-    /* INTERNAL MEMBERS AND METHODS */
-
-    /** @internal */
-    private _initialized = false;
-
-    /** @internal */
-    private _dirty = true;
-
-    /** @internal */
-    private _trackedGet: FlowGetter = (observable) => observable._getFrom(this);
-
-    /** @internal */
-    private _trackedWatch: FlowWatcher = (signal) => signal._watchFrom(this);
-
-    /** @internal */
-    private _untrackedGet: FlowGetter = (observable) => observable.get();
-
-    /** @internal */
-    private _untrackedWatch: FlowWatcher = (signal) => signal._watch();
-
-    /** @internal */
-    private _trackedExec: () => T;
-
-    /** @internal */
-    private _untrackedExec: () => T;
-
-    /**
-     * @internal
-     * Executes the compute function if necessary to update the derived value.
-     */
-    _exec(): void {
-        if (this._disposed) throw new Error("Effect is disposed");
-
-        if (this._dirty) {
-            if (this._initialized) this._value = this._untrackedExec();
-            else {
-                this._value = this._trackedExec();
-                this._initialized = true;
-            }
-            this._dirty = false;
-        }
-    }
-
-    /**
-     * @internal
-     * Marks the derivation as dirty and notifies downstream dependencies.
-     */
-    override _notify(): void {
-        this._dirty = true;
-        super._notify();
-    }
-
-    /**
-     * @internal
-     * Ensures that the derivation is up-to-date when it is watched.
-     */
-    override _watch(): void {
-        this._exec();
-    }
-}

package/src/effect.ts

@@ -1,152 +0,0 @@
-import type { FlowGetter } from "./observable";
-import type { 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 class FlowEffect {
-    /* API --------------------------------------------------- */
-
-    /**
-     * 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) {
-        this._trackedExec = () => apply(this._trackedGet, this._trackedWatch);
-        this._untrackedExec = () =>
-            apply(this._untrackedGet, this._untrackedWatch);
-        this._exec();
-    }
-
-    /**
-     * 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
-     */
-    public dispose(): void {
-        if (this._disposed) throw new Error("Effect is disposed");
-        Array.from(this._dependencies).forEach((dependency) => {
-            this._unregisterDependency(dependency);
-        });
-        this._disposed = true;
-    }
-
-    /**
-     * Indicates whether this effect has been disposed.
-     *
-     * @returns A boolean value indicating if the effect is disposed.
-     *
-     * @public
-     */
-    public get disposed(): boolean {
-        return this._disposed;
-    }
-
-    /* INTERNAL ------------------------------------------------------------ */
-
-    /**
-     * @internal
-     */
-    private _disposed = false;
-
-    /**
-     * @internal
-     */
-    private _initialized = false;
-
-    /**
-     * @internal
-     */
-    private _dependencies = new Set<FlowSignal>();
-
-    /**
-     * @internal
-     * A tracked getter that registers a dependency when accessing an observable.
-     */
-    private _trackedGet: FlowGetter = (observable) => observable._getFrom(this);
-
-    /**
-     * @internal
-     * A tracked watcher that registers a dependency when watching a signal.
-     */
-    private _trackedWatch: FlowWatcher = (signal) => signal._watchFrom(this);
-
-    /**
-     * @internal
-     * An untracked getter that simply retrieves the current value from an observable.
-     */
-    private _untrackedGet: FlowGetter = (observable) => observable.get();
-
-    /**
-     * @internal
-     * An untracked watcher that calls the default watch on a signal.
-     */
-    private _untrackedWatch: FlowWatcher = (signal) => signal._watch();
-
-    /**
-     * @internal
-     * Execution function used during initialization (tracked mode).
-     */
-    private _trackedExec: () => void;
-
-    /**
-     * @internal
-     * Execution function used after initialization (untracked mode).
-     */
-    private _untrackedExec: () => void;
-
-    /**
-     * @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 {
-        if (this._disposed) throw new Error("Effect is disposed");
-        if (this._initialized) this._untrackedExec();
-        else {
-            this._trackedExec();
-            this._initialized = true;
-        }
-    }
-
-    /**
-     * @internal
-     * Registers a dependency on the given signal.
-     *
-     * @param dependency - The FlowSignal to register as a dependency.
-     */
-    _registerDependency(dependency: FlowSignal): void {
-        this._dependencies.add(dependency);
-        dependency._registerEffect(this);
-    }
-
-    /**
-     * @internal
-     * Unregisters the given dependency.
-     *
-     * @param dependency - The FlowSignal to unregister.
-     */
-    _unregisterDependency(dependency: FlowSignal): void {
-        this._dependencies.delete(dependency);
-        dependency._unregisterEffect(this);
-    }
-}

package/src/observable.ts

@@ -1,50 +0,0 @@
-import type { 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 abstract class FlowObservable<T> extends FlowSignal {
-    /* API ----------------------------------------------- */
-
-    /**
-     * Retrieves the current value of the observable.
-     * @returns The current value.
-     * @public
-     */
-    abstract get(): T;
-
-    /* INTERNAL -------------------------------------------*/
-
-    /**
-     * @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 {
-        listener._registerDependency(this);
-        return this.get();
-    }
-}