@ersbeth/picoflow 0.2.2 → 0.2.3

package/dist/picoflow.js

@@ -1,4 +1,4 @@
-let FlowSignal$1 = class FlowSignal {
+class FlowSignal {
   /**
    * Triggers the FlowSignal.
    * Notifies all registered listeners and schedules execution of associated effects.
@@ -93,9 +93,9 @@ let FlowSignal$1 = class FlowSignal {
   _unregisterEffect(effect) {
     this._effects.delete(effect);
   }
-};
+}
 
-let FlowEffect$1 = class FlowEffect {
+class FlowEffect {
   /**
    * Creates a new FlowEffect.
    *
@@ -169,9 +169,9 @@ let FlowEffect$1 = class FlowEffect {
     this._dependencies.delete(dependency);
     dependency._unregisterEffect(this);
   }
-};
+}
 
-let FlowObservable$1 = class FlowObservable extends FlowSignal$1 {
+class FlowObservable extends FlowSignal {
   /* INTERNAL -------------------------------------------*/
   /*@internal*/
   _value;
@@ -187,14 +187,14 @@ let FlowObservable$1 = class FlowObservable extends FlowSignal$1 {
    * @returns A disposer function to cancel the subscription.
    */
   subscribe(listener) {
-    const effect = new FlowEffect$1((get) => {
+    const effect = new FlowEffect((get) => {
       listener(get(this));
     });
     return () => effect.dispose();
   }
-};
+}
 
-class FlowConstant extends FlowObservable$1 {
+class FlowConstant extends FlowObservable {
   /**
    * Creates a new FlowConstant instance.
    *
@@ -264,7 +264,7 @@ class FlowState extends FlowConstant {
   }
 }
 
-let FlowDerivation$1 = class FlowDerivation extends FlowObservable$1 {
+class FlowDerivation extends FlowObservable {
   /**
    * Creates a new FlowDerivation.
    * @param compute - A function that computes the derived value. It is provided with two parameters:
@@ -334,372 +334,90 @@ let FlowDerivation$1 = class FlowDerivation extends FlowObservable$1 {
     this._initLazy();
     this._compute();
   }
-};
+}
 
-class FlowSignal {
-  /**
-   * Triggers the FlowSignal.
-   * Notifies all registered listeners and schedules execution of associated effects.
-   * @throws If the FlowSignal has already been disposed.
-   * @public
-   */
-  trigger() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._notify();
-  }
-  /**
-   * Disposes the FlowSignal.
-   * Cleans up all registered effects, listeners, and dependencies.
-   * Once disposed, further usage of the signal will throw an error.
-   * @throws If the FlowSignal is already disposed.
-   * @public
-   */
-  dispose(options) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    if (options?.self) {
-      Array.from(this._effects).forEach(
-        (effect) => effect._unregisterDependency(this)
-      );
-      Array.from(this._listeners).forEach(
-        (listener) => listener._unregisterDependency(this)
-      );
-    } else {
-      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 FlowSignal has been disposed.
-   * @remarks Once disposed, the signal should not be used.
-   * @public
-   */
-  get disposed() {
-    return this._disposed;
-  }
-  /* INTERNAL ------------------------------------------------------------- */
-  /*@internal*/
-  _disposed = false;
-  /*@internal*/
-  _dependencies = /* @__PURE__ */ new Set();
-  /*@internal*/
-  _listeners = /* @__PURE__ */ new Set();
-  /*@internal*/
-  _effects = /* @__PURE__ */ new Set();
-  /*@internal*/
-  _watch() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-  }
-  /*@internal*/
-  _notify() {
-    this._listeners.forEach((listener) => listener._notify());
-    this._effects.forEach((effect) => effect._exec());
-  }
-  /*@internal*/
-  _watchFrom(listener) {
-    listener._registerDependency(this);
-    this._watch();
-  }
-  /*@internal*/
-  _registerDependency(dependency) {
-    this._dependencies.add(dependency);
-    dependency._registerListener(this);
-  }
-  /*@internal*/
-  _unregisterDependency(dependency) {
-    this._dependencies.delete(dependency);
-    dependency._unregisterListener(this);
-  }
-  /*@internal*/
-  _registerListener(signal) {
-    this._listeners.add(signal);
-  }
-  /*@internal*/
-  _unregisterListener(signal) {
-    this._listeners.delete(signal);
-  }
-  /*@internal*/
-  _registerEffect(effect) {
-    this._effects.add(effect);
-  }
-  /*@internal*/
-  _unregisterEffect(effect) {
-    this._effects.delete(effect);
-  }
+function isDisposable(obj) {
+  return obj !== null && obj !== void 0 && typeof obj.dispose === "function";
 }
 
-class FlowEffect {
+class FlowMap extends FlowState {
   /**
-   * Creates a new FlowEffect.
-   *
-   * @param apply - A side-effect function that receives a getter and a watcher to
-   * access and register dependencies on reactive observables and signals.
+   * A reactive state that holds the most recent key and value that were set.
    *
    * @remarks
-   * The provided function is executed immediately in a tracked mode to collect dependencies.
-   * On subsequent executions, it runs in an untracked mode.
+   * When a key is set via {@link FlowMap.setAt}, this state is updated with
+   * the corresponding key and value.
    *
    * @public
    */
-  constructor(apply) {
-    this._trackedExec = () => apply(this._trackedGet, this._trackedWatch);
-    this._untrackedExec = () => apply(this._untrackedGet, this._untrackedWatch);
-    this._exec();
-  }
+  $lastSet = new FlowState({});
   /**
-   * Disposes the effect, unregistering all its tracked dependencies.
+   * A reactive state that holds the most recent key and value that were deleted.
    *
    * @remarks
-   * Once disposed, the effect must no longer be used. Trying to dispose an effect
-   * that is already disposed will throw an error.
+   * When a key is deleted via {@link FlowMap.delete}, this state is updated with
+   * the corresponding key and its last known value.
    *
    * @public
    */
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Effect is disposed");
-    Array.from(this._dependencies).forEach((dependency) => {
-      this._unregisterDependency(dependency);
-    });
-    this._disposed = true;
-  }
+  $lastDeleted = new FlowState({});
   /**
-   * Indicates whether this effect has been disposed.
+   * Sets a value at the specified key in the underlying map.
    *
-   * @returns A boolean value that is true if the effect is disposed, false otherwise.
+   * @param key - The key at which to set the value.
+   * @param value - The value to set.
+   * @throws If the FlowMap instance is disposed.
+   *
+   * @remarks
+   * Updates the internal map, emits the key-value pair via {@link FlowMap.$lastSet},
+   * and notifies all subscribers of the change.
    *
    * @public
    */
-  get disposed() {
-    return this._disposed;
-  }
-  /* INTERNAL ------------------------------------------------------------ */
-  _disposed = false;
-  _initialized = false;
-  _dependencies = /* @__PURE__ */ new Set();
-  _trackedGet = (observable) => observable._getFrom(this);
-  _trackedWatch = (signal) => signal._watchFrom(this);
-  _untrackedGet = (observable) => observable.get();
-  _untrackedWatch = (signal) => signal._watch();
-  _trackedExec;
-  _untrackedExec;
-  /*@internal*/
-  _exec() {
-    if (this._disposed)
-      throw new Error("[PicoFlow] Effect is disposed");
-    if (this._initialized) this._untrackedExec();
-    else {
-      this._trackedExec();
-      this._initialized = true;
-    }
-  }
-  /*@internal*/
-  _registerDependency(dependency) {
-    this._dependencies.add(dependency);
-    dependency._registerEffect(this);
-  }
-  /*@internal*/
-  _unregisterDependency(dependency) {
-    this._dependencies.delete(dependency);
-    dependency._unregisterEffect(this);
-  }
-}
-
-class FlowObservable extends FlowSignal {
-  /* INTERNAL -------------------------------------------*/
-  /*@internal*/
-  _value;
-  /*@internal*/
-  _getFrom(listener) {
-    listener._registerDependency(this);
-    return this.get();
+  setAt(key, value) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._value.set(key, value);
+    this.$lastSet.set({ key, value });
+    this._notify();
   }
   /**
-   * Subscribes a listener function to changes of the observable.
-   * The listener is executed immediately with the current value and on subsequent updates.
-   * @param listener - A callback function that receives the new value.
-   * @returns A disposer function to cancel the subscription.
+   * Deletes the value at the specified key from the underlying map.
+   *
+   * @param key - The key to delete.
+   * @throws If the FlowMap instance is disposed.
+   *
+   * @remarks
+   * Removes the key from the internal map, emits the deleted key and its value via {@link FlowMap.$lastDeleted},
+   * and notifies all subscribers of the change.
+   *
+   * @public
    */
-  subscribe(listener) {
-    const effect = new FlowEffect((get) => {
-      listener(get(this));
-    });
-    return () => effect.dispose();
+  delete(key) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const value = this._value.get(key);
+    this._value.delete(key);
+    this.$lastDeleted.set({ key, value });
+    this._notify();
   }
 }
 
-class FlowDerivation extends FlowObservable {
+class FlowStream extends FlowObservable {
   /**
-   * Creates a new FlowDerivation.
-   * @param compute - A function that computes the derived value. It is provided with two parameters:
-   * a getter and a watcher that respect dependency tracking.
+   * 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.
    * @public
    */
-  constructor(compute) {
+  constructor(updater) {
     super();
-    this._initEager(compute);
+    this._disposer = updater((value) => {
+      this._set(value);
+    });
   }
   /**
-   * Gets the current derived value.
-   * @returns The current computed value.
-   * @remarks
-   * This method lazily initializes and updates the derivation if it is marked as dirty. It throws an error
-   * if the derivation has been disposed.
-   * @public
-   */
-  get() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._initLazy();
-    this._compute();
-    return this._value;
-  }
-  /* INTERNAL --------------------------------------------------------- */
-  _initialized = false;
-  _dirty = false;
-  _trackedGet = (observable) => observable._getFrom(this);
-  _trackedWatch = (signal) => signal._watchFrom(this);
-  _untrackedGet = (observable) => observable.get();
-  _untrackedWatch = (signal) => signal._watch();
-  _trackedCompute;
-  _untrackedCompute;
-  _initEager(compute) {
-    this._trackedCompute = () => compute(this._trackedGet, this._trackedWatch);
-    this._untrackedCompute = () => compute(this._untrackedGet, this._untrackedWatch);
-  }
-  _initLazy() {
-    if (!this._initialized) {
-      this._value = this._trackedCompute();
-      this._initialized = true;
-    }
-  }
-  /* @internal */
-  _compute() {
-    if (this._dirty) {
-      this._value = this._untrackedCompute();
-      this._dirty = false;
-    }
-  }
-  /* @internal */
-  _notify() {
-    this._dirty = true;
-    super._notify();
-  }
-  /* @internal */
-  _watch() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._initLazy();
-    this._compute();
-  }
-}
-
-class FlowDerivationAsync extends FlowDerivation {
-  /**
-   * Creates a new FlowDerivation.
-   * @param compute - A function that computes the derived value. It is provided with two parameters:
-   * a getter and a watcher that respect dependency tracking.
-   * @public
-   */
-  // biome-ignore lint/complexity/noUselessConstructor: <explanation>
-  constructor(compute) {
-    super(compute);
-  }
-  /**
-   * Retrieves the current resource value.
-   * @returns The current value, or undefined if the resource has not been fetched yet.
-   * @throws Error if the resource is disposed.
-   * @public
-   */
-  get() {
-    return super.get();
-  }
-}
-
-function isDisposable(obj) {
-  return obj !== null && obj !== void 0 && typeof obj.dispose === "function";
-}
-
-class FlowMap extends FlowState {
-  /**
-   * 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 = new FlowState({});
-  /**
-   * 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 = new FlowState({});
-  /**
-   * 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.
-   * @throws If the FlowMap instance is disposed.
-   *
-   * @remarks
-   * Updates the internal map, emits the key-value pair via {@link FlowMap.$lastSet},
-   * and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  setAt(key, value) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._value.set(key, value);
-    this.$lastSet.set({ key, value });
-    this._notify();
-  }
-  /**
-   * Deletes the value at the specified key from the underlying map.
-   *
-   * @param key - The key to delete.
-   * @throws If the FlowMap instance is disposed.
-   *
-   * @remarks
-   * Removes the key from the internal map, emits the deleted key and its value via {@link FlowMap.$lastDeleted},
-   * and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  delete(key) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const value = this._value.get(key);
-    this._value.delete(key);
-    this.$lastDeleted.set({ key, value });
-    this._notify();
-  }
-}
-
-class FlowStream extends FlowObservable$1 {
-  /**
-   * 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.
-   * @public
-   */
-  constructor(updater) {
-    super();
-    this._disposer = updater((value) => {
-      this._set(value);
-    });
-  }
-  /**
-   * Retrieves the current value of the stream.
-   * @returns The current value, or undefined if no value has been set yet.
-   * @throws Error if the stream is disposed.
+   * Retrieves the current value of the stream.
+   * @returns The current value, or undefined if no value has been set yet.
+   * @throws Error if the stream is disposed.
    * @public
    */
   get() {
@@ -727,7 +445,7 @@ class FlowStream extends FlowObservable$1 {
   }
 }
 
-class FlowStreamAsync extends FlowObservable$1 {
+class FlowStreamAsync extends FlowObservable {
   /**
    * Creates a new asynchronous FlowStream.
    * @param updater - A function that receives a setter to update the stream's value.
@@ -785,7 +503,7 @@ class FlowStreamAsync extends FlowObservable$1 {
   }
 }
 
-class FlowResource extends FlowObservable$1 {
+class FlowResource extends FlowObservable {
   /**
    * Creates a new FlowResource.
    * @param fetch - An asynchronous function that retrieves the resource's value.
@@ -826,7 +544,7 @@ class FlowResource extends FlowObservable$1 {
   _fetch;
 }
 
-class FlowResourceAsync extends FlowObservable$1 {
+class FlowResourceAsync extends FlowObservable {
   /**
    * Creates a new FlowResource.
    * @param fetch - An asynchronous function that retrieves the resource's value.
@@ -865,7 +583,7 @@ class FlowResourceAsync extends FlowObservable$1 {
   _fetch;
 }
 
-class FlowArray extends FlowObservable$1 {
+class FlowArray extends FlowObservable {
   /**
    * Last action performed on the FlowArray.
    * @public
@@ -1032,7 +750,7 @@ class FlowArray extends FlowObservable$1 {
 }
 
 function signal() {
-  return new FlowSignal$1();
+  return new FlowSignal();
 }
 function constant(value) {
   return new FlowConstant(value);
@@ -1053,10 +771,10 @@ function streamAsync(updater) {
   return new FlowStreamAsync(updater);
 }
 function derivation(fn) {
-  return new FlowDerivation$1(fn);
+  return new FlowDerivation(fn);
 }
 function effect(fn) {
-  return new FlowEffect$1(fn);
+  return new FlowEffect(fn);
 }
 function map(initial) {
   return new FlowMap(
@@ -1067,4 +785,838 @@ function array(initial) {
   return new FlowArray(initial);
 }
 
-export { FlowArray, FlowConstant, FlowDerivation$1 as FlowDerivation, FlowDerivationAsync, FlowEffect$1 as FlowEffect, FlowMap, FlowObservable$1 as FlowObservable, FlowResource, FlowResourceAsync, FlowSignal$1 as FlowSignal, FlowState, FlowStream, FlowStreamAsync, array, constant, derivation, effect, isDisposable, map, resource, resourceAsync, signal, state, stream, streamAsync };
+let FlowSignal$1 = class FlowSignal {
+  /**
+   * Triggers the FlowSignal.
+   * Notifies all registered listeners and schedules execution of associated effects.
+   * @throws If the FlowSignal has already been disposed.
+   * @public
+   */
+  trigger() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._notify();
+  }
+  /**
+   * Disposes the FlowSignal.
+   * Cleans up all registered effects, listeners, and dependencies.
+   * Once disposed, further usage of the signal will throw an error.
+   * @throws If the FlowSignal is already disposed.
+   * @public
+   */
+  dispose(options) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (options?.self) {
+      Array.from(this._effects).forEach(
+        (effect) => effect._unregisterDependency(this)
+      );
+      Array.from(this._listeners).forEach(
+        (listener) => listener._unregisterDependency(this)
+      );
+    } else {
+      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 FlowSignal has been disposed.
+   * @remarks Once disposed, the signal should not be used.
+   * @public
+   */
+  get disposed() {
+    return this._disposed;
+  }
+  /* INTERNAL ------------------------------------------------------------- */
+  /*@internal*/
+  _disposed = false;
+  /*@internal*/
+  _dependencies = /* @__PURE__ */ new Set();
+  /*@internal*/
+  _listeners = /* @__PURE__ */ new Set();
+  /*@internal*/
+  _effects = /* @__PURE__ */ new Set();
+  /*@internal*/
+  _watch() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+  }
+  /*@internal*/
+  _notify() {
+    this._listeners.forEach((listener) => listener._notify());
+    this._effects.forEach((effect) => effect._exec());
+  }
+  /*@internal*/
+  _watchFrom(listener) {
+    listener._registerDependency(this);
+    this._watch();
+  }
+  /*@internal*/
+  _registerDependency(dependency) {
+    this._dependencies.add(dependency);
+    dependency._registerListener(this);
+  }
+  /*@internal*/
+  _unregisterDependency(dependency) {
+    this._dependencies.delete(dependency);
+    dependency._unregisterListener(this);
+  }
+  /*@internal*/
+  _registerListener(signal) {
+    this._listeners.add(signal);
+  }
+  /*@internal*/
+  _unregisterListener(signal) {
+    this._listeners.delete(signal);
+  }
+  /*@internal*/
+  _registerEffect(effect) {
+    this._effects.add(effect);
+  }
+  /*@internal*/
+  _unregisterEffect(effect) {
+    this._effects.delete(effect);
+  }
+};
+
+let FlowEffect$1 = class FlowEffect {
+  /**
+   * Creates a new FlowEffect.
+   *
+   * @param apply - A side-effect function that receives a getter and a watcher to
+   * access and register dependencies on reactive observables and signals.
+   *
+   * @remarks
+   * The provided function is executed immediately in a tracked mode to collect dependencies.
+   * On subsequent executions, it runs in an untracked mode.
+   *
+   * @public
+   */
+  constructor(apply) {
+    this._trackedExec = () => apply(this._trackedGet, this._trackedWatch);
+    this._untrackedExec = () => apply(this._untrackedGet, this._untrackedWatch);
+    this._exec();
+  }
+  /**
+   * Disposes the effect, unregistering all its tracked dependencies.
+   *
+   * @remarks
+   * Once disposed, the effect must no longer be used. Trying to dispose an effect
+   * that is already disposed will throw an error.
+   *
+   * @public
+   */
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] 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 that is true if the effect is disposed, false otherwise.
+   *
+   * @public
+   */
+  get disposed() {
+    return this._disposed;
+  }
+  /* INTERNAL ------------------------------------------------------------ */
+  _disposed = false;
+  _initialized = false;
+  _dependencies = /* @__PURE__ */ new Set();
+  _trackedGet = (observable) => observable._getFrom(this);
+  _trackedWatch = (signal) => signal._watchFrom(this);
+  _untrackedGet = (observable) => observable.get();
+  _untrackedWatch = (signal) => signal._watch();
+  _trackedExec;
+  _untrackedExec;
+  /*@internal*/
+  _exec() {
+    if (this._disposed)
+      throw new Error("[PicoFlow] Effect is disposed");
+    if (this._initialized) this._untrackedExec();
+    else {
+      this._trackedExec();
+      this._initialized = true;
+    }
+  }
+  /*@internal*/
+  _registerDependency(dependency) {
+    this._dependencies.add(dependency);
+    dependency._registerEffect(this);
+  }
+  /*@internal*/
+  _unregisterDependency(dependency) {
+    this._dependencies.delete(dependency);
+    dependency._unregisterEffect(this);
+  }
+};
+
+let FlowObservable$1 = class FlowObservable extends FlowSignal$1 {
+  /* INTERNAL -------------------------------------------*/
+  /*@internal*/
+  _value;
+  /*@internal*/
+  _getFrom(listener) {
+    listener._registerDependency(this);
+    return this.get();
+  }
+  /**
+   * Subscribes a listener function to changes of the observable.
+   * The listener is executed immediately with the current value and on subsequent updates.
+   * @param listener - A callback function that receives the new value.
+   * @returns A disposer function to cancel the subscription.
+   */
+  subscribe(listener) {
+    const effect = new FlowEffect$1((get) => {
+      listener(get(this));
+    });
+    return () => effect.dispose();
+  }
+};
+
+let FlowDerivation$1 = class FlowDerivation extends FlowObservable$1 {
+  /**
+   * Creates a new FlowDerivation.
+   * @param compute - A function that computes the derived value. It is provided with two parameters:
+   * a getter and a watcher that respect dependency tracking.
+   * @public
+   */
+  constructor(compute) {
+    super();
+    this._initEager(compute);
+  }
+  /**
+   * Gets the current derived value.
+   * @returns The current computed value.
+   * @remarks
+   * This method lazily initializes and updates the derivation if it is marked as dirty. It throws an error
+   * if the derivation has been disposed.
+   * @public
+   */
+  get() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._initLazy();
+    this._compute();
+    return this._value;
+  }
+  /* INTERNAL --------------------------------------------------------- */
+  _initialized = false;
+  _dirty = false;
+  _trackedGet = (observable) => observable._getFrom(this);
+  _trackedWatch = (signal) => signal._watchFrom(this);
+  _untrackedGet = (observable) => observable.get();
+  _untrackedWatch = (signal) => signal._watch();
+  _trackedCompute;
+  _untrackedCompute;
+  _initEager(compute) {
+    this._trackedCompute = () => compute(this._trackedGet, this._trackedWatch);
+    this._untrackedCompute = () => compute(this._untrackedGet, this._untrackedWatch);
+  }
+  _initLazy() {
+    if (!this._initialized) {
+      this._value = this._trackedCompute();
+      this._initialized = true;
+    }
+  }
+  /* @internal */
+  _compute() {
+    if (this._dirty) {
+      const dependencies = [...this._dependencies];
+      this._dependencies.clear();
+      this._value = this._trackedCompute();
+      const dependenciesToRemove = dependencies.filter(
+        (dependency) => !this._dependencies.has(dependency)
+      );
+      dependenciesToRemove.forEach(
+        (dependency) => dependency._unregisterDependency(this)
+      );
+      this._dirty = false;
+    }
+  }
+  /* @internal */
+  _notify() {
+    this._dirty = true;
+    super._notify();
+  }
+  /* @internal */
+  _watch() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._initLazy();
+    this._compute();
+  }
+};
+
+const IS_DEV = false;
+const equalFn = (a, b) => a === b;
+const signalOptions = {
+  equals: equalFn
+};
+let runEffects = runQueue;
+const STALE = 1;
+const PENDING = 2;
+const UNOWNED = {
+  };
+const NO_INIT = {};
+var Owner = null;
+let Transition = null;
+let ExternalSourceConfig = null;
+let Listener = null;
+let Updates = null;
+let Effects = null;
+let ExecCount = 0;
+function createSignal(value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const s = {
+    value,
+    observers: null,
+    observerSlots: null,
+    comparator: options.equals || undefined
+  };
+  const setter = value => {
+    if (typeof value === "function") {
+      value = value(s.value);
+    }
+    return writeSignal(s, value);
+  };
+  return [readSignal.bind(s), setter];
+}
+function createComputed(fn, value, options) {
+  const c = createComputation(fn, value, true, STALE);
+  updateComputation(c);
+}
+function createEffect(fn, value, options) {
+  runEffects = runUserEffects;
+  const c = createComputation(fn, value, false, STALE);
+  c.user = true;
+  Effects ? Effects.push(c) : updateComputation(c);
+}
+function createMemo(fn, value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const c = createComputation(fn, value, true, 0);
+  c.observers = null;
+  c.observerSlots = null;
+  c.comparator = options.equals || undefined;
+  updateComputation(c);
+  return readSignal.bind(c);
+}
+function isPromise(v) {
+  return v && typeof v === "object" && "then" in v;
+}
+function createResource(pSource, pFetcher, pOptions) {
+  let source;
+  let fetcher;
+  let options;
+  {
+    source = true;
+    fetcher = pSource;
+    options = {};
+  }
+  let pr = null,
+    initP = NO_INIT,
+    scheduled = false,
+    resolved = "initialValue" in options,
+    dynamic = typeof source === "function" && createMemo(source);
+  const contexts = new Set(),
+    [value, setValue] = (options.storage || createSignal)(options.initialValue),
+    [error, setError] = createSignal(undefined),
+    [track, trigger] = createSignal(undefined, {
+      equals: false
+    }),
+    [state, setState] = createSignal(resolved ? "ready" : "unresolved");
+  function loadEnd(p, v, error, key) {
+    if (pr === p) {
+      pr = null;
+      key !== undefined && (resolved = true);
+      if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
+        value: v
+      }));
+      initP = NO_INIT;
+      completeLoad(v, error);
+    }
+    return v;
+  }
+  function completeLoad(v, err) {
+    runUpdates(() => {
+      if (err === undefined) setValue(() => v);
+      setState(err !== undefined ? "errored" : resolved ? "ready" : "unresolved");
+      setError(err);
+      for (const c of contexts.keys()) c.decrement();
+      contexts.clear();
+    }, false);
+  }
+  function read() {
+    const c = SuspenseContext,
+      v = value(),
+      err = error();
+    if (err !== undefined && !pr) throw err;
+    if (Listener && !Listener.user && c) {
+      createComputed(() => {
+        track();
+        if (pr) {
+          if (c.resolved && Transition) ;else if (!contexts.has(c)) {
+            c.increment();
+            contexts.add(c);
+          }
+        }
+      });
+    }
+    return v;
+  }
+  function load(refetching = true) {
+    if (refetching !== false && scheduled) return;
+    scheduled = false;
+    const lookup = dynamic ? dynamic() : source;
+    if (lookup == null || lookup === false) {
+      loadEnd(pr, untrack(value));
+      return;
+    }
+    let error;
+    const p = initP !== NO_INIT ? initP : untrack(() => {
+      try {
+        return fetcher(lookup, {
+          value: value(),
+          refetching
+        });
+      } catch (fetcherError) {
+        error = fetcherError;
+      }
+    });
+    if (error !== undefined) {
+      loadEnd(pr, undefined, castError(error), lookup);
+      return;
+    } else if (!isPromise(p)) {
+      loadEnd(pr, p, undefined, lookup);
+      return p;
+    }
+    pr = p;
+    if ("v" in p) {
+      if (p.s === 1) loadEnd(pr, p.v, undefined, lookup);else loadEnd(pr, undefined, castError(p.v), lookup);
+      return p;
+    }
+    scheduled = true;
+    queueMicrotask(() => scheduled = false);
+    runUpdates(() => {
+      setState(resolved ? "refreshing" : "pending");
+      trigger();
+    }, false);
+    return p.then(v => loadEnd(p, v, undefined, lookup), e => loadEnd(p, undefined, castError(e), lookup));
+  }
+  Object.defineProperties(read, {
+    state: {
+      get: () => state()
+    },
+    error: {
+      get: () => error()
+    },
+    loading: {
+      get() {
+        const s = state();
+        return s === "pending" || s === "refreshing";
+      }
+    },
+    latest: {
+      get() {
+        if (!resolved) return read();
+        const err = error();
+        if (err && !pr) throw err;
+        return value();
+      }
+    }
+  });
+  let owner = Owner;
+  if (dynamic) createComputed(() => (owner = Owner, load(false)));else load(false);
+  return [read, {
+    refetch: info => runWithOwner(owner, () => load(info)),
+    mutate: setValue
+  }];
+}
+function untrack(fn) {
+  if (Listener === null) return fn();
+  const listener = Listener;
+  Listener = null;
+  try {
+    if (ExternalSourceConfig) ;
+    return fn();
+  } finally {
+    Listener = listener;
+  }
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function onCleanup(fn) {
+  if (Owner === null) ;else if (Owner.cleanups === null) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+  return fn;
+}
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  const prevListener = Listener;
+  Owner = o;
+  Listener = null;
+  try {
+    return runUpdates(fn, true);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = prev;
+    Listener = prevListener;
+  }
+}
+const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
+let SuspenseContext;
+function readSignal() {
+  if (this.sources && (this.state)) {
+    if ((this.state) === STALE) updateComputation(this);else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      this.observerSlots.push(Listener.sources.length - 1);
+    }
+  }
+  return this.value;
+}
+function writeSignal(node, value, isComp) {
+  let current = node.value;
+  if (!node.comparator || !node.comparator(current, value)) {
+    node.value = value;
+    if (node.observers && node.observers.length) {
+      runUpdates(() => {
+        for (let i = 0; i < node.observers.length; i += 1) {
+          const o = node.observers[i];
+          const TransitionRunning = Transition && Transition.running;
+          if (TransitionRunning && Transition.disposed.has(o)) ;
+          if (TransitionRunning ? !o.tState : !o.state) {
+            if (o.pure) Updates.push(o);else Effects.push(o);
+            if (o.observers) markDownstream(o);
+          }
+          if (!TransitionRunning) o.state = STALE;
+        }
+        if (Updates.length > 10e5) {
+          Updates = [];
+          if (IS_DEV) ;
+          throw new Error();
+        }
+      }, false);
+    }
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn) return;
+  cleanNode(node);
+  const time = ExecCount;
+  runComputation(node, node.value, time);
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  const owner = Owner,
+    listener = Listener;
+  Listener = Owner = node;
+  try {
+    nextValue = node.fn(value);
+  } catch (err) {
+    if (node.pure) {
+      {
+        node.state = STALE;
+        node.owned && node.owned.forEach(cleanNode);
+        node.owned = null;
+      }
+    }
+    node.updatedAt = time + 1;
+    return handleError(err);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.updatedAt != null && "observers" in node) {
+      writeSignal(node, nextValue);
+    } else node.value = nextValue;
+    node.updatedAt = time;
+  }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+  const c = {
+    fn,
+    state: state,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    pure
+  };
+  if (Owner === null) ;else if (Owner !== UNOWNED) {
+    {
+      if (!Owner.owned) Owner.owned = [c];else Owner.owned.push(c);
+    }
+  }
+  return c;
+}
+function runTop(node) {
+  if ((node.state) === 0) return;
+  if ((node.state) === PENDING) return lookUpstream(node);
+  if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
+  const ancestors = [node];
+  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+    if (node.state) ancestors.push(node);
+  }
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    node = ancestors[i];
+    if ((node.state) === STALE) {
+      updateComputation(node);
+    } else if ((node.state) === PENDING) {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates) return fn();
+  let wait = false;
+  if (!init) Updates = [];
+  if (Effects) wait = true;else Effects = [];
+  ExecCount++;
+  try {
+    const res = fn();
+    completeUpdates(wait);
+    return res;
+  } catch (err) {
+    if (!wait) Effects = null;
+    Updates = null;
+    handleError(err);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    runQueue(Updates);
+    Updates = null;
+  }
+  if (wait) return;
+  const e = Effects;
+  Effects = null;
+  if (e.length) runUpdates(() => runEffects(e), false);
+}
+function runQueue(queue) {
+  for (let i = 0; i < queue.length; i++) runTop(queue[i]);
+}
+function runUserEffects(queue) {
+  let i,
+    userLength = 0;
+  for (i = 0; i < queue.length; i++) {
+    const e = queue[i];
+    if (!e.user) runTop(e);else queue[userLength++] = e;
+  }
+  for (i = 0; i < userLength; i++) runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+  node.state = 0;
+  for (let i = 0; i < node.sources.length; i += 1) {
+    const source = node.sources[i];
+    if (source.sources) {
+      const state = source.state;
+      if (state === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount)) runTop(source);
+      } else if (state === PENDING) lookUpstream(source, ignore);
+    }
+  }
+}
+function markDownstream(node) {
+  for (let i = 0; i < node.observers.length; i += 1) {
+    const o = node.observers[i];
+    if (!o.state) {
+      o.state = PENDING;
+      if (o.pure) Updates.push(o);else Effects.push(o);
+      o.observers && markDownstream(o);
+    }
+  }
+}
+function cleanNode(node) {
+  let i;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(),
+        index = node.sourceSlots.pop(),
+        obs = source.observers;
+      if (obs && obs.length) {
+        const n = obs.pop(),
+          s = source.observerSlots.pop();
+        if (index < obs.length) {
+          n.sourceSlots[s] = index;
+          obs[index] = n;
+          source.observerSlots[index] = s;
+        }
+      }
+    }
+  }
+  if (node.tOwned) {
+    for (i = node.tOwned.length - 1; i >= 0; i--) cleanNode(node.tOwned[i]);
+    delete node.tOwned;
+  }
+  if (node.owned) {
+    for (i = node.owned.length - 1; i >= 0; i--) cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i = node.cleanups.length - 1; i >= 0; i--) node.cleanups[i]();
+    node.cleanups = null;
+  }
+  node.state = 0;
+}
+function castError(err) {
+  if (err instanceof Error) return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function handleError(err, owner = Owner) {
+  const error = castError(err);
+  throw error;
+}
+
+class SolidState {
+  /**
+   * Returns the current value.
+   */
+  get;
+  /**
+   * Sets the value or updates it using a getter function.
+   */
+  set;
+  /**
+   * Creates a new SolidState with the given initial value.
+   * @param initialValue - The initial value.
+   */
+  constructor(initialValue) {
+    const [get, set] = createSignal(initialValue);
+    this.get = get;
+    this.set = set;
+  }
+}
+class SolidDerivation {
+  /**
+   * Returns the current derived value.
+   */
+  get;
+  /**
+   * Creates a new SolidDerivation from a getter function or value.
+   * @param calculator - The getter function or value.
+   */
+  constructor(calculator) {
+    const get = createMemo(calculator);
+    this.get = get;
+  }
+}
+class SolidResource {
+  /**
+   * Returns the current value (or undefined if not yet loaded).
+   */
+  get;
+  /**
+   * Returns the current resource state.
+   */
+  state;
+  /**
+   * Returns the latest successfully loaded value (or undefined).
+   */
+  latest;
+  /**
+   * Triggers a refetch of the resource.
+   */
+  refetch;
+  /**
+   * Creates a new SolidResource from a fetcher function.
+   * @param fetcher - The async fetcher function.
+   */
+  constructor(fetcher) {
+    const [get, set] = createResource(fetcher);
+    this.get = get;
+    this.state = () => get.state;
+    this.latest = () => get.latest;
+    this.refetch = () => set.refetch();
+  }
+}
+
+function fromSync(state) {
+  const solidState = new SolidState(state.get());
+  let fx;
+  onMount(() => {
+    fx = new FlowEffect$1((get) => {
+      const value = get(state);
+      solidState.set(() => value);
+    });
+  });
+  onCleanup(() => fx.dispose());
+  return solidState;
+}
+function fromAsync(derivation) {
+  const solidResource = new SolidResource(async () => {
+    const value = await derivation.get();
+    return value;
+  });
+  let fx;
+  onMount(() => {
+    fx = new FlowEffect$1(async (get) => {
+      await get(derivation);
+      solidResource.refetch();
+    });
+  });
+  onCleanup(() => fx.dispose());
+  return solidResource;
+}
+function shallowFrom(flow) {
+  const initialValue = flow.get();
+  const isAsync = initialValue instanceof Promise;
+  if (isAsync) {
+    return fromAsync(flow);
+  }
+  return fromSync(flow);
+}
+function deepFrom(getter) {
+  const derivation = new FlowDerivation$1((get) => {
+    return getter(get);
+  });
+  const initialValue = derivation.get();
+  const isAsync = initialValue instanceof Promise;
+  if (isAsync) {
+    return fromAsync(derivation);
+  }
+  return fromSync(derivation);
+}
+function from(flow) {
+  if (flow instanceof FlowObservable$1) {
+    return shallowFrom(flow);
+  }
+  return deepFrom(flow);
+}
+
+export { FlowArray, FlowConstant, FlowDerivation, FlowEffect, FlowMap, FlowObservable, FlowResource, FlowResourceAsync, FlowSignal, FlowState, FlowStream, FlowStreamAsync, SolidDerivation, SolidResource, SolidState, array, constant, derivation, effect, from, isDisposable, map, resource, resourceAsync, signal, state, stream, streamAsync };