@ersbeth/picoflow 2.3.1 → 3.0.0

package/dist/types/api/base/flowConfig.d.ts

@@ -1,17 +0,0 @@
-/**
- * Installs a global handler for errors that escape the reactive flush.
- *
- * All reactive work — recomputing derivations, running effects — happens inside an
- * asynchronous flush. Without this hook, an error escaping the flush (an effect callback
- * that throws with no `onError`, or a feedback loop between two effects) becomes an
- * uncaught exception, which terminates a Node process. Installing a handler here makes
- * that error catchable instead.
- *
- * Defaults to `console.error`. The handler replaces any previously installed handler —
- * it is not additive.
- *
- * @param handler - Called with the error that escaped the flush.
- *
- * @public
- */
-export declare function onFlushError(handler: (error: unknown) => void): void;

package/dist/types/api/base/flowDisposable.d.ts

@@ -1,40 +0,0 @@
-/**
- * Contract for resources that can be explicitly released to prevent memory leaks.
- *
- * All reactive primitives in PicoFlow implement this interface, allowing manual cleanup of subscriptions
- * and dependencies. Once disposed, the resource cannot be reused and will throw errors on further access.
- * Call `dispose()` when you no longer need a reactive primitive to free its resources.
- *
- * @public
- */
-export interface FlowDisposable {
-    /**
-     * Indicates whether this resource has been disposed.
-     *
-     * Returns `true` if `dispose()` has been called, `false` otherwise. Once disposed,
-     * the resource is no longer usable and any operations on it will throw errors.
-     */
-    get disposed(): boolean;
-    /**
-     * Releases all resources held by this disposable object.
-     *
-     * Cleans up all subscriptions, dependencies, and internal state. After calling this method,
-     * the resource enters a disposed state and cannot be reused. Any subsequent operations will
-     * throw errors. This method should be called when you no longer need the reactive primitive
-     * to prevent memory leaks.
-     */
-    dispose(): void;
-}
-/**
- * Type guard to check if an object implements the FlowDisposable interface.
- *
- * Useful for conditionally disposing objects that may or may not be disposable,
- * such as when cleaning up mixed collections of values. Returns true if the object
- * has a `dispose` method, providing type-safe access to disposal functionality.
- *
- * @param obj - The object to check
- * @returns True if the object implements FlowDisposable, false otherwise
- *
- * @public
- */
-export declare function isDisposable(obj: unknown): obj is FlowDisposable;

package/dist/types/api/base/flowErrors.d.ts

@@ -1 +0,0 @@
-export { PicoFlowCycleError, PicoFlowDisposedError, PicoFlowError, PicoFlowInternalError } from '../../base/errors.js';

package/dist/types/api/base/flowObservable.d.ts

@@ -1,26 +0,0 @@
-import { FlowDisposable } from './flowDisposable.js';
-import { FlowSubscribable } from './flowSubscribable.js';
-import { FlowTracker } from './flowTracker.js';
-/**
- * Contract for reactive primitives that emit changes and notify their dependents in the reactivity graph.
- * @public
- */
-export interface FlowObservable<T> extends FlowDisposable, FlowSubscribable<T> {
-    /**
-     * Establishes a reactive dependency without reading the value.
-     *
-     * Registers this observable as a dependency of the given tracker, allowing it to be notified
-     * when changes occur. This enables dependency tracking without accessing the actual value.
-     *
-     * @param tracker - Tracker that records this observable as a dependency
-     */
-    watch(tracker: FlowTracker): void;
-    /**
-     * Manually triggers notifications to all dependents.
-     *
-     * Forces all dependents of this observable to be notified and re-executed, even if the
-     * value hasn't actually changed. Useful for imperatively triggering updates when the
-     * reactive system cannot detect changes automatically.
-     */
-    trigger(): void;
-}

package/dist/types/api/base/flowPrimitiveOptions.d.ts

@@ -1,14 +0,0 @@
-/**
- * Optional per-instance settings accepted by the primitive factories (`state`, `derivation`,
- * `array`, `map`, `signal`, …).
- *
- * @public
- */
-export interface FlowPrimitiveOptions {
-    /**
-     * Identifies this primitive in error messages, e.g. `"[PicoFlow] Primitive \"$count\" is disposed"`
-     * instead of the unnamed `"[PicoFlow] Primitive is disposed"`. Purely diagnostic — has no effect
-     * on reactive behavior.
-     */
-    name?: string;
-}

package/dist/types/api/base/flowSubscribable.d.ts

@@ -1,78 +0,0 @@
-import { FlowEffect } from '../nodes/flowEffect.js';
-import { FlowTracker } from './flowTracker.js';
-/**
- * Function that tracks reactive dependencies and returns data.
- *
- * This function is called during effect execution with a tracker parameter that automatically
- * records any reactive values accessed. The tracker enables automatic dependency tracking without
- * explicit subscriptions. The returned data is passed to the `onData` callback.
- *
- * @param t - Tracker object that records dependencies when reactive values are accessed
- * @returns The computed data of type T
- *
- * @public
- */
-export type FlowDataTracker<T> = (t: FlowTracker) => T;
-/**
- * Callback invoked when new data is available.
- *
- * This callback runs each time the effect executes successfully, receiving the data returned
- * by the tracker function. It's called immediately on effect creation and then on every reactive
- * re-execution. Use this callback to perform side effects with the computed data.
- *
- * @param data - The computed data from the tracker function
- * @returns Always returns undefined (callbacks are for side effects)
- *
- * @public
- */
-export type FlowOnDataListener<T> = (data: T) => void;
-/**
- * Callback invoked when an error occurs during effect execution.
- *
- * If provided, this callback handles any errors thrown by the tracker function (except PendingError).
- * Without this callback, errors propagate and may crash the application. Use this for error logging,
- * recovery, or user feedback. The effect remains active and will retry on the next reactive trigger.
- *
- * @param error - The error that occurred, always normalized to an Error instance
- * @returns Always returns undefined (callbacks are for side effects)
- *
- * @public
- */
-export type FlowOnErrorListener = (error: Error) => void;
-/**
- * Callback invoked when an async computation is pending.
- *
- * This callback is triggered when the tracker function throws a PendingError, indicating that
- * async dependencies are still resolving. Use this to show loading states or pending indicators.
- * The effect will automatically re-execute once the async values settle.
- *
- * @returns Always returns undefined (callbacks are for side effects)
- *
- * @public
- */
-export type FlowOnPendingListener = () => void;
-/**
- * Contract for observables that can be subscribed to with lifecycle callbacks.
- *
- * This interface enables imperative subscription to reactive values, allowing manual control over
- * when effects run. The subscribe method returns a disposal function to stop the subscription.
- * Useful for integrating with non-reactive code or frameworks that manage subscriptions differently.
- *
- * @public
- */
-export interface FlowSubscribable<T> {
-    /**
-     * Subscribes to this observable with lifecycle callbacks.
-     *
-     * Creates an active subscription that executes immediately and then re-executes whenever
-     * the observable's dependencies change. The subscription remains active until the returned
-     * disposal function is called. The `onData` callback receives the computed value, while
-     * `onError` handles errors and `onPending` signals async operations in progress.
-     *
-     * @param onData - Callback invoked with the computed data on each execution
-     * @param onError - Optional callback for handling errors during execution
-     * @param onPending - Optional callback invoked when async dependencies are pending
-     * @returns A function to dispose the subscription and stop receiving updates
-     */
-    subscribe(onData: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
-}

package/dist/types/api/base/flowTracker.d.ts

@@ -1,7 +0,0 @@
-import { FlowDisposable } from './flowDisposable.js';
-/**
- * Contract for reactive computations that track dependencies and react to changes in the reactivity graph.
- * @public
- */
-export interface FlowTracker extends FlowDisposable {
-}

package/dist/types/api/base/index.d.ts

@@ -1,7 +0,0 @@
-export * from './flowConfig.js';
-export * from './flowDisposable.js';
-export * from './flowErrors.js';
-export * from './flowObservable.js';
-export * from './flowPrimitiveOptions.js';
-export * from './flowSubscribable.js';
-export * from './flowTracker.js';

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

@@ -1,2 +0,0 @@
-export * from './base/index.js';
-export * from './nodes/index.js';

package/dist/types/api/nodes/async/flowConstantAsync.d.ts

@@ -1,32 +0,0 @@
-import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
-import { FlowValue } from '../flowValue.js';
-/** Function that initializes a value asynchronously. */
-export type InitFunctionAsync<T> = () => Promise<T>;
-/**
- * Read-only reactive value that resolves once from a promise or async initializer.
- *
- * Async constants provide lazy initialization for asynchronous values. The promise or async initializer
- * runs once on first access, and the resolved value is cached forever. While pending, accessing the value
- * throws PendingError. Use for async operations that only need to run once, such as loading remote configuration,
- * fetching initial data, or computing expensive async resources.
- *
- * @public
- */
-export interface FlowConstantAsync<T> extends FlowValue<T> {
-}
-/**
- * Creates a constant reactive value from a promise or async initializer that resolves once and never recomputes.
- *
- * The promise or async initializer executes once on first access, and the resolved value is cached permanently.
- * While the promise is pending, any reactive computation that accesses the value will receive PendingError and
- * automatically retry once the promise resolves. Use for one-time async operations that don't depend on other
- * reactive values, such as loading configuration or fetching initial data.
- *
- * @param value - Promise to resolve, or async function that returns a promise on first access
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowConstantAsync that provides read-only access to the resolved value
- *
- * @public
- */
-export declare function constantAsync<T>(value: Promise<T>, options?: FlowPrimitiveOptions): FlowConstantAsync<T>;
-export declare function constantAsync<T>(initializer: InitFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowConstantAsync<T>;

package/dist/types/api/nodes/async/flowDerivationAsync.d.ts

@@ -1,37 +0,0 @@
-import { FlowPrimitiveOptions, FlowTracker } from '../../base/index.js';
-import { FlowValue } from '../flowValue.js';
-import { NotPromise } from '../utils.js';
-/** Function that derives a value asynchronously from dependencies and optionally the previous value. */
-export type DerivationFunctionAsync<T> = (tracker: FlowTracker, previous?: NotPromise<T> | undefined) => Promise<T>;
-/**
- * Read-only reactive value that recomputes asynchronously when dependencies change.
- *
- * Async derivations track reactive values accessed during computation and automatically recompute when any
- * tracked dependency changes. The compute function returns a promise, and the resolved value is cached until
- * dependencies change. While recomputing, accessing the value throws PendingError. Use for values derived from
- * async operations like API calls, database queries, or any computation that depends on reactive state and
- * requires async work.
- *
- * @public
- */
-export interface FlowDerivationAsync<T> extends FlowValue<T> {
-    /**
-     * Forces the derivation to recompute even if dependencies haven't changed.
-     */
-    refresh(): void;
-}
-/**
- * Creates an async derived value that automatically recomputes when dependencies change.
- *
- * The async compute function tracks dependencies and returns a promise. When any tracked dependency changes,
- * the function runs again and returns a new promise. The resolved value is cached until the next change.
- * While the promise is pending, reactive computations that access this value receive PendingError and automatically
- * retry once resolved. Use for derived data from async sources like filtered API results or computed database queries.
- *
- * @param compute - Async function that accesses dependencies and returns a promise of the derived value
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowDerivationAsync that provides read-only access to the resolved computed value
- *
- * @public
- */
-export declare function derivationAsync<T>(compute: DerivationFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowDerivationAsync<T>;

package/dist/types/api/nodes/async/flowStateAsync.d.ts

@@ -1,42 +0,0 @@
-import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
-import { FlowValue } from '../flowValue.js';
-import { NotPromise } from '../utils.js';
-import { InitFunctionAsync } from './flowConstantAsync.js';
-/** Function that updates a value asynchronously based on the previous value. */
-export type UpdateFunctionAsync<T> = (previous: NotPromise<T> | undefined) => Promise<T>;
-/**
- * Writable reactive value that resolves promises and can be updated with new promises.
- *
- * Async state is the async equivalent of regular state. Unlike sync state, it accepts promises instead of
- * direct values. Set new promises or async updater functions to update the state. While a promise is pending,
- * accessing the value throws PendingError. Use for async data that changes imperatively, such as user-triggered
- * API calls, async form submissions, or any async operation that updates based on user actions.
- *
- * @public
- */
-export interface FlowStateAsync<T> extends FlowValue<T> {
-    /**
-     * Updates the state with a new promise or via an async updater function.
-     * Notifies all dependents immediately (they will receive PendingError until resolved).
-     *
-     * @param promise - New promise to resolve, or async function that receives current value and returns a promise
-     */
-    set(promise: Promise<T>): void;
-    set(updater: UpdateFunctionAsync<T>): void;
-}
-/**
- * Creates a mutable async reactive state that resolves promises and can be updated imperatively.
- *
- * State can be initialized with a direct promise or a lazy async initializer function. Update the state by
- * calling `set()` with a new promise or an async updater function. Changes propagate automatically to all
- * reactive computations that depend on this state. Use for async data that changes through user actions or
- * application logic, such as loading user profiles, fetching search results, or any async state updates.
- *
- * @param value - Initial promise to resolve, or lazy async initializer function
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowStateAsync that can be read and modified with promises
- *
- * @public
- */
-export declare function stateAsync<T>(value: Promise<T>, options?: FlowPrimitiveOptions): FlowStateAsync<T>;
-export declare function stateAsync<T>(initializer: InitFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowStateAsync<T>;

package/dist/types/api/nodes/async/flowWritableDerivationAsync.d.ts

@@ -1,31 +0,0 @@
-import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
-import { DerivationFunctionAsync, FlowDerivationAsync } from './flowDerivationAsync.js';
-import { FlowStateAsync } from './flowStateAsync.js';
-/**
- * Writable reactive value that recomputes asynchronously when dependencies change, but can be manually overridden.
- *
- * Async writable derivations combine reactive async computation with manual control. They track dependencies and
- * recompute asynchronously like regular async derivations, but you can also call `set()` to override the computed
- * value with a new promise. While recomputing or pending, accessing the value throws PendingError. Use for computed
- * async values that users can edit, such as formatted async fields, calculated async totals that can be adjusted,
- * or any async value that is usually derived but sometimes needs manual correction.
- *
- * @public
- */
-export interface FlowWritableDerivationAsync<T> extends FlowStateAsync<T>, FlowDerivationAsync<T> {
-}
-/**
- * Creates an async derived value that recomputes automatically but can also be manually overridden.
- *
- * The async compute function tracks dependencies and returns a promise. When any tracked dependency changes,
- * the function runs again and returns a new promise. However, you can also call `set()` to override the computed
- * value with a new promise. Use for async values that are normally derived but need occasional manual adjustments,
- * such as editable async calculated fields or user-correctable async totals.
- *
- * @param compute - Async function that accesses dependencies and returns a promise of the derived value
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowWritableDerivationAsync that provides both reactive async computation and manual control
- *
- * @public
- */
-export declare function writableDerivationAsync<T>(compute: DerivationFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowWritableDerivationAsync<T>;

package/dist/types/api/nodes/async/index.d.ts

@@ -1,4 +0,0 @@
-export * from './flowConstantAsync.js';
-export * from './flowDerivationAsync.js';
-export * from './flowStateAsync.js';
-export * from './flowWritableDerivationAsync.js';

package/dist/types/api/nodes/collections/flowArray.d.ts

@@ -1,138 +0,0 @@
-import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
-import { FlowState } from '../sync/flowState.js';
-/**
- * Discriminated union representing all possible array mutation operations.
- *
- * Each mutation on a FlowArray emits an action describing what changed. This enables fine-grained
- * reactive tracking - you can observe the array itself or subscribe to `$lastAction` to react only
- * to specific mutations. Use this for optimized rendering, undo/redo systems, or any scenario where
- * you need to know exactly what changed rather than just that something changed.
- *
- * @public
- */
-export type FlowArrayAction<T> = {
-    type: "set";
-    setItems: T[];
-    clearedItems: T[];
-} | {
-    type: "update";
-    index: number;
-    setItem: T;
-    clearedItem: T | undefined;
-} | {
-    type: "push";
-    addedItem: T;
-} | {
-    type: "pop";
-    removedItem: T | undefined;
-} | {
-    type: "unshift";
-    addedItem: T;
-} | {
-    type: "shift";
-    removedItem: T | undefined;
-} | {
-    type: "splice";
-    start: number;
-    deleteCount: number;
-    addedItems: T[];
-    removedItems: T[];
-} | {
-    type: "clear";
-    clearedItems: T[];
-};
-/**
- * Reactive array with standard mutation methods and fine-grained change tracking.
- *
- * FlowArray behaves like a regular array but notifies dependents on mutations. It provides all standard
- * array mutation methods (push, pop, splice, etc.) and tracks each operation via the `$lastAction` signal.
- * This enables both coarse-grained reactivity (reacting to any change) and fine-grained reactivity (reacting
- * only to specific mutations). Use for lists that need reactive updates, such as todo lists, data tables,
- * or any collection that changes over time.
- *
- * @public
- */
-export interface FlowArray<T> extends FlowState<T[]> {
-    /**
-     * Replaces an item at a specific index.
-     * Emits an "update" action to $lastAction.
-     *
-     * @param index - The index of the item to replace
-     * @param item - The new item
-     * @returns The previous item at that index
-     */
-    update(index: number, item: T): T | undefined;
-    /**
-     * Appends an item to the end of the array.
-     * Emits a "push" action to $lastAction.
-     *
-     * @param item - The item to append
-     */
-    push(item: T): void;
-    /**
-     * Removes and returns the last item from the array.
-     * Emits a "pop" action to $lastAction when an item is removed.
-     * If the array is already empty, returns undefined without notifying dependents or updating $lastAction.
-     *
-     * @returns The removed item, or undefined if the array was empty
-     */
-    pop(): T | undefined;
-    /**
-     * Inserts an item at the beginning of the array.
-     * Emits an "unshift" action to $lastAction.
-     *
-     * @param item - The item to insert
-     */
-    unshift(item: T): void;
-    /**
-     * Removes and returns the first item from the array.
-     * Emits a "shift" action to $lastAction when an item is removed.
-     * If the array is already empty, returns undefined without notifying dependents or updating $lastAction.
-     *
-     * @returns The removed item, or undefined if the array was empty
-     */
-    shift(): T | undefined;
-    /**
-     * Changes the content of the array by removing, replacing, or adding items.
-     * Emits a "splice" action to $lastAction.
-     *
-     * @param start - The starting index
-     * @param deleteCount - Number of items to remove
-     * @param newItems - New items to add at the start position
-     * @returns Array of removed items
-     */
-    splice(start: number, deleteCount: number, ...newItems: T[]): T[];
-    /**
-     * Removes all items from the array.
-     * Emits a "clear" action to $lastAction.
-     *
-     * @returns Array of all removed items
-     */
-    clear(): T[];
-    /**
-     * The current length of the array.
-     */
-    length: number;
-    /**
-     * Reactive state containing the last mutation operation performed on the array.
-     * `.subscribe()` invokes its callback once per mutation (including several in the same tick).
-     * `get()` / `pick()` expose only the latest action snapshot.
-     */
-    $lastAction: FlowState<FlowArrayAction<T>>;
-}
-/**
- * Creates a reactive array with mutation methods and fine-grained action tracking.
- *
- * The array starts with the provided initial items (or empty if none provided). All mutation methods
- * (push, pop, splice, etc.) notify dependents and emit detailed action information to `$lastAction`.
- * Use the array itself for coarse-grained reactivity, or subscribe to `$lastAction` for fine-grained
- * reactivity to specific mutation types. Useful for reactive lists, collections, or any data that
- * needs array-like operations with automatic change propagation.
- *
- * @param initial - Optional initial array of items
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowArray with reactive mutation methods
- *
- * @public
- */
-export declare function array<T>(initial?: T[], options?: FlowPrimitiveOptions): FlowArray<T>;

package/dist/types/api/nodes/collections/flowMap.d.ts

@@ -1,100 +0,0 @@
-import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
-import { FlowState } from '../sync/flowState.js';
-/**
- * Discriminated union representing all possible map mutation operations.
- *
- * Each mutation on a FlowMap emits an action describing what changed. This enables fine-grained
- * reactive tracking - you can observe the map itself or subscribe to `$lastAction` to react only
- * to specific mutations. Use this for optimized updates, undo/redo systems, or any scenario where
- * you need to know exactly what changed rather than just that something changed.
- *
- * @public
- */
-export type FlowMapAction<K, V> = {
-    type: "set";
-    setMap: Map<K, V>;
-    clearedMap: Map<K, V>;
-} | {
-    type: "add";
-    key: K;
-    addedValue: V;
-} | {
-    type: "update";
-    key: K;
-    setValue: V;
-    clearedValue: V;
-} | {
-    type: "delete";
-    key: K;
-    removedValue: V;
-} | {
-    type: "clear";
-    clearedMap: Map<K, V>;
-};
-/**
- * Reactive map with standard mutation methods and fine-grained change tracking.
- *
- * FlowMap behaves like a regular Map but notifies dependents on mutations. It provides standard
- * map operations (add, update, delete) and tracks each operation via the `$lastAction` signal.
- * This enables both coarse-grained reactivity (reacting to any change) and fine-grained reactivity
- * (reacting only to specific mutations). Use for key-value collections that need reactive updates,
- * such as entity stores, lookup tables, or any map-based data that changes over time.
- *
- * @public
- */
-export interface FlowMap<K, V> extends FlowState<Map<K, V>> {
-    /**
-     * Removes a key-value pair from the map.
-     * Emits a "delete" action to $lastAction.
-     *
-     * @param key - The key to delete
-     * @returns The deleted value
-     */
-    delete(key: K): V;
-    /**
-     * Updates an existing key-value pair in the map.
-     * Emits an "update" action to $lastAction.
-     *
-     * @param key - The key to update (must exist)
-     * @param value - The new value
-     * @returns The previous value
-     */
-    update(key: K, value: V): V | undefined;
-    /**
-     * Adds a new key-value pair to the map.
-     * Emits an "add" action to $lastAction.
-     *
-     * @param key - The key to add (must not exist)
-     * @param value - The value to associate with the key
-     */
-    add(key: K, value: V): void;
-    /**
-     * Removes all entries from the map.
-     * Emits a "clear" action to $lastAction.
-     *
-     * @returns Map of all removed entries
-     */
-    clear(): Map<K, V>;
-    /**
-     * Reactive state containing the last mutation operation performed on the map.
-     * `.subscribe()` invokes its callback once per mutation (including several in the same tick).
-     * `get()` / `pick()` expose only the latest action snapshot.
-     */
-    $lastAction: FlowState<FlowMapAction<K, V>>;
-}
-/**
- * Creates a reactive map with mutation methods and fine-grained action tracking.
- *
- * The map starts with the provided initial entries (or empty if none provided). All mutation methods
- * (add, update, delete) notify dependents and emit detailed action information to `$lastAction`.
- * Use the map itself for coarse-grained reactivity, or subscribe to `$lastAction` for fine-grained
- * reactivity to specific mutation types. Useful for entity stores, lookup tables, or any key-value
- * data that needs reactive updates.
- *
- * @param initial - Optional initial entries as a Record or Map
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowMap with reactive mutation methods
- *
- * @public
- */
-export declare function map<K extends string | number | symbol, V>(initial?: Record<K, V> | Map<K, V>, options?: FlowPrimitiveOptions): FlowMap<K, V>;

package/dist/types/api/nodes/collections/index.d.ts

@@ -1,2 +0,0 @@
-export * from './flowArray.js';
-export * from './flowMap.js';

package/dist/types/api/nodes/flowEffect.d.ts

@@ -1,28 +0,0 @@
-import { FlowDisposable } from '../base/flowDisposable.js';
-import { FlowDataTracker, FlowOnDataListener, FlowOnErrorListener, FlowOnPendingListener } from '../base/flowSubscribable.js';
-/**
- * Handle to a reactive effect that automatically tracks dependencies and re-executes when they change.
- *
- * Effects run immediately upon creation and then reactively respond to changes in any reactive values
- * accessed during execution. Call `dispose()` to stop the effect and clean up its subscriptions.
- *
- * @public
- */
-export interface FlowEffect extends FlowDisposable {
-}
-/**
- * Creates a reactive effect that runs immediately and automatically re-runs when dependencies change.
- *
- * The effect function tracks any reactive values accessed and subscribes to their changes.
- * When any tracked value changes, the effect re-executes with the new values.
- * Optional callbacks handle errors and pending async states.
- *
- * @param data - Function that accesses reactive dependencies and returns data
- * @param onData - Callback invoked with the computed data on each execution
- * @param onError - Optional callback for handling errors during execution
- * @param onPending - Optional callback invoked when async dependencies are pending
- * @returns A FlowEffect handle with a `dispose()` method to stop the effect
- *
- * @public
- */
-export declare function subscribe<T>(data: FlowDataTracker<T>, onData: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;

package/dist/types/api/nodes/flowSignal.d.ts

@@ -1,26 +0,0 @@
-import { FlowObservable } from '../base/flowObservable.js';
-import { FlowPrimitiveOptions } from '../base/flowPrimitiveOptions.js';
-/**
- * Manual trigger that notifies subscribers without carrying data.
- *
- * Unlike reactive state or derivations, signals don't hold values. They serve as event emitters
- * that notify dependents when explicitly triggered. Use signals for side effects that should run
- * in response to manual actions rather than data changes.
- *
- * @public
- */
-export interface FlowSignal extends FlowObservable<void> {
-}
-/**
- * Creates a signal that can be manually triggered to notify dependents.
- *
- * Signals act as event emitters in the reactive graph. Call `trigger()` to notify all subscribers
- * and reactive computations that depend on the signal. Unlike state or derivations, signals don't
- * carry data values - they simply represent that an event occurred.
- *
- * @param options - Optional settings; `name` identifies this primitive in error messages
- * @returns A FlowSignal that can be triggered manually and subscribed to
- *
- * @public
- */
-export declare function signal(options?: FlowPrimitiveOptions): FlowSignal;