@actuallab/fusion 12.1.62

package/dist/index.js

@@ -0,0 +1,661 @@
+// src/computed-input.ts
+var _nextInstanceId = 0;
+var _instanceIds = /* @__PURE__ */ new WeakMap();
+function getInstanceId(instance) {
+  let id = _instanceIds.get(instance);
+  if (id === void 0) {
+    id = ++_nextInstanceId;
+    _instanceIds.set(instance, id);
+  }
+  return id;
+}
+
+// src/computed.ts
+import { AsyncContext as AsyncContext2, EventHandlerSet, PromiseSource, Result, result } from "@actuallab/core";
+
+// src/computed-registry.ts
+var ComputedRegistry = class _ComputedRegistry {
+  static _entries = /* @__PURE__ */ new Map();
+  static _finalization = new FinalizationRegistry((key) => {
+    _ComputedRegistry._entries.delete(key);
+  });
+  static get size() {
+    return _ComputedRegistry._entries.size;
+  }
+  static get(key) {
+    const ref = _ComputedRegistry._entries.get(key);
+    if (ref === void 0) return void 0;
+    const computed = ref.deref();
+    if (computed === void 0) {
+      _ComputedRegistry._entries.delete(key);
+      return void 0;
+    }
+    return computed;
+  }
+  static register(computed) {
+    const key = computed.input;
+    _ComputedRegistry._entries.set(key, new WeakRef(computed));
+    _ComputedRegistry._finalization.register(computed, key, computed);
+  }
+  static unregister(computed) {
+    const key = computed.input;
+    _ComputedRegistry._entries.delete(key);
+    _ComputedRegistry._finalization.unregister(computed);
+  }
+};
+
+// src/compute-context.ts
+import { AsyncContext, AsyncContextKey } from "@actuallab/core";
+var computeContextKey = new AsyncContextKey("ComputeContext", void 0);
+var ComputeContext = class {
+  computed;
+  _isCapturing = true;
+  constructor(computed) {
+    this.computed = computed;
+  }
+  get isCapturing() {
+    return this._isCapturing;
+  }
+  stopCapturing() {
+    this._isCapturing = false;
+  }
+  captureDependency(dependency) {
+    if (!this._isCapturing) return;
+    this.computed.addDependency(dependency);
+  }
+  /** Resolve ComputeContext from an AsyncContext (or current). */
+  static from(ctx) {
+    return AsyncContext.from(ctx)?.get(computeContextKey);
+  }
+};
+
+// src/computed.ts
+var _nextVersion = 0;
+var ConsistencyState = /* @__PURE__ */ ((ConsistencyState2) => {
+  ConsistencyState2[ConsistencyState2["Computing"] = 0] = "Computing";
+  ConsistencyState2[ConsistencyState2["Consistent"] = 1] = "Consistent";
+  ConsistencyState2[ConsistencyState2["Invalidated"] = 2] = "Invalidated";
+  return ConsistencyState2;
+})(ConsistencyState || {});
+var Computed = class _Computed {
+  /** Delay before auto-invalidating a Computed that holds an error result. 0 = disabled. */
+  static errorAutoInvalidateDelay = 1e3;
+  /** Capture the Computed backing a computation — works with both local and RPC compute methods. */
+  static async capture(fn) {
+    const captureComputed = new _Computed("__capture__");
+    const captureCtx = new ComputeContext(captureComputed);
+    const asyncCtx = AsyncContext2.getOrCreate().with(computeContextKey, captureCtx);
+    await asyncCtx.run(fn);
+    const deps = captureComputed.dependencies;
+    if (deps.size === 0)
+      throw new Error("No Computed was captured \u2014 fn must call a compute function.");
+    return deps.values().next().value;
+  }
+  input;
+  _version;
+  _state;
+  _output;
+  _dependencies = /* @__PURE__ */ new Set();
+  _dependants = /* @__PURE__ */ new Map();
+  onInvalidated = new EventHandlerSet();
+  _renewer;
+  constructor(input, renewer) {
+    this.input = input;
+    this._renewer = renewer;
+    this._version = ++_nextVersion;
+    this._state = 0 /* Computing */;
+  }
+  get version() {
+    return this._version;
+  }
+  get output() {
+    if (this._output === void 0) throw new Error("Computed has no output yet.");
+    return this._output;
+  }
+  get hasValue() {
+    return this.output.hasValue;
+  }
+  get hasError() {
+    return this.output.hasError;
+  }
+  get value() {
+    return this.output.value;
+  }
+  get error() {
+    return this.output.error;
+  }
+  get valueOrUndefined() {
+    return this.output.valueOrUndefined;
+  }
+  get state() {
+    return this._state;
+  }
+  get isConsistent() {
+    return this._state === 1 /* Consistent */;
+  }
+  get dependencies() {
+    return this._dependencies;
+  }
+  update() {
+    if (this._state === 1 /* Consistent */) return this;
+    const latest = this._latest();
+    if (latest?.isConsistent) return latest;
+    if (this._renewer !== void 0) return this._renewer();
+    throw new Error("Cannot recompute: Computed is invalidated and has no renewer.");
+  }
+  _latest() {
+    return ComputedRegistry.get(this.input);
+  }
+  use(asyncContext) {
+    const ctx = ComputeContext.from(asyncContext);
+    const updated = this.update();
+    if (updated instanceof Promise) {
+      return updated.then((c) => {
+        ctx?.captureDependency(c);
+        return c.value;
+      });
+    }
+    ctx?.captureDependency(updated);
+    return updated.value;
+  }
+  useInconsistent(asyncContext) {
+    ComputeContext.from(asyncContext)?.captureDependency(this);
+    return this.value;
+  }
+  setOutput(output) {
+    if (this._state !== 0 /* Computing */)
+      throw new Error("Cannot set output on a non-computing Computed.");
+    this._output = output instanceof Result ? output : result(output);
+    this._state = 1 /* Consistent */;
+    this._register();
+    if (this._output.hasError && _Computed.errorAutoInvalidateDelay > 0)
+      setTimeout(() => this.invalidate(), _Computed.errorAutoInvalidateDelay);
+  }
+  _register() {
+    ComputedRegistry.register(this);
+  }
+  _unregister() {
+    ComputedRegistry.unregister(this);
+  }
+  invalidate() {
+    if (this._state === 2 /* Invalidated */) return;
+    this._state = 2 /* Invalidated */;
+    this._dependencies.clear();
+    for (const [, ref] of this._dependants) {
+      const dependant = ref.deref();
+      if (dependant != null) dependant.invalidate();
+    }
+    this._dependants.clear();
+    this.onInvalidated.trigger();
+    this.onInvalidated.clear();
+    this._unregister();
+  }
+  whenInvalidated(abortSignal) {
+    if (this._state === 2 /* Invalidated */)
+      return Promise.resolve();
+    const ps = new PromiseSource();
+    const handler = () => ps.resolve(void 0);
+    this.onInvalidated.add(handler);
+    if (abortSignal !== void 0 && !abortSignal.aborted) {
+      abortSignal.addEventListener("abort", () => {
+        this.onInvalidated.remove(handler);
+        ps.reject(abortSignal.reason);
+      }, { once: true });
+    }
+    return ps.promise;
+  }
+  addDependency(dependency) {
+    this._dependencies.add(dependency);
+    dependency._dependants.set(this._version, new WeakRef(this));
+  }
+};
+var StateBoundComputed = class extends Computed {
+  constructor(state, renewer) {
+    super(state, renewer);
+  }
+  _latest() {
+    return this.input.computed;
+  }
+  _register() {
+  }
+  _unregister() {
+  }
+};
+
+// src/compute-function.ts
+import { AsyncContext as AsyncContext3, AsyncLock, result as result2, errorResult } from "@actuallab/core";
+var RS = "";
+function defaultArgToString(arg) {
+  return JSON.stringify(arg) ?? "undefined";
+}
+var _nextFunctionId = 0;
+var ComputeFunction = class {
+  methodName;
+  id;
+  argToString = defaultArgToString;
+  _impl;
+  _locks = /* @__PURE__ */ new Map();
+  constructor(methodName, impl) {
+    this.methodName = methodName;
+    this.id = `${methodName}[${++_nextFunctionId}]`;
+    this._impl = impl;
+  }
+  /** Build a string key for the given instance and arguments. */
+  buildKey(instance, args) {
+    let key = String(getInstanceId(instance)) + RS + this.id;
+    for (const arg of args) {
+      key += RS + this.argToString(arg);
+    }
+    return key;
+  }
+  async invoke(instance, args, prevComputed) {
+    const asyncCtx = AsyncContext3.fromArgs(args);
+    const callerComputeCtx = asyncCtx?.get(computeContextKey);
+    const argsWithoutCtx = asyncCtx?.stripFromArgs(args) ?? args;
+    const key = this.buildKey(instance, argsWithoutCtx);
+    const existing = ComputedRegistry.get(key);
+    if (existing?.isConsistent) {
+      callerComputeCtx?.captureDependency(existing);
+      return existing;
+    }
+    let lock = this._locks.get(key);
+    if (lock === void 0) {
+      lock = new AsyncLock();
+      this._locks.set(key, lock);
+    }
+    const computed = await lock.run(async () => {
+      const cached = ComputedRegistry.get(key);
+      if (cached?.isConsistent) return cached;
+      let newComputed;
+      const renewer = prevComputed?._renewer ?? (() => this.invoke(instance, argsWithoutCtx, newComputed));
+      newComputed = new Computed(key, renewer);
+      const childComputeCtx = new ComputeContext(newComputed);
+      const childAsyncCtx = (asyncCtx ?? AsyncContext3.empty).with(computeContextKey, childComputeCtx);
+      let fnResult;
+      try {
+        const value = childAsyncCtx.run(() => this._impl.call(instance, ...argsWithoutCtx));
+        const resolved = value instanceof Promise ? await value : value;
+        fnResult = result2(resolved);
+      } catch (e) {
+        fnResult = errorResult(e);
+      }
+      newComputed.setOutput(fnResult);
+      return newComputed;
+    });
+    callerComputeCtx?.captureDependency(computed);
+    return computed;
+  }
+};
+
+// src/compute-method.ts
+var METHODS_META = /* @__PURE__ */ Symbol.for("actuallab.methods");
+function getMethodsMeta(cls) {
+  return cls[Symbol.metadata]?.[METHODS_META];
+}
+function computeMethod(target, context) {
+  const methodName = String(context.name);
+  const methods = context.metadata[METHODS_META] ??= {};
+  methods[methodName] = { ...methods[methodName], compute: true, argCount: target.length };
+  const cf = new ComputeFunction(methodName, target);
+  const replacement = function(...allArgs) {
+    return cf.invoke(this, allArgs).then((c) => c.value);
+  };
+  context.addInitializer(function() {
+    const instance = this;
+    const boundMethod = (...allArgs) => {
+      return cf.invoke(instance, allArgs).then((c) => c.value);
+    };
+    boundMethod.invalidate = (...args) => {
+      const key = cf.buildKey(instance, args);
+      ComputedRegistry.get(key)?.invalidate();
+    };
+    this[methodName] = boundMethod;
+  });
+  return replacement;
+}
+function wrapComputeMethod(fn) {
+  const syntheticInstance = {};
+  const methodName = fn.name || "anonymous";
+  const cf = new ComputeFunction(methodName, fn);
+  const wrapped = (...allArgs) => {
+    return cf.invoke(syntheticInstance, allArgs).then((c) => c.value);
+  };
+  wrapped.invalidate = (...args) => {
+    const key = cf.buildKey(syntheticInstance, args);
+    ComputedRegistry.get(key)?.invalidate();
+  };
+  return wrapped;
+}
+
+// src/update-delayer.ts
+var FixedDelayer = class _FixedDelayer {
+  static zero = () => Promise.resolve();
+  static _cache = /* @__PURE__ */ new Map();
+  static get(ms) {
+    if (ms <= 0) return _FixedDelayer.zero;
+    let delayer = _FixedDelayer._cache.get(ms);
+    if (delayer === void 0) {
+      delayer = new _FixedDelayer(ms).delay;
+      _FixedDelayer._cache.set(ms, delayer);
+    }
+    return delayer;
+  }
+  ms;
+  delay;
+  constructor(ms) {
+    this.ms = ms;
+    this.delay = ms > 1e4 ? (abortSignal) => new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, this.ms);
+      if (abortSignal === void 0) return;
+      if (abortSignal.aborted) {
+        clearTimeout(timer);
+        reject(abortSignal.reason);
+        return;
+      }
+      abortSignal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(abortSignal.reason);
+      }, { once: true });
+    }) : () => new Promise((resolve) => setTimeout(resolve, this.ms));
+  }
+};
+var defaultUpdateDelayer = FixedDelayer.get(1e3 / 60);
+
+// src/ui-action-tracker.ts
+import { EventHandlerSet as EventHandlerSet2 } from "@actuallab/core";
+var UIActionTracker = class {
+  _activeCount = 0;
+  changed = new EventHandlerSet2();
+  errors = [];
+  get isActive() {
+    return this._activeCount > 0;
+  }
+  /** Run a command silently — errors are added to the error list but not thrown. */
+  async run(fn) {
+    this._activeCount++;
+    this.changed.trigger();
+    try {
+      await fn();
+    } catch (e) {
+      this.errors.push(e);
+    } finally {
+      this._activeCount--;
+      await new Promise((r) => setTimeout(r, 50));
+      this.changed.trigger();
+    }
+  }
+  /** Call a command and return the result — errors are added to the error list AND thrown. */
+  async call(fn) {
+    this._activeCount++;
+    this.changed.trigger();
+    try {
+      return await fn();
+    } catch (e) {
+      this.errors.push(e);
+      throw e;
+    } finally {
+      this._activeCount--;
+      await new Promise((r) => setTimeout(r, 50));
+      this.changed.trigger();
+    }
+  }
+  dismissError(index) {
+    if (index >= 0 && index < this.errors.length) {
+      this.errors.splice(index, 1);
+      this.changed.trigger();
+    }
+  }
+};
+var uiActions = new UIActionTracker();
+
+// src/ui-update-delayer.ts
+var UIUpdateDelayer = class _UIUpdateDelayer {
+  static _cache = /* @__PURE__ */ new Map();
+  static get(ms) {
+    if (ms <= 0) return FixedDelayer.zero;
+    let delayer = _UIUpdateDelayer._cache.get(ms);
+    if (delayer !== void 0) return delayer;
+    const t = uiActions;
+    delayer = (abortSignal) => {
+      if (t.isActive)
+        return Promise.resolve();
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        const onChanged = () => {
+          if (t.isActive) {
+            clearTimeout(timer);
+            t.changed.remove(onChanged);
+            resolve();
+          }
+        };
+        t.changed.add(onChanged);
+        if (abortSignal !== void 0) {
+          if (abortSignal.aborted) {
+            clearTimeout(timer);
+            t.changed.remove(onChanged);
+            reject(abortSignal.reason);
+            return;
+          }
+          abortSignal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            t.changed.remove(onChanged);
+            reject(abortSignal.reason);
+          }, { once: true });
+        }
+      });
+    };
+    _UIUpdateDelayer._cache.set(ms, delayer);
+    return delayer;
+  }
+};
+
+// src/state.ts
+import { PromiseSource as PromiseSource2, resolvedVoidPromise } from "@actuallab/core";
+var State = class {
+  _computed;
+  _updateIndex = 0;
+  _lastNonErrorValue;
+  _whenUpdatedSource = null;
+  get updateIndex() {
+    return this._updateIndex;
+  }
+  get lastNonErrorValue() {
+    return this._lastNonErrorValue;
+  }
+  get hasValue() {
+    return this._computed.hasValue;
+  }
+  get hasError() {
+    return this._computed.hasError;
+  }
+  get value() {
+    return this._computed.value;
+  }
+  get error() {
+    return this._computed.error;
+  }
+  get valueOrUndefined() {
+    return this._computed.valueOrUndefined;
+  }
+  get output() {
+    return this._computed.output;
+  }
+  get computed() {
+    return this._computed;
+  }
+  use(asyncContext) {
+    return this._computed.use(asyncContext);
+  }
+  useInconsistent(asyncContext) {
+    return this._computed.useInconsistent(asyncContext);
+  }
+  update() {
+    return this._computed.update();
+  }
+  recompute() {
+    this._computed.invalidate();
+    return this.update();
+  }
+  whenInvalidated() {
+    return this._computed.whenInvalidated();
+  }
+  whenUpdated() {
+    return (this._whenUpdatedSource ??= new PromiseSource2()).promise;
+  }
+  whenFirstTimeUpdated() {
+    return this._updateIndex > 0 ? resolvedVoidPromise : this.whenUpdated();
+  }
+  _initialize(output, renewer) {
+    this._computed = new StateBoundComputed(this, renewer);
+    this._computed.setOutput(output);
+    this._lastNonErrorValue = this._computed.valueOrUndefined;
+  }
+  _update(computed, output) {
+    computed.setOutput(output);
+    this._computed = computed;
+    if (computed.hasValue)
+      this._lastNonErrorValue = computed.value;
+    this._updateIndex++;
+    this._whenUpdatedSource?.resolve(void 0);
+    this._whenUpdatedSource = null;
+  }
+};
+
+// src/computed-state.ts
+import { AsyncContext as AsyncContext4, PromiseSource as PromiseSource3, result as result3, errorResult as errorResult2 } from "@actuallab/core";
+var ComputedState = class extends State {
+  _computer;
+  _updateDelayer;
+  _disposeController;
+  _cancelDelaySource = new PromiseSource3();
+  _renewer;
+  _hasOutput = false;
+  constructor(computer, options) {
+    super();
+    this._computer = computer;
+    this._updateDelayer = options?.updateDelayer ?? defaultUpdateDelayer;
+    this._disposeController = new AbortController();
+    this._renewer = async () => {
+      const whenUpdated = this.whenUpdated();
+      this._cancelDelaySource.resolve(void 0);
+      await whenUpdated;
+      return this._computed;
+    };
+    if (options?.initialOutput !== void 0 || options?.initialValue !== void 0) {
+      this._initialize(options.initialOutput ?? options.initialValue, this._renewer);
+      this._hasOutput = true;
+    }
+    void this._updateCycle();
+  }
+  get hasValue() {
+    if (!this._hasOutput && this._updateIndex === 0) return false;
+    return this._computed.hasValue;
+  }
+  get hasError() {
+    if (!this._hasOutput && this._updateIndex === 0) return false;
+    return this._computed.hasError;
+  }
+  get value() {
+    if (!this._hasOutput && this._updateIndex === 0) throw new Error("ComputedState has no value yet.");
+    if (this._computed.hasValue) return this._computed.value;
+    if (this._lastNonErrorValue !== void 0) return this._lastNonErrorValue;
+    throw new Error("ComputedState has no value yet.");
+  }
+  get error() {
+    if (!this._hasOutput && this._updateIndex === 0) return void 0;
+    return this._computed.error;
+  }
+  get valueOrUndefined() {
+    if (!this._hasOutput && this._updateIndex === 0) return void 0;
+    return this._computed.valueOrUndefined ?? this._lastNonErrorValue;
+  }
+  get output() {
+    if (!this._hasOutput && this._updateIndex === 0) throw new Error("ComputedState has no output yet.");
+    return this._computed.output;
+  }
+  get computed() {
+    if (!this._hasOutput && this._updateIndex === 0) throw new Error("ComputedState has not been computed yet.");
+    return this._computed;
+  }
+  get isDisposed() {
+    return this._disposeController.signal.aborted;
+  }
+  dispose() {
+    if (!this.isDisposed)
+      this._disposeController.abort();
+  }
+  async _updateCycle() {
+    const disposeSignal = this._disposeController.signal;
+    try {
+      while (!disposeSignal.aborted) {
+        const computed = new StateBoundComputed(this, this._renewer);
+        const computeCtx = new ComputeContext(computed);
+        const asyncCtx = (AsyncContext4.current ?? AsyncContext4.empty).with(computeContextKey, computeCtx);
+        let output;
+        try {
+          const value = asyncCtx.run(() => this._computer());
+          const resolved = value instanceof Promise ? await value : value;
+          output = result3(resolved);
+        } catch (e) {
+          output = errorResult2(e);
+        }
+        this._update(computed, output);
+        if (this._cancelDelaySource.isCompleted)
+          this._cancelDelaySource = new PromiseSource3();
+        try {
+          await computed.whenInvalidated(disposeSignal);
+        } catch {
+          return;
+        }
+        await Promise.race([
+          this._updateDelayer(disposeSignal),
+          this._cancelDelaySource.promise
+        ]);
+      }
+    } catch (e) {
+    }
+  }
+};
+
+// src/mutable-state.ts
+import "@actuallab/core";
+var MutableState = class extends State {
+  _renewer = () => {
+    const computed = new StateBoundComputed(this, this._renewer);
+    this._update(computed, this._computed.output);
+    return computed;
+  };
+  constructor(initialOutput) {
+    super();
+    this._initialize(initialOutput, this._renewer);
+  }
+  use(asyncContext) {
+    return this._computed.use(asyncContext);
+  }
+  set(output) {
+    this._computed.invalidate();
+    this._update(new StateBoundComputed(this, this._renewer), output);
+  }
+};
+export {
+  ComputeContext,
+  ComputeFunction,
+  Computed,
+  ComputedRegistry,
+  ComputedState,
+  ConsistencyState,
+  FixedDelayer,
+  MutableState,
+  State,
+  StateBoundComputed,
+  UIActionTracker,
+  UIUpdateDelayer,
+  computeContextKey,
+  computeMethod,
+  defaultUpdateDelayer,
+  getInstanceId,
+  getMethodsMeta,
+  uiActions,
+  wrapComputeMethod
+};
+//# sourceMappingURL=index.js.map