@ersbeth/picoflow 0.0.1 → 0.2.0

package/src/signal.ts

@@ -1,166 +0,0 @@
-import type { 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 class FlowSignal {
-    /* API ---------------------------------------------------------------------- */
-
-    /**
-     * Triggers the signal.
-     * @remarks
-     * This method notifies all registered listeners and causes associated effects to execute.
-     * @throws Error if the signal is disposed.
-     * @public
-     */
-    public trigger(): void {
-        if (this._disposed) throw new Error("Signal is disposed");
-        this._notify();
-    }
-
-    /**
-     * 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
-     */
-    public dispose(): void {
-        if (this._disposed) throw new Error("Signal is disposed");
-        Array.from(this._effects).forEach((effect) => effect.dispose());
-        Array.from(this._listeners).forEach((listener) => listener.dispose());
-        Array.from(this._dependencies).forEach((dependency) => {
-            this._unregisterDependency(dependency);
-        });
-        this._disposed = true;
-    }
-
-    /**
-     * Indicates whether the signal has been disposed.
-     * @remarks
-     * Once disposed, the signal should not be used.
-     * @public
-     */
-    public get disposed(): boolean {
-        return this._disposed;
-    }
-
-    /* INTERNAL ------------------------------------------------------------- */
-
-    /**
-     * @internal
-     */
-    protected _disposed = false;
-
-    /**
-     * @internal
-     */
-    protected _dependencies = new Set<FlowSignal>();
-
-    /**
-     * @internal
-     */
-    protected _listeners = new Set<FlowSignal>();
-
-    /**
-     * @internal
-     */
-    protected _effects = new Set<FlowEffect>();
-
-    /**
-     * @internal
-     * Internal method to watch the signal.
-     * @throws Error if the signal is disposed.
-     */
-    _watch(): void {
-        if (this._disposed) throw new Error("Signal is disposed");
-    }
-
-    /**
-     * @internal
-     * Notifies all listeners and executes all registered effects.
-     */
-    _notify(): void {
-        this._listeners.forEach((listener) => listener._notify());
-        this._effects.forEach((effect) => effect._exec());
-    }
-
-    /**
-     * @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 {
-        listener._registerDependency(this);
-        this._watch();
-    }
-
-    /**
-     * @internal
-     * Registers a dependency with the given FlowSignal.
-     * @param dependency - The FlowSignal to register as a dependency.
-     */
-    _registerDependency(dependency: FlowSignal): void {
-        this._dependencies.add(dependency);
-        dependency._registerListener(this);
-    }
-
-    /**
-     * @internal
-     * Unregisters the given dependency.
-     * @param dependency - The FlowSignal to unregister.
-     */
-    _unregisterDependency(dependency: FlowSignal): void {
-        this._dependencies.delete(dependency);
-        dependency._unregisterListener(this);
-    }
-
-    /**
-     * @internal
-     * Registers a listener (another FlowSignal) to this signal.
-     * @param signal - The FlowSignal to register as a listener.
-     */
-    _registerListener(signal: FlowSignal): void {
-        this._listeners.add(signal);
-    }
-
-    /**
-     * @internal
-     * Unregisters the given listener.
-     * @param signal - The FlowSignal to unregister.
-     */
-    _unregisterListener(signal: FlowSignal): void {
-        this._listeners.delete(signal);
-    }
-
-    /**
-     * @internal
-     * Registers a FlowEffect to this signal.
-     * @param effect - The FlowEffect to register.
-     */
-    _registerEffect(effect: FlowEffect): void {
-        this._effects.add(effect);
-    }
-
-    /**
-     * @internal
-     * Unregisters the given FlowEffect.
-     * @param effect - The FlowEffect to unregister.
-     */
-    _unregisterEffect(effect: FlowEffect): void {
-        this._effects.delete(effect);
-    }
-}

package/src/state.ts

@@ -1,52 +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 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) {
-        super();
-        this._value = value;
-    }
-
-    /**
-     * Retrieves the current state value.
-     * @returns The current value of the state.
-     * @throws Error if the state has been disposed.
-     * @public
-     */
-    get(): T {
-        if (this._disposed) throw new Error("State is disposed");
-        return this._value;
-    }
-
-    /**
-     * 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 {
-        if (this._disposed) throw new Error("State is disposed");
-        if (value === this._value) return;
-        this._value = value;
-        this._notify();
-    }
-}

package/src/stream.ts

@@ -1,99 +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 class FlowStream<T> extends FlowObservable<T> {
-    /* API -------------------------------------------------------- */
-
-    /**
-     * 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) {
-        super();
-        this._value = initial;
-        this._disposer = updater((value: T) => {
-            this._set(value);
-        });
-    }
-
-    /**
-     * Retrieves the current value of the stream.
-     * @returns The current value.
-     * @throws Error if the stream is disposed.
-     * @public
-     */
-    public get(): T {
-        if (this._disposed) throw new Error("Stream is disposed");
-        return this._value;
-    }
-
-    /**
-     * Disposes the stream, releasing all resources.
-     * @remarks
-     * In addition to disposing the underlying observable, this method calls the disposer
-     * returned by the updater.
-     * @public
-     */
-    public override dispose(): void {
-        super.dispose();
-        this._disposer();
-    }
-
-    /* INTERNAL ------------------------------------------------------ */
-
-    /**
-     * @internal
-     * The disposer function returned by the updater.
-     */
-    private _disposer: FlowDisposer;
-
-    /**
-     * @internal
-     * Updates the stream's value and notifies subscribers if the value changes.
-     * @param value - The new value to set.
-     * @internal
-     */
-    private _set(value: T): void {
-        if (this._disposed) throw new Error("Stream is disposed");
-        if (value === this._value) return;
-        this._value = value;
-        this._notify();
-    }
-}