@ersbeth/picoflow 2.0.0 → 2.0.1

package/dist/picoflow.js

@@ -4,192 +4,6 @@ function isDisposable(obj) {
   return obj !== null && obj !== void 0 && typeof obj.dispose === "function";
 }
 
-class ExecutionStack {
-  static _pendingQueue = [];
-  static _effectQueue = [];
-  static _executionScheduled;
-  static pushPending(node) {
-    ExecutionStack._scheduleExecution();
-    ExecutionStack._pendingQueue.push(node);
-  }
-  static pushEffect(effect) {
-    ExecutionStack._scheduleExecution();
-    ExecutionStack._effectQueue.push(effect);
-  }
-  static _scheduleExecution() {
-    if (ExecutionStack._executionScheduled) return;
-    ExecutionStack._executionScheduled = new Promise((resolve) => {
-      setTimeout(() => {
-        ExecutionStack._executionScheduled = void 0;
-        ExecutionStack._execute();
-        resolve();
-      }, 0);
-    });
-  }
-  static _execute() {
-    ExecutionStack._pendingQueue.forEach((node) => {
-      node.execute();
-    });
-    ExecutionStack._pendingQueue.length = 0;
-    ExecutionStack._effectQueue.forEach((effect) => {
-      effect.execute();
-    });
-    ExecutionStack._effectQueue.length = 0;
-  }
-}
-
-class Disposable {
-  _disposed = false;
-  get disposed() {
-    return this._disposed;
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._disposed = true;
-  }
-}
-
-class Node extends Disposable {
-  _dependencies = /* @__PURE__ */ new Set();
-  _dependents = /* @__PURE__ */ new Set();
-  _status = "resolved";
-  get status() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    return this._status;
-  }
-  set status(status) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._status = status;
-  }
-  registerDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.add(dependency);
-    dependency.registerDependent(this);
-  }
-  unregisterDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.delete(dependency);
-    dependency.unregisterDependent(this);
-  }
-  clearDependencies() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.forEach((dependency) => {
-      dependency.unregisterDependent(this);
-    });
-    this._dependencies.clear();
-  }
-  registerDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.add(dependent);
-  }
-  unregisterDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.delete(dependent);
-  }
-  notifyDependents() {
-    if (this.disposed) return;
-    this._dependents.forEach((dependent) => {
-      dependent.notify();
-    });
-  }
-  watch(tracker) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    tracker.registerDependency(this);
-  }
-  trigger() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this.notifyDependents();
-  }
-  notify() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    if (this.status === "dirty") return;
-    this.status = "dirty";
-    this.notifyDependents();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    Array.from(this._dependents).forEach((dependant) => {
-      dependant.unregisterDependency(this);
-      this.unregisterDependent(dependant);
-    });
-    Array.from(this._dependencies).forEach((dependency) => {
-      this.unregisterDependency(dependency);
-    });
-    this._disposed = true;
-  }
-}
-
-class Observable extends Disposable {
-  _dependents = /* @__PURE__ */ new Set();
-  _status = "resolved";
-  get status() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    return this._status;
-  }
-  set status(status) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._status = status;
-  }
-  registerDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.add(dependent);
-  }
-  unregisterDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.delete(dependent);
-  }
-  notifyDependents() {
-    if (this.disposed) return;
-    this._dependents.forEach((dependent) => {
-      dependent.notify();
-    });
-  }
-  watch(tracker) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    tracker.registerDependency(this);
-  }
-  trigger() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this.notifyDependents();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    Array.from(this._dependents).forEach((dependant) => {
-      dependant.unregisterDependency(this);
-      this.unregisterDependent(dependant);
-    });
-    this._disposed = true;
-  }
-}
-
-class Observer extends Disposable {
-  _dependencies = /* @__PURE__ */ new Set();
-  registerDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.add(dependency);
-    dependency.registerDependent(this);
-  }
-  unregisterDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.delete(dependency);
-    dependency.unregisterDependent(this);
-  }
-  clearDependencies() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.forEach((dependency) => {
-      dependency.unregisterDependent(this);
-    });
-    this._dependencies.clear();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    Array.from(this._dependencies).forEach((dependency) => {
-      this.unregisterDependency(dependency);
-    });
-    this._disposed = true;
-  }
-}
-
 class PendingError extends Error {
   pendingPromise;
   constructor(promise) {
@@ -348,52 +162,238 @@ class SyncResolver {
       this._onValue(value);
     }
   }
-  abort() {
-    this._iteration++;
-    this._aborted = true;
+  abort() {
+    this._iteration++;
+    this._aborted = true;
+  }
+}
+
+class SyncScheduler {
+  _compute;
+  _resolver;
+  _onResolve;
+  _onReject;
+  _settled = Promise.withResolvers();
+  _disposed = false;
+  constructor(compute, onResolve, onReject) {
+    this._compute = compute;
+    this._onResolve = (value) => {
+      onResolve(value);
+      this._settled.resolve();
+    };
+    this._onReject = (error) => {
+      onReject(error);
+      this._settled.resolve();
+    };
+    this._resolver = new SyncResolver(compute, this._onResolve, this._onReject);
+  }
+  get settled() {
+    return this._settled.promise;
+  }
+  overwrite(value) {
+    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
+    if (this._resolver.finished) {
+      this._settled = Promise.withResolvers();
+      this._resolver = new SyncResolver(this._compute, this._onResolve, this._onReject);
+    }
+    this._resolver.overwrite(value);
+  }
+  compute() {
+    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
+    if (this._resolver.finished) {
+      this._settled = Promise.withResolvers();
+      this._resolver = new SyncResolver(this._compute, this._onResolve, this._onReject);
+    }
+    this._resolver.compute();
+  }
+  dispose() {
+    this._resolver.abort();
+    this._disposed = true;
+  }
+}
+
+class Disposable {
+  _disposed = false;
+  get disposed() {
+    return this._disposed;
+  }
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._disposed = true;
+  }
+}
+
+class ExecutionStack {
+  static _pendingQueue = [];
+  static _effectQueue = [];
+  static _executionScheduled;
+  static pushPending(node) {
+    ExecutionStack._scheduleExecution();
+    ExecutionStack._pendingQueue.push(node);
+  }
+  static pushEffect(effect) {
+    ExecutionStack._scheduleExecution();
+    ExecutionStack._effectQueue.push(effect);
+  }
+  static _scheduleExecution() {
+    if (ExecutionStack._executionScheduled) return;
+    ExecutionStack._executionScheduled = new Promise((resolve) => {
+      setTimeout(() => {
+        ExecutionStack._executionScheduled = void 0;
+        ExecutionStack._execute();
+        resolve();
+      }, 0);
+    });
+  }
+  static _execute() {
+    ExecutionStack._pendingQueue.forEach((node) => {
+      node.execute();
+    });
+    ExecutionStack._pendingQueue.length = 0;
+    ExecutionStack._effectQueue.forEach((effect) => {
+      effect.execute();
+    });
+    ExecutionStack._effectQueue.length = 0;
+  }
+}
+
+class Node extends Disposable {
+  _dependencies = /* @__PURE__ */ new Set();
+  _dependents = /* @__PURE__ */ new Set();
+  _status = "resolved";
+  get status() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    return this._status;
+  }
+  set status(status) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._status = status;
+  }
+  registerDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.add(dependency);
+    dependency.registerDependent(this);
+  }
+  unregisterDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.delete(dependency);
+    dependency.unregisterDependent(this);
+  }
+  clearDependencies() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.forEach((dependency) => {
+      dependency.unregisterDependent(this);
+    });
+    this._dependencies.clear();
+  }
+  registerDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.add(dependent);
+  }
+  unregisterDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.delete(dependent);
+  }
+  notifyDependents() {
+    if (this.disposed) return;
+    this._dependents.forEach((dependent) => {
+      dependent.notify();
+    });
+  }
+  watch(tracker) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    tracker.registerDependency(this);
+  }
+  trigger() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this.notifyDependents();
+  }
+  notify() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (this.status === "dirty") return;
+    this.status = "dirty";
+    this.notifyDependents();
+  }
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependents).forEach((dependant) => {
+      dependant.unregisterDependency(this);
+      this.unregisterDependent(dependant);
+    });
+    Array.from(this._dependencies).forEach((dependency) => {
+      this.unregisterDependency(dependency);
+    });
+    this._disposed = true;
+  }
+}
+
+class Observable extends Disposable {
+  _dependents = /* @__PURE__ */ new Set();
+  _status = "resolved";
+  get status() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    return this._status;
+  }
+  set status(status) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._status = status;
+  }
+  registerDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.add(dependent);
+  }
+  unregisterDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.delete(dependent);
+  }
+  notifyDependents() {
+    if (this.disposed) return;
+    this._dependents.forEach((dependent) => {
+      dependent.notify();
+    });
+  }
+  watch(tracker) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    tracker.registerDependency(this);
+  }
+  trigger() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this.notifyDependents();
+  }
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependents).forEach((dependant) => {
+      dependant.unregisterDependency(this);
+      this.unregisterDependent(dependant);
+    });
+    this._disposed = true;
   }
 }
 
-class SyncScheduler {
-  _compute;
-  _resolver;
-  _onResolve;
-  _onReject;
-  _settled = Promise.withResolvers();
-  _disposed = false;
-  constructor(compute, onResolve, onReject) {
-    this._compute = compute;
-    this._onResolve = (value) => {
-      onResolve(value);
-      this._settled.resolve();
-    };
-    this._onReject = (error) => {
-      onReject(error);
-      this._settled.resolve();
-    };
-    this._resolver = new SyncResolver(compute, this._onResolve, this._onReject);
-  }
-  get settled() {
-    return this._settled.promise;
+class Observer extends Disposable {
+  _dependencies = /* @__PURE__ */ new Set();
+  registerDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.add(dependency);
+    dependency.registerDependent(this);
   }
-  overwrite(value) {
-    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
-    if (this._resolver.finished) {
-      this._settled = Promise.withResolvers();
-      this._resolver = new SyncResolver(this._compute, this._onResolve, this._onReject);
-    }
-    this._resolver.overwrite(value);
+  unregisterDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.delete(dependency);
+    dependency.unregisterDependent(this);
   }
-  compute() {
-    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
-    if (this._resolver.finished) {
-      this._settled = Promise.withResolvers();
-      this._resolver = new SyncResolver(this._compute, this._onResolve, this._onReject);
-    }
-    this._resolver.compute();
+  clearDependencies() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.forEach((dependency) => {
+      dependency.unregisterDependent(this);
+    });
+    this._dependencies.clear();
   }
   dispose() {
-    this._resolver.abort();
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependencies).forEach((dependency) => {
+      this.unregisterDependency(dependency);
+    });
     this._disposed = true;
   }
 }
@@ -552,6 +552,83 @@ class ValueNode extends Node {
   }
 }
 
+class ValueAsyncNode extends ValueNode {
+  _scheduler;
+  _compute;
+  constructor(promiseOrCompute) {
+    super();
+    if (typeof promiseOrCompute === "function") {
+      this._compute = () => promiseOrCompute(this, this._value);
+    } else {
+      this._compute = () => promiseOrCompute;
+    }
+    this.status = "dirty";
+    this._scheduler = new AsyncScheduler(
+      () => this._compute(),
+      (value) => this._onResolve(value),
+      (error) => this._onReject(error)
+    );
+  }
+  _onResolve(value) {
+    this.status = "resolved";
+    this._value = value;
+    this._error = void 0;
+    this.notifyDependents();
+  }
+  _onReject(error) {
+    this.status = "error";
+    this._error = error;
+    this.notifyDependents();
+  }
+  set(promiseOrUpdater) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (typeof promiseOrUpdater === "function") {
+      const updater = promiseOrUpdater;
+      switch (this.status) {
+        case "resolved": {
+          this.status = "pending";
+          this._scheduler.overwrite(updater(this._value));
+          this.notifyDependents();
+          return;
+        }
+        case "pending":
+        case "error":
+        case "dirty": {
+          this.status = "pending";
+          this._scheduler.overwrite(updater(this._value));
+          this.notifyDependents();
+          return;
+        }
+      }
+    } else {
+      this.status = "pending";
+      const promise = promiseOrUpdater;
+      this._scheduler.overwrite(promise);
+      this.notifyDependents();
+    }
+  }
+  refresh() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this.execute();
+  }
+}
+
+function constantAsync(valueOrInitializer) {
+  return new ValueAsyncNode(valueOrInitializer);
+}
+
+function derivationAsync(compute) {
+  return new ValueAsyncNode(compute);
+}
+
+function stateAsync(valueOrInitializer) {
+  return new ValueAsyncNode(valueOrInitializer);
+}
+
+function writableDerivationAsync(compute) {
+  return new ValueAsyncNode(compute);
+}
+
 class ValueSyncNode extends ValueNode {
   _scheduler;
   _compute;
@@ -657,6 +734,14 @@ class ArrayNode extends ValueSyncNode {
       clearedItems: []
     });
   }
+  get(tracker) {
+    const values = super.get(tracker);
+    return [...values];
+  }
+  async pick() {
+    const values = await super.pick();
+    return [...values];
+  }
   get length() {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
     return this._value.length;
@@ -744,6 +829,10 @@ class ArrayNode extends ValueSyncNode {
   }
 }
 
+function array(initial) {
+  return new ArrayNode(initial);
+}
+
 class MapNode extends ValueSyncNode {
   $lastAction;
   constructor(value = /* @__PURE__ */ new Map()) {
@@ -815,95 +904,6 @@ class MapNode extends ValueSyncNode {
   }
 }
 
-class SignalNode extends Observable {
-  subscribe(onTrigger, onError, onPending) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const effect = new EffectNode((t) => this.watch(t), onTrigger, onError, onPending);
-    return effect;
-  }
-}
-
-class ValueAsyncNode extends ValueNode {
-  _scheduler;
-  _compute;
-  constructor(promiseOrCompute) {
-    super();
-    if (typeof promiseOrCompute === "function") {
-      this._compute = () => promiseOrCompute(this, this._value);
-    } else {
-      this._compute = () => promiseOrCompute;
-    }
-    this.status = "dirty";
-    this._scheduler = new AsyncScheduler(
-      () => this._compute(),
-      (value) => this._onResolve(value),
-      (error) => this._onReject(error)
-    );
-  }
-  _onResolve(value) {
-    this.status = "resolved";
-    this._value = value;
-    this._error = void 0;
-    this.notifyDependents();
-  }
-  _onReject(error) {
-    this.status = "error";
-    this._error = error;
-    this.notifyDependents();
-  }
-  set(promiseOrUpdater) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    if (typeof promiseOrUpdater === "function") {
-      const updater = promiseOrUpdater;
-      switch (this.status) {
-        case "resolved": {
-          this.status = "pending";
-          this._scheduler.overwrite(updater(this._value));
-          this.notifyDependents();
-          return;
-        }
-        case "pending":
-        case "error":
-        case "dirty": {
-          this.status = "pending";
-          this._scheduler.overwrite(updater(this._value));
-          this.notifyDependents();
-          return;
-        }
-      }
-    } else {
-      this.status = "pending";
-      const promise = promiseOrUpdater;
-      this._scheduler.overwrite(promise);
-      this.notifyDependents();
-    }
-  }
-  refresh() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this.execute();
-  }
-}
-
-function constantAsync(valueOrInitializer) {
-  return new ValueAsyncNode(valueOrInitializer);
-}
-
-function derivationAsync(compute) {
-  return new ValueAsyncNode(compute);
-}
-
-function stateAsync(valueOrInitializer) {
-  return new ValueAsyncNode(valueOrInitializer);
-}
-
-function writableDerivationAsync(compute) {
-  return new ValueAsyncNode(compute);
-}
-
-function array(initial) {
-  return new ArrayNode(initial);
-}
-
 function map(initial) {
   if (initial instanceof Map) {
     return new MapNode(initial);
@@ -915,6 +915,14 @@ function subscribe(data, onData, onError, onPending) {
   return new EffectNode(data, onData, onError, onPending);
 }
 
+class SignalNode extends Observable {
+  subscribe(onTrigger, onError, onPending) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const effect = new EffectNode((t) => this.watch(t), onTrigger, onError, onPending);
+    return effect;
+  }
+}
+
 function signal() {
   return new SignalNode();
 }

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

@@ -1,4 +1,4 @@
-import { FlowEffect } from '../nodes';
+import { FlowEffect } from '../nodes/flowEffect';
 import { FlowTracker } from './flowTracker';
 /**
  * Function that tracks reactive dependencies and returns data.

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

@@ -1 +1 @@
-{"version":3,"file":"flowSubscribable.d.ts","sourceRoot":"","sources":["../../../../src/api/base/flowSubscribable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,WAAW,KAAK,CAAC,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,SAAS,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B;;;;;;;;;;;;OAYG;IACH,SAAS,CACL,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC7B,OAAO,CAAC,EAAE,mBAAmB,EAC7B,SAAS,CAAC,EAAE,qBAAqB,GAClC,UAAU,CAAC;CACjB"}
+{"version":3,"file":"flowSubscribable.d.ts","sourceRoot":"","sources":["../../../../src/api/base/flowSubscribable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,WAAW,KAAK,CAAC,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,SAAS,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B;;;;;;;;;;;;OAYG;IACH,SAAS,CACL,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC7B,OAAO,CAAC,EAAE,mBAAmB,EAC7B,SAAS,CAAC,EAAE,qBAAqB,GAClC,UAAU,CAAC;CACjB"}

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

@@ -1,4 +1,4 @@
-import { FlowTracker } from '../../../../api/base';
+import { FlowTracker } from '../../base';
 import { FlowValue } from '../flowValue';
 import { NotPromise } from '../utils';
 /** Function that derives a value asynchronously from dependencies and optionally the previous value. */