@ersbeth/picoflow 0.2.1 → 0.2.3

package/dist/picoflow.js

@@ -311,7 +311,15 @@ class FlowDerivation extends FlowObservable {
   /* @internal */
   _compute() {
     if (this._dirty) {
-      this._value = this._untrackedCompute();
+      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;
     }
   }
@@ -777,4 +785,838 @@ 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 };
+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 };