@ersbeth/picoflow 1.1.1 → 2.0.0

package/dist/types/flow/nodes/sync/flowDerivation.d.ts

@@ -1,100 +0,0 @@
-import { FlowTracker, NotPromise } from '../../base';
-import { FlowNode } from './flowNode';
-/**
- * Represents a reactive derivation whose value is computed based on other reactive signals.
- *
- * @typeParam T - The type of the computed value.
- *
- * @remarks
- * `FlowDerivation` is a type alias based on {@link FlowNode} with the `set()` method removed,
- * making it immutable. It provides all the reactive capabilities of `FlowNode` (dependency tracking,
- * lazy computation, caching) but prevents value mutation after initialization.
- *
- * Unlike {@link FlowConstant}, which computes its value once and never changes, derivations
- * automatically recompute when any tracked dependency changes. This makes them ideal for
- * creating derived state that stays in sync with its sources.
- *
- * **Lazy Computation:**
- * The compute function doesn't run immediately upon creation. It executes only when:
- * - The value is first read via `get()` or `pick()`
- * - The derivation is watched via `watch()`
- *
- * **Automatic Recomputation:**
- * When a tracked dependency changes, the derivation is marked as "dirty" but doesn't recompute
- * immediately. Recomputation happens lazily on the next value access. This prevents unnecessary
- * computations when multiple dependencies change in quick succession. You can also force
- * recomputation using the `refresh()` method.
- *
- * **Dynamic Dependencies:**
- * Dependencies are tracked dynamically during each computation. If the compute function
- * conditionally tracks different observables, the dependency graph updates automatically.
- *
- * @example
- * ```typescript
- * const $firstName = state('John');
- * const $lastName = state('Doe');
- *
- * const $fullName = derivation((t) => {
- *   return `${$firstName.get(t)} ${$lastName.get(t)}`;
- * });
- *
- * // Compute function hasn't run yet (lazy)
- * const name = await $fullName.pick(); // Now it computes: "John Doe"
- *
- * // When dependencies change, derivation recomputes automatically
- * await $firstName.set('Jane');
- * const newName = await $fullName.pick(); // "Jane Doe" (recomputed)
- * ```
- *
- * @public
- */
-export type FlowDerivation<T> = Omit<FlowNode<T>, "set">;
-/**
- * Creates a new reactive derivation whose value is computed based on other reactive signals.
- *
- * @typeParam T - The type of the derived value.
- *
- * @param fn - A function that computes the derived value using a tracking context. The function
- * receives a tracking context (`t`) that should be used to access dependencies via `.get(t)`.
- * The function is not executed immediately; it runs lazily on first access.
- *
- * @returns A new instance of {@link FlowDerivation} that provides reactive access to the computed value.
- *
- * @remarks
- * A derivation is a computed reactive value that automatically tracks its dependencies and
- * recomputes when they change. The computation is lazy - it runs only when the value is
- * accessed, not on construction. Use derivations to create derived state without manual
- * dependency management.
- *
- * **Lazy Computation:**
- * The compute function is not executed immediately upon creation. It runs only when:
- * - The value is first read via `get(t)` or `pick()`
- * - The derivation is watched via `watch()`
- *
- * **When to Use Derivations:**
- * - Use `derivation()` for values that should recompute when dependencies change
- * - Use `constant()` for values that compute once and never change
- * - Use `state()` for mutable values that can be updated directly
- *
- * @example
- * ```typescript
- * const $firstName = state('John');
- * const $lastName = state('Doe');
- *
- * const $fullName = derivation((t) => {
- *   return `${$firstName.get(t)} ${$lastName.get(t)}`;
- * });
- *
- * // Use in reactive context
- * effect((t) => {
- *   console.log($fullName.get(t)); // Logs: "John Doe"
- * });
- *
- * // When dependencies change, derivation recomputes automatically
- * await $firstName.set('Jane'); // Logs: "Jane Doe"
- * ```
- *
- * @public
- */
-export declare function derivation<T>(fn: (t: FlowTracker) => NotPromise<T>): FlowDerivation<T>;
-//# sourceMappingURL=flowDerivation.d.ts.map

package/dist/types/flow/nodes/sync/flowDerivation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowDerivation.d.ts","sourceRoot":"","sources":["../../../../../src/flow/nodes/sync/flowDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC3B,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,GACnC,cAAc,CAAC,CAAC,CAAC,CAEnB"}

package/dist/types/flow/nodes/sync/flowNode.d.ts

@@ -1,314 +0,0 @@
-import { FlowSignal, FlowTracker, NotPromise } from '../../base';
-/**
- * A versatile reactive node that can operate as mutable state or computed derivation.
- *
- * @typeParam T - The type of the value held by this node.
- *
- * @remarks
- * FlowNode is a flexible reactive primitive that adapts its behavior based on how it's initialized.
- * It extends {@link FlowSignal} and provides reactive value access with automatic dependency tracking.
- *
- * **Operating Modes:**
- *
- * - **Mutable State Mode**: When constructed with a constant value, FlowNode acts as a mutable
- *   reactive state. You can update its value using `set()`, and all dependents are automatically
- *   notified when the value changes.
- *
- * - **Computed Derivation Mode**: When constructed with a compute function, FlowNode acts as a
- *   computed value that automatically tracks its dependencies. The compute function runs lazily
- *   (only when the value is first accessed) and recomputes when any tracked dependency changes.
- *   The computed value can be temporarily overridden using `set()`, but the override is cleared
- *   on the next recomputation (triggered by dependency changes or `refresh()`).
- *
- * **Lazy Computation:**
- * When using a compute function, the computation doesn't run immediately upon construction. It
- * executes only when:
- * - The value is first read via `get()` or `pick()`
- * - The node is watched via `watch()`
- *
- * **Dirty Tracking:**
- * When a tracked dependency changes, the node is marked as "dirty" but doesn't recompute
- * immediately. Recomputation happens lazily on the next value access, preventing unnecessary
- * computations when multiple dependencies change in quick succession.
- *
- * **Dynamic Dependencies:**
- * Dependencies are tracked dynamically during each computation. If the compute function
- * conditionally tracks different observables, the dependency graph updates automatically.
- *
- * @example
- * ```typescript
- * // Mutable state mode
- * const $count = new FlowNode(0);
- * $count.set(1); // Updates the value
- *
- * // Computed derivation mode
- * const $firstName = new FlowNode('John');
- * const $lastName = new FlowNode('Doe');
- * const $fullName = new FlowNode((t) => {
- *   return `${$firstName.get(t)} ${$lastName.get(t)}`;
- * });
- *
- * // Compute function hasn't run yet (lazy)
- * const name = await $fullName.pick(); // Now it computes: "John Doe"
- *
- * // Temporarily override computed value
- * $fullName.set('Override');
- * console.log(await $fullName.pick()); // "Override"
- *
- * // Trigger recomputation (clears override)
- * $firstName.set('Jane');
- * console.log(await $fullName.pick()); // "Jane Doe" (override cleared)
- * ```
- *
- * @public
- */
-export declare class FlowNode<T extends NotPromise<unknown>> extends FlowSignal {
-    protected _value?: T;
-    private _dirty;
-    private _compute?;
-    /**
-     * Creates a new FlowNode.
-     *
-     * @param compute - Either a constant value or a compute function that derives the value.
-     *
-     * @remarks
-     * The constructor accepts two different initialization modes:
-     *
-     * - **Constant value**: Creates a mutable reactive node that can be updated via `set()`.
-     *   The value is stored immediately and can be changed at any time.
-     *
-     * - **Compute function**: Creates a computed reactive node that automatically tracks dependencies
-     *   and recomputes when they change. The compute function receives a tracking context (`t`)
-     *   that should be used to access dependencies via `.get(t)`. The function is not executed
-     *   immediately; it runs lazily on first access. The computed value can be temporarily
-     *   overridden using `set()`, but the override is cleared on the next recomputation
-     *   (triggered by dependency changes or `refresh()`).
-     *
-     * @example
-     * ```typescript
-     * // Mutable state with constant value
-     * const $count = new FlowNode(0);
-     * $count.set(5);
-     *
-     * // Computed derivation with function
-     * const $a = new FlowNode(10);
-     * const $b = new FlowNode(20);
-     * const $sum = new FlowNode((t) => $a.get(t) + $b.get(t));
-     *
-     * // Lazy evaluation - compute function hasn't run yet
-     * console.log(await $sum.pick()); // Now it computes: 30
-     * ```
-     *
-     * @public
-     */
-    constructor(compute: NotPromise<T> | ((t: FlowTracker) => NotPromise<T>));
-    watch(tracker: FlowTracker): void;
-    /**
-     * Gets the current value with dependency tracking.
-     *
-     * @param tracker - The tracking context for reactive tracking. This observable is registered
-     * as a dependency when accessed through this method.
-     *
-     * @returns The current value of type T.
-     *
-     * @remarks
-     * Use `get(t)` within effects and derivations to create reactive dependencies. The tracker
-     * parameter must be provided from the reactive context (typically the `t` parameter in effect
-     * or derivation callbacks).
-     *
-     * To read a value without creating a dependency, use `pick()` instead.
-     *
-     * @example
-     * ```typescript
-     * effect((t) => {
-     *   const tracked = $state.get(t);     // Dependency registered
-     *   const untracked = await $other.pick(); // No dependency
-     * });
-     * ```
-     *
-     * @throws Error if the node has been disposed.
-     *
-     * @public
-     */
-    get(tracker: FlowTracker | null): T;
-    /**
-     * Updates the node with a new value.
-     *
-     * @param value - A new value or a callback function that computes a new value based on the current value.
-     *
-     * @returns A promise that resolves after the update is processed and all dependent effects have been notified.
-     *
-     * @remarks
-     * This method can be used in two ways:
-     *
-     * **For mutable state nodes** (constructed with a constant value):
-     * - Updates the stored value directly
-     * - All dependents are notified of the change
-     *
-     * **For computed nodes** (constructed with a compute function):
-     * - Temporarily overrides the computed value
-     * - The override persists until the next recomputation, which occurs when:
-     *   - A tracked dependency changes, or
-     *   - `refresh()` is called
-     * - This allows temporarily overriding computed values for testing or manual control
-     *
-     * **Value Comparison:**
-     * If the new value is strictly equal (`===`) to the current value, no update occurs
-     * and subscribers are not notified. This prevents unnecessary re-renders and effect
-     * executions.
-     *
-     * **Asynchronous Processing:**
-     * The update is processed asynchronously through the reactive graph, ensuring proper
-     * ordering of updates and effect execution.
-     *
-     * @throws Error if the node has been disposed.
-     *
-     * @example
-     * ```typescript
-     * // Mutable state usage
-     * const $count = new FlowNode(0);
-     * await $count.set(5);
-     * await $count.set(current => current + 1); // 6
-     *
-     * // Temporary override of computed value
-     * const $source = new FlowNode(10);
-     * const $doubled = new FlowNode((t) => $source.get(t) * 2);
-     *
-     * console.log(await $doubled.pick()); // 20
-     *
-     * // Temporarily override
-     * await $doubled.set(50);
-     * console.log(await $doubled.pick()); // 50 (override active)
-     *
-     * // Dependency change clears override
-     * await $source.set(15);
-     * console.log(await $doubled.pick()); // 30 (recomputed, override cleared)
-     * ```
-     *
-     * @public
-     */
-    set(value: NotPromise<T> | ((current: T) => NotPromise<T>)): Promise<void>;
-    /**
-     * Forces recomputation of the value, even if it's not marked as dirty.
-     *
-     * @returns A promise that resolves after the recomputation is complete and all
-     * dependent effects have been notified.
-     *
-     * @remarks
-     * This method is useful when you need to force a recomputation of a computed value,
-     * for example when the computation depends on external data that has changed outside
-     * the reactive system.
-     *
-     * **Behavior:**
-     * - For nodes with a compute function: Forces the compute function to run again,
-     *   even if no dependencies have changed. This effectively clears any temporary
-     *   override that was set using `set()`.
-     * - For nodes without a compute function (mutable state): Recomputes the current
-     *   value (which is just the stored value), useful for consistency but typically
-     *   not necessary.
-     *
-     * The recomputation happens asynchronously through the reactive graph, ensuring
-     * proper ordering of updates and effect execution.
-     *
-     * @throws Error if the node has been disposed.
-     *
-     * @example
-     * ```typescript
-     * const $externalData = new FlowNode(() => fetchExternalData());
-     *
-     * // Some external event occurs that changes the data source
-     * externalDataChanged();
-     *
-     * // Force recomputation to get the new value
-     * await $externalData.refresh();
-     *
-     * // For computed nodes with temporary overrides
-     * const $computed = new FlowNode((t) => $source.get(t) * 2);
-     * $computed.set(100); // Temporary override
-     * await $computed.refresh(); // Clears override, recomputes from source
-     * ```
-     *
-     * @public
-     */
-    refresh(): Promise<void>;
-    /**
-     * Gets the current value without any dependency tracking.
-     *
-     * @returns A promise that resolves with the current value of type T.
-     *
-     * @remarks
-     * This method reads the value asynchronously through the reactive graph, ensuring proper ordering of
-     * read operations. Unlike `get(t)`, this method does not create a reactive dependency.
-     *
-     * Use `pick()` when you want to read a snapshot of the current value without creating a reactive
-     * dependency. This is useful for:
-     * - Reading initial values outside reactive contexts
-     * - Accessing configuration that shouldn't trigger updates
-     * - Mixing tracked and untracked reads in the same effect
-     *
-     * **Note:** This is an async method. Always use `await` when calling it.
-     *
-     * @example
-     * ```typescript
-     * // Read a snapshot outside reactive context
-     * const currentValue = await $state.pick();
-     *
-     * // Mix tracked and untracked reads
-     * effect(async (t) => {
-     *   const tracked = $reactive.get(t);        // Triggers re-runs
-     *   const snapshot = await $config.pick();    // Doesn't trigger re-runs
-     *   processData(tracked, snapshot);
-     * });
-     * ```
-     *
-     * @throws Error if the node has been disposed.
-     *
-     * @public
-     */
-    pick(): Promise<T>;
-    /**
-     * Subscribes a listener function to changes of this node.
-     *
-     * @param listener - A callback function that receives the new value whenever it changes.
-     *
-     * @returns A disposer function that cancels the subscription when called.
-     *
-     * @remarks
-     * This method creates a reactive subscription that automatically tracks this node as a dependency.
-     * The listener is executed:
-     * - Immediately with the current value when the subscription is created
-     * - Automatically whenever the value changes
-     *
-     * The subscription uses a {@link FlowEffect} internally to manage the reactive tracking and
-     * automatic re-execution. When the value changes, the listener is called with the new value
-     * after the update is processed through the reactive graph.
-     *
-     * **Cleanup:**
-     * Always call the returned disposer function when you no longer need the subscription to
-     * prevent memory leaks and unnecessary computations.
-     *
-     * @example
-     * ```typescript
-     * const $count = new FlowNode(0);
-     *
-     * // Subscribe to changes
-     * const unsubscribe = $count.subscribe((value) => {
-     *   console.log(`Count is now: ${value}`);
-     * });
-     * // Logs immediately: "Count is now: 0"
-     *
-     * await $count.set(5);
-     * // Logs: "Count is now: 5"
-     *
-     * // Clean up when done
-     * unsubscribe();
-     * ```
-     *
-     * @throws Error if the node has been disposed.
-     *
-     * @public
-     */
-    subscribe(listener: (value: T) => void): () => void;
-    private _computeValue;
-}
-//# sourceMappingURL=flowNode.d.ts.map

package/dist/types/flow/nodes/sync/flowNode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowNode.d.ts","sourceRoot":"","sources":["../../../../../src/flow/nodes/sync/flowNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,UAAU,EACV,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,UAAU,CAAC,OAAO,CAAC,CAAE,SAAQ,UAAU;IACtE,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACrB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAC,CAAwB;IAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;gBACS,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC;IAU/D,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAM1C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,CAAC;IAOnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAwB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC;IAMxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAkBnD,OAAO,CAAC,aAAa;CA0BrB"}

package/dist/types/flow/nodes/sync/flowReadonly.d.ts

@@ -1,57 +0,0 @@
-import { FlowNode } from './flowNode';
-/**
- * A generic utility type for creating read-only views of reactive nodes.
- *
- * @typeParam T - The type of the value held by the reactive node.
- *
- * @remarks
- * `FlowReadonly` is a type alias based on {@link FlowNode} with the `set()` method removed,
- * making it a read-only view. It provides all the reactive capabilities of `FlowNode`
- * (dependency tracking, lazy computation, caching, reading values) but prevents mutation.
- *
- * **Difference from FlowConstant and FlowDerivation:**
- * - {@link FlowConstant}: Specialized type for immutable constants that compute once and never change
- * - {@link FlowDerivation}: Specialized type for computed values that automatically recompute when dependencies change
- * - `FlowReadonly`: Generic utility type that can be used with any `FlowNode` to create a read-only view
- *
- * **Use Cases:**
- * - **Type Safety**: Ensure functions don't accidentally mutate state by accepting `FlowReadonly` instead of `FlowState`
- * - **API Design**: Expose read-only views of internal state to prevent external mutation
- * - **Function Parameters**: Accept any reactive node (state, derivation, constant) but prevent mutation
- * - **Composition**: Create read-only wrappers around mutable states for safer sharing
- *
- * @example
- * ```typescript
- * // Type safety: Function that only reads state
- * function displayCount(count: FlowReadonly<number>) {
- *   // count.set(100); // TypeScript error: Property 'set' does not exist
- *   effect((t) => {
- *     console.log(count.get(t)); // OK: Reading is allowed
- *   });
- * }
- *
- * const $count = state(0);
- * displayCount($count); // OK: FlowState is assignable to FlowReadonly
- *
- * // API design: Expose read-only view
- * class Counter {
- *   private _count = state(0);
- *
- *   get count(): FlowReadonly<number> {
- *     return this._count; // FlowState is assignable to FlowReadonly
- *   }
- *
- *   increment() {
- *     this._count.set(n => n + 1); // Internal mutation allowed
- *   }
- * }
- *
- * const counter = new Counter();
- * // counter.count.set(100); // TypeScript error: Cannot mutate read-only view
- * const current = await counter.count.pick(); // OK: Reading is allowed
- * ```
- *
- * @public
- */
-export type FlowReadonly<T> = Omit<FlowNode<T>, "set" | "refresh">;
-//# sourceMappingURL=flowReadonly.d.ts.map

package/dist/types/flow/nodes/sync/flowReadonly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowReadonly.d.ts","sourceRoot":"","sources":["../../../../../src/flow/nodes/sync/flowReadonly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC"}

package/dist/types/flow/nodes/sync/flowState.d.ts

@@ -1,96 +0,0 @@
-import { NotPromise } from '../../base';
-import { FlowNode } from './flowNode';
-/**
- * Represents a reactive state that holds a mutable value.
- *
- * @typeParam T - The type of the state value.
- *
- * @remarks
- * `FlowState` is a type alias of {@link FlowNode}, providing a mutable reactive state that can be
- * updated using the `set()` method. It provides all the reactive capabilities of `FlowNode`
- * (lazy computation, caching) with the ability to mutate the value.
- *
- * Unlike {@link FlowConstant}, which is immutable and computes once, states can be updated at any
- * time. Unlike {@link FlowDerivation}, which recomputes when dependencies change, states are
- * updated explicitly via `set()`.
- *
- * **Reading Values:**
- * You can read the state value using `get(t)` for tracked access (creates reactive dependency)
- * or `pick()` for untracked access (reads without creating dependency).
- *
- * **Updating Values:**
- * When the state is updated with a new value that differs from the current value (strict equality),
- * all dependent effects and derivations are automatically notified and re-executed. If the new value
- * is strictly equal to the current value, no notification occurs.
- *
- * @example
- * ```typescript
- * const $count = state(0);
- *
- * // Read with tracking
- * effect((t) => {
- *   console.log($count.get(t)); // Effect re-runs when $count changes
- * });
- *
- * // Read without tracking
- * const snapshot = await $count.pick();
- *
- * // Update the value
- * await $count.set(1);
- * await $count.set(current => current + 1);
- * ```
- *
- * @public
- */
-export type FlowState<T> = Omit<FlowNode<T>, "refresh">;
-/**
- * Creates a new reactive state holding a mutable value.
- *
- * @typeParam T - The type of the state value.
- *
- * @param value - The initial value for the state, or a function that returns the initial value.
- * If a function is provided, it is called lazily only when the value is first accessed via
- * `get()` or `pick()`. If a direct value is provided, it is stored immediately.
- *
- * @returns A new instance of {@link FlowState} that provides reactive access to the mutable value.
- *
- * @remarks
- * State is the most common reactive primitive - a mutable container that notifies dependents
- * when its value changes. Use `set()` to update the value (returns `Promise<void>`) and `get(t)`
- * or `pick()` to read it.
- *
- * **Lazy Initialization:**
- * When a function is provided, the initialization is lazy - the function is not called immediately
- * upon creation. It executes only when:
- * - The value is first read via `get(t)` or `pick()`
- * - The state is watched via `watch()`
- *
- * This is useful for expensive initializations that may not be needed immediately.
- *
- * **When to Use States:**
- * - Use `state()` for mutable values that can be updated directly
- * - Use `constant()` for values that compute once and never change
- * - Use `derivation()` for values that recompute when dependencies change
- *
- * @example
- * ```typescript
- * // Direct value - initialized immediately
- * const $count = state(0);
- *
- * // Lazy initialization - computed on first access
- * const $config = state(() => {
- *   return loadConfiguration();
- * });
- *
- * effect((t) => {
- *   console.log($count.get(t));
- * });
- *
- * await $count.set(1); // Logs: 1
- * await $count.set(n => n + 1); // Logs: 2
- * ```
- *
- * @public
- */
-export declare function state<T>(value: NotPromise<T> | (() => NotPromise<T>)): FlowState<T>;
-//# sourceMappingURL=flowState.d.ts.map

package/dist/types/flow/nodes/sync/flowState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowState.d.ts","sourceRoot":"","sources":["../../../../../src/flow/nodes/sync/flowState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACtB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,UAAU,CAAC,CAAC,CAAC,CAAC,GAC1C,SAAS,CAAC,CAAC,CAAC,CAEd"}

package/dist/types/flow/nodes/sync/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/flow/nodes/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/types/solid/converters.d.ts

@@ -1,53 +0,0 @@
-import { FlowReadonly, FlowReadonlyAsync } from '../flow';
-import { FlowTracker } from '../flow/base/flowTracker';
-import { SolidResource } from './primitives';
-/**
- * Utility type that excludes Promise types from T.
- * Used to ensure type safety for synchronous derivations/resources.
- *
- * @public
- */
-/**
- * Converts a FlowNode, FlowNodeAsync, or getter function into a SolidResource.
- *
- * @param flow - The FlowNode, FlowNodeAsync, or getter function to convert.
- * @returns A SolidResource that wraps the value or computation.
- *
- * @remarks
- * This function bridges PicoFlow's reactive system with SolidJS, allowing you to use
- * PicoFlow nodes and computations within Solid components. All conversions return a
- * `SolidResource`, which can handle both synchronous and asynchronous values seamlessly.
- *
- * The conversion works with:
- * - **FlowNode**: Synchronous reactive nodes (e.g., from `state()` or `derivation()`)
- * - **FlowNodeAsync**: Asynchronous reactive nodes (e.g., from `resourceAsync()`)
- * - **Getter functions**: Computation functions that use a FlowTracker to access reactive values
- *
- * The created SolidResource automatically subscribes to the PicoFlow nodes and updates
- * when their values change. The subscription is properly cleaned up when the Solid
- * component unmounts.
- *
- * @example
- * ```typescript
- * import { from } from 'picoflow/solid';
- * import { state } from 'picoflow';
- *
- * // Convert a PicoFlow state to a Solid resource
- * const $count = state(0);
- * const solidCount = from($count);
- *
- * // Use in a Solid component
- * function Counter() {
- *   return <div>Count: {solidCount.get()}</div>;
- * }
- *
- * // Or convert a computation function
- * const solidDerived = from((t) => {
- *   return solidCount.get(t) * 2;
- * });
- * ```
- *
- * @public
- */
-export declare function from<T>(flow: FlowReadonlyAsync<T> | FlowReadonly<T> | ((t: FlowTracker) => T) | ((t: FlowTracker) => Promise<T>)): SolidResource<T>;
-//# sourceMappingURL=converters.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../../../src/solid/converters.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAmE7C;;;;;GAKG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACrB,IAAI,EACD,iBAAiB,CAAC,CAAC,CAAC,GACpB,YAAY,CAAC,CAAC,CAAC,GACf,CAAC,CAAC,CAAC,EAAE,WAAW,KAAK,CAAC,CAAC,GACvB,CAAC,CAAC,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACjC,aAAa,CAAC,CAAC,CAAC,CAUlB"}

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

@@ -1,3 +0,0 @@
-export * from './converters';
-export * from './primitives';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/solid/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}