@ersbeth/picoflow 0.2.1 → 0.2.2

package/api/doc/picoflow.flowderivationasync._constructor_.md

@@ -0,0 +1,49 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@ersbeth/picoflow](./picoflow.md) &gt; [FlowDerivationAsync](./picoflow.flowderivationasync.md) &gt; [(constructor)](./picoflow.flowderivationasync._constructor_.md)
+
+## FlowDerivationAsync.(constructor)
+
+Creates a new FlowDerivation.
+
+**Signature:**
+
+```typescript
+constructor(compute: (get: FlowGetter, watch: FlowWatcher) => Promise<T>);
+```
+
+## Parameters
+
+<table><thead><tr><th>
+
+Parameter
+
+
+</th><th>
+
+Type
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+compute
+
+
+</td><td>
+
+(get: [FlowGetter](./picoflow.flowgetter.md)<!-- -->, watch: [FlowWatcher](./picoflow.flowwatcher.md)<!-- -->) =&gt; Promise&lt;T&gt;
+
+
+</td><td>
+
+A function that computes the derived value. It is provided with two parameters: a getter and a watcher that respect dependency tracking.
+
+
+</td></tr>
+</tbody></table>

package/api/doc/picoflow.flowderivationasync.get.md

@@ -0,0 +1,23 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@ersbeth/picoflow](./picoflow.md) &gt; [FlowDerivationAsync](./picoflow.flowderivationasync.md) &gt; [get](./picoflow.flowderivationasync.get.md)
+
+## FlowDerivationAsync.get() method
+
+Retrieves the current resource value.
+
+**Signature:**
+
+```typescript
+get(): Promise<T>;
+```
+**Returns:**
+
+Promise&lt;T&gt;
+
+The current value, or undefined if the resource has not been fetched yet.
+
+## Exceptions
+
+Error if the resource is disposed.
+

package/api/doc/picoflow.flowderivationasync.md

@@ -0,0 +1,86 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@ersbeth/picoflow](./picoflow.md) &gt; [FlowDerivationAsync](./picoflow.flowderivationasync.md)
+
+## FlowDerivationAsync class
+
+Represents a reactive resource that asynchronously fetches its value.
+
+**Signature:**
+
+```typescript
+export declare class FlowDerivationAsync<T> extends FlowDerivation<Promise<T>> 
+```
+**Extends:** [FlowDerivation](./picoflow.flowderivation.md)<!-- -->&lt;Promise&lt;T&gt;&gt;
+
+## Remarks
+
+A FlowResource extends FlowObservable and encapsulates an asynchronous fetch function. It is used to retrieve and update its value asynchronously. When the fetch is executed, if the new value differs from the current value, the resource is updated and its subscribers are notified.
+
+## Constructors
+
+<table><thead><tr><th>
+
+Constructor
+
+
+</th><th>
+
+Modifiers
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+[(constructor)(compute)](./picoflow.flowderivationasync._constructor_.md)
+
+
+</td><td>
+
+
+</td><td>
+
+Creates a new FlowDerivation.
+
+
+</td></tr>
+</tbody></table>
+
+## Methods
+
+<table><thead><tr><th>
+
+Method
+
+
+</th><th>
+
+Modifiers
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+[get()](./picoflow.flowderivationasync.get.md)
+
+
+</td><td>
+
+
+</td><td>
+
+Retrieves the current resource value.
+
+
+</td></tr>
+</tbody></table>

package/api/doc/picoflow.md

@@ -51,6 +51,17 @@ Represents a reactive and immutable constant value computed lazily upon first ac
 Represents a reactive derivation whose value is computed based on other reactive signals.
 
 
+</td></tr>
+<tr><td>
+
+[FlowDerivationAsync](./picoflow.flowderivationasync.md)
+
+
+</td><td>
+
+Represents a reactive resource that asynchronously fetches its value.
+
+
 </td></tr>
 <tr><td>
 

package/api/picoflow.public.api.md

@@ -74,6 +74,12 @@ export class FlowDerivation<T> extends FlowObservable<T> {
     get(): T;
 }
 
+// @public
+export class FlowDerivationAsync<T> extends FlowDerivation<Promise<T>> {
+    constructor(compute: (get: FlowGetter, watch: FlowWatcher) => Promise<T>);
+    get(): Promise<T>;
+}
+
 // @public
 export interface FlowDisposable {
     dispose(options?: {

package/dist/picoflow.js

@@ -1,4 +1,4 @@
-class FlowSignal {
+let FlowSignal$1 = class FlowSignal {
   /**
    * Triggers the FlowSignal.
    * Notifies all registered listeners and schedules execution of associated effects.
@@ -93,9 +93,9 @@ class FlowSignal {
   _unregisterEffect(effect) {
     this._effects.delete(effect);
   }
-}
+};
 
-class FlowEffect {
+let FlowEffect$1 = class FlowEffect {
   /**
    * Creates a new FlowEffect.
    *
@@ -169,9 +169,9 @@ class FlowEffect {
     this._dependencies.delete(dependency);
     dependency._unregisterEffect(this);
   }
-}
+};
 
-class FlowObservable extends FlowSignal {
+let FlowObservable$1 = class FlowObservable extends FlowSignal$1 {
   /* INTERNAL -------------------------------------------*/
   /*@internal*/
   _value;
@@ -187,14 +187,14 @@ class FlowObservable extends FlowSignal {
    * @returns A disposer function to cancel the subscription.
    */
   subscribe(listener) {
-    const effect = new FlowEffect((get) => {
+    const effect = new FlowEffect$1((get) => {
       listener(get(this));
     });
     return () => effect.dispose();
   }
-}
+};
 
-class FlowConstant extends FlowObservable {
+class FlowConstant extends FlowObservable$1 {
   /**
    * Creates a new FlowConstant instance.
    *
@@ -264,6 +264,274 @@ class FlowState extends FlowConstant {
   }
 }
 
+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();
+  }
+};
+
+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);
+  }
+}
+
+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);
+  }
+}
+
+class FlowObservable extends FlowSignal {
+  /* 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((get) => {
+      listener(get(this));
+    });
+    return () => effect.dispose();
+  }
+}
+
 class FlowDerivation extends FlowObservable {
   /**
    * Creates a new FlowDerivation.
@@ -328,6 +596,28 @@ class FlowDerivation extends FlowObservable {
   }
 }
 
+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";
 }
@@ -393,7 +683,7 @@ class FlowMap extends FlowState {
   }
 }
 
-class FlowStream extends FlowObservable {
+class FlowStream extends FlowObservable$1 {
   /**
    * Creates a new FlowStream.
    * @param updater - A function that receives a setter to update the stream's value.
@@ -437,7 +727,7 @@ class FlowStream extends FlowObservable {
   }
 }
 
-class FlowStreamAsync extends FlowObservable {
+class FlowStreamAsync extends FlowObservable$1 {
   /**
    * Creates a new asynchronous FlowStream.
    * @param updater - A function that receives a setter to update the stream's value.
@@ -495,7 +785,7 @@ class FlowStreamAsync extends FlowObservable {
   }
 }
 
-class FlowResource extends FlowObservable {
+class FlowResource extends FlowObservable$1 {
   /**
    * Creates a new FlowResource.
    * @param fetch - An asynchronous function that retrieves the resource's value.
@@ -536,7 +826,7 @@ class FlowResource extends FlowObservable {
   _fetch;
 }
 
-class FlowResourceAsync extends FlowObservable {
+class FlowResourceAsync extends FlowObservable$1 {
   /**
    * Creates a new FlowResource.
    * @param fetch - An asynchronous function that retrieves the resource's value.
@@ -575,7 +865,7 @@ class FlowResourceAsync extends FlowObservable {
   _fetch;
 }
 
-class FlowArray extends FlowObservable {
+class FlowArray extends FlowObservable$1 {
   /**
    * Last action performed on the FlowArray.
    * @public
@@ -742,7 +1032,7 @@ class FlowArray extends FlowObservable {
 }
 
 function signal() {
-  return new FlowSignal();
+  return new FlowSignal$1();
 }
 function constant(value) {
   return new FlowConstant(value);
@@ -763,10 +1053,10 @@ function streamAsync(updater) {
   return new FlowStreamAsync(updater);
 }
 function derivation(fn) {
-  return new FlowDerivation(fn);
+  return new FlowDerivation$1(fn);
 }
 function effect(fn) {
-  return new FlowEffect(fn);
+  return new FlowEffect$1(fn);
 }
 function map(initial) {
   return new FlowMap(
@@ -777,4 +1067,4 @@ function array(initial) {
   return new FlowArray(initial);
 }
 
-export { FlowArray, FlowConstant, FlowDerivation, FlowEffect, FlowMap, FlowObservable, FlowResource, FlowResourceAsync, FlowSignal, FlowState, FlowStream, FlowStreamAsync, array, constant, derivation, effect, isDisposable, map, resource, resourceAsync, signal, state, stream, streamAsync };
+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 };

package/dist/types/basic/derivation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../../src/basic/derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;GAQG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACpD;;;;;OAKG;gBACS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC;IAK/D;;;;;;;OAOG;IACI,GAAG,IAAI,CAAC;IASf,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,WAAW,CAAyD;IAC5E,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,aAAa,CAAgD;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAW;IAEpC,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;CAyBpB"}
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../../src/basic/derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;GAQG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACpD;;;;;OAKG;gBACS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC;IAK/D;;;;;;;OAOG;IACI,GAAG,IAAI,CAAC;IASf,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,WAAW,CAAyD;IAC5E,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,aAAa,CAAgD;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAW;IAEpC,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;CA0CpB"}

package/dist/types/basic/derivationAsync.d.ts

@@ -0,0 +1,31 @@
+import { FlowDerivation, FlowGetter, FlowWatcher } from '@ersbeth/picoflow';
+/**
+ * Represents a reactive resource that asynchronously fetches its value.
+ *
+ * @remarks
+ * A FlowResource extends FlowObservable and encapsulates an asynchronous fetch function.
+ * It is used to retrieve and update its value asynchronously. When the fetch is executed,
+ * if the new value differs from the current value, the resource is updated and its subscribers
+ * are notified.
+ *
+ * @typeparam T - The type of the resource value.
+ *
+ * @public
+ */
+export declare class FlowDerivationAsync<T> extends FlowDerivation<Promise<T>> {
+    /**
+     * 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: (get: FlowGetter, watch: FlowWatcher) => Promise<T>);
+    /**
+     * 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(): Promise<T>;
+}
+//# sourceMappingURL=derivationAsync.d.ts.map

package/dist/types/basic/derivationAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivationAsync.d.ts","sourceRoot":"","sources":["../../../src/basic/derivationAsync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEtF;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAClE;;;;;OAKG;gBAGS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAIxE;;;;;OAKG;IACa,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;CAGpC"}

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

@@ -2,6 +2,7 @@ export { FlowSignal } from './signal';
 export { FlowState } from './state';
 export { FlowObservable } from './observable';
 export { FlowDerivation } from './derivation';
+export { FlowDerivationAsync } from './derivationAsync';
 export { FlowEffect } from './effect';
 export { FlowConstant } from './constant';
 export { isDisposable } from './disposable';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/basic/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/basic/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/types/index.d.ts

@@ -8,7 +8,7 @@
  */
 export { signal, state, constant, resource, stream, derivation, effect, map, array, streamAsync, resourceAsync, } from './creators';
 export { isDisposable } from './basic';
-export { FlowDerivation, FlowEffect, FlowObservable, FlowSignal, FlowState, FlowConstant, } from './basic/';
+export { FlowDerivation, FlowDerivationAsync, FlowEffect, FlowObservable, FlowSignal, FlowState, FlowConstant, } from './basic/';
 export type { FlowGetter, FlowWatcher, FlowDisposable, } from './basic/';
 export { FlowResource, FlowMap, FlowResourceAsync, FlowStreamAsync, FlowStream, FlowArray, } from './advanced/';
 export type { FlowStreamDisposer, FlowStreamSetter, FlowStreamUpdater, FlowArrayAction, } from './advanced/';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACH,MAAM,EACN,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,UAAU,EACV,MAAM,EACN,GAAG,EACH,KAAK,EACL,WAAW,EACX,aAAa,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EACH,cAAc,EACd,UAAU,EACV,cAAc,EACd,UAAU,EACV,SAAS,EACT,YAAY,GACf,MAAM,UAAU,CAAC;AAElB,YAAY,EACR,UAAU,EACV,WAAW,EACX,cAAc,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EACH,YAAY,EACZ,OAAO,EACP,iBAAiB,EACjB,eAAe,EACf,UAAU,EACV,SAAS,GACZ,MAAM,aAAa,CAAC;AACrB,YAAY,EACR,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,GAClB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACH,MAAM,EACN,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,UAAU,EACV,MAAM,EACN,GAAG,EACH,KAAK,EACL,WAAW,EACX,aAAa,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EACH,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,cAAc,EACd,UAAU,EACV,SAAS,EACT,YAAY,GACf,MAAM,UAAU,CAAC;AAElB,YAAY,EACR,UAAU,EACV,WAAW,EACX,cAAc,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EACH,YAAY,EACZ,OAAO,EACP,iBAAiB,EACjB,eAAe,EACf,UAAU,EACV,SAAS,GACZ,MAAM,aAAa,CAAC;AACrB,YAAY,EACR,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,GAClB,MAAM,aAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ersbeth/picoflow",
-    "version": "0.2.1",
+    "version": "0.2.2",
     "description": "Minimal Dataflow librairy for TypeScript",
     "type": "module",
     "exports": {

package/src/basic/derivation.ts

@@ -67,7 +67,24 @@ export class FlowDerivation<T> extends FlowObservable<T> {
 
     /* @internal */ _compute(): void {
         if (this._dirty) {
-            this._value = this._untrackedCompute();
+            // we cant use untrackedCompute because it will not track dependencies
+            // that changed dynamically
+
+            // store current dependencies
+            const dependencies = [...this._dependencies];
+
+            // clear current dependencies, compute and retrack dependencies
+            this._dependencies.clear();
+            this._value = this._trackedCompute();
+
+            // unsubscribe from dependencies that are no longer needed
+            const dependenciesToRemove = dependencies.filter(
+                (dependency) => !this._dependencies.has(dependency),
+            );
+            dependenciesToRemove.forEach((dependency) =>
+                dependency._unregisterDependency(this),
+            );
+
             this._dirty = false;
         }
     }

package/src/basic/derivationAsync.ts

@@ -0,0 +1,38 @@
+import { FlowDerivation, type FlowGetter, type FlowWatcher } from '@ersbeth/picoflow';
+
+/**
+ * Represents a reactive resource that asynchronously fetches its value.
+ *
+ * @remarks
+ * A FlowResource extends FlowObservable and encapsulates an asynchronous fetch function.
+ * It is used to retrieve and update its value asynchronously. When the fetch is executed,
+ * if the new value differs from the current value, the resource is updated and its subscribers
+ * are notified.
+ *
+ * @typeparam T - The type of the resource value.
+ *
+ * @public
+ */
+export class FlowDerivationAsync<T> extends FlowDerivation<Promise<T>> {
+    /**
+     * 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: (get: FlowGetter, watch: FlowWatcher) => Promise<T>) {
+        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
+     */
+    public override get(): Promise<T> {
+        return super.get();
+    }
+}

package/src/basic/index.ts

@@ -2,6 +2,7 @@ export { FlowSignal } from "./signal";
 export { FlowState } from "./state";
 export { FlowObservable } from "./observable";
 export { FlowDerivation } from "./derivation";
+export { FlowDerivationAsync } from "./derivationAsync";
 export { FlowEffect } from "./effect";
 export { FlowConstant } from "./constant";
 export { isDisposable } from "./disposable";

package/src/index.ts

@@ -22,6 +22,7 @@ export {
 export { isDisposable } from "./basic";
 export {
     FlowDerivation,
+    FlowDerivationAsync,
     FlowEffect,
     FlowObservable,
     FlowSignal,

package/test/derivation.test.ts

@@ -443,4 +443,102 @@ describe("effect", () => {
             expect(effectFn).toHaveBeenLastCalledWith(4);
         });
     });
+
+    describe("complex test", () => {
+        test("test", () => {
+            const obj1 = {
+                cond: state(false),
+                num: state(2),
+                dispose: (options: { self: boolean }) => {
+                    obj1.cond.dispose(options);
+                    obj1.num.dispose(options);
+                }
+            }
+            const obj2 = {
+                cond: state(false),
+                num: state(4),
+                dispose: (options: { self: boolean }) => {
+                    obj2.cond.dispose(options);
+                    obj2.num.dispose(options);
+                }
+            }
+            const $state = state(obj1);
+            const $derivationCond = derivation((get) => get(get($state).cond));
+            const $derivationNum = derivation((get) => get(get($state).num) * 2);
+            const effectCondFn = vi.fn();
+            const effectNumFn = vi.fn();
+            effect((get) => effectCondFn(get($derivationCond)));
+            effect((get) => effectNumFn(get($derivationNum)));
+
+            expect(effectCondFn).toHaveBeenCalledTimes(1);
+            expect(effectCondFn).toHaveBeenLastCalledWith(false);
+            expect(effectNumFn).toHaveBeenCalledTimes(1);
+            expect(effectNumFn).toHaveBeenLastCalledWith(4);
+
+            $state.get().num.set(3);
+            expect(effectCondFn).toHaveBeenCalledTimes(1);
+            expect(effectCondFn).toHaveBeenLastCalledWith(false);
+            expect(effectNumFn).toHaveBeenCalledTimes(2);
+            expect(effectNumFn).toHaveBeenLastCalledWith(6);
+
+            $state.get().cond.set(true);
+            expect(effectCondFn).toHaveBeenCalledTimes(2);
+            expect(effectCondFn).toHaveBeenLastCalledWith(true);
+            expect(effectNumFn).toHaveBeenCalledTimes(2);
+            expect(effectNumFn).toHaveBeenLastCalledWith(6);
+
+            $state.set(obj2)
+            expect(effectCondFn).toHaveBeenCalledTimes(3);
+            expect(effectCondFn).toHaveBeenLastCalledWith(false);
+            expect(effectNumFn).toHaveBeenCalledTimes(3);
+            expect(effectNumFn).toHaveBeenLastCalledWith(8);
+
+            $state.get().cond.set(true);
+            expect(effectCondFn).toHaveBeenCalledTimes(4); // fails -> called 3 times
+            expect(effectCondFn).toHaveBeenLastCalledWith(true);
+            expect(effectNumFn).toHaveBeenCalledTimes(3);
+            expect(effectNumFn).toHaveBeenLastCalledWith(8);
+
+            $state.get().num.set(5);
+            expect(effectCondFn).toHaveBeenCalledTimes(4);
+            expect(effectCondFn).toHaveBeenLastCalledWith(true);
+            expect(effectNumFn).toHaveBeenCalledTimes(4);
+            expect(effectNumFn).toHaveBeenLastCalledWith(10);
+        });
+
+        test("test", () => {
+            const obj = {
+                cond: state(false),
+                b: state(2)
+            }
+
+            const $state = state(obj);
+            const $derivation = derivation((get) => {
+                const cond = get(get($state).cond);
+                if (cond) {
+                    return get(get($state).b) * 2;
+                }
+                return 0;
+            });
+
+
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(0);
+
+            $state.get().cond.set(true);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+
+            $state.set({ cond: state(false), b: state(3) })
+            expect(effectFn).toHaveBeenCalledTimes(3);
+            expect(effectFn).toHaveBeenLastCalledWith(0);
+
+            $state.get().cond.set(true);
+            expect(effectFn).toHaveBeenCalledTimes(4);
+            expect(effectFn).toHaveBeenLastCalledWith(6);
+        });
+    });
 });