@tachui/core 0.7.0-alpha1

package/dist/reactive/computed.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("./context.cjs"),l=require("./equality.cjs"),i=require("./types.cjs"),n=require("./unified-scheduler.cjs");var c=Object.defineProperty,h=(s,e,t)=>e in s?c(s,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):s[e]=t,o=(s,e,t)=>h(s,typeof e!="symbol"?e+"":e,t);class p extends a.ComputationImpl{constructor(e,t={},r=a.getCurrentOwner()){super(e,r),o(this,"type","computed"),o(this,"priority"),o(this,"_hasValue",!1),o(this,"_error",null),o(this,"equalsFn"),o(this,"options"),this.priority=t.priority??n.UpdatePriority.Normal,this.equalsFn=t.equals??l.defaultEquals,this.options=t}getValue(){const e=a.getCurrentComputation();return e&&e.state!==i.ComputationState.Disposed&&(this.observers.add(e),e.sources.add(this)),(this.state===i.ComputationState.Dirty||!this._hasValue)&&(this.execute(),this._hasValue=!0),this.value}peek(){return(this.state===i.ComputationState.Dirty||!this._hasValue)&&(this.execute(),this._hasValue=!0),this.value}removeObserver(e){this.observers.delete(e)}execute(){const e=this._hasValue?this.value:void 0,t=super.execute();if(!this._hasValue||!this.equalsFn(e,t))for(const r of this.observers)r.state!==i.ComputationState.Disposed&&(r.state=i.ComputationState.Dirty,"execute"in r&&typeof r.execute=="function"&&queueMicrotask(()=>{r.state===i.ComputationState.Dirty&&r.execute()}));return t}notify(){this.execute()}cleanup(){for(const e of this.sources)"removeObserver"in e&&e.removeObserver(this);this.sources.clear();for(const e of this.observers)e.sources.delete(this);this.observers.clear(),this._hasValue=!1,this._error=null,this.state=i.ComputationState.Disposed}dispose(){this.cleanup(),super.dispose()}[Symbol.for("tachui.debug")](){return{id:this.id,type:this.type,value:this._hasValue?this.value:void 0,hasValue:this._hasValue,error:this._error?.message,state:this.state,sourceCount:this.sources.size,observerCount:this.observers.size,priority:n.UpdatePriority[this.priority],debugName:this.options.debugName,equalsFn:this.equalsFn.name||"anonymous"}}toString(){return`Computed(${this.options.debugName||this.id}): ${this._hasValue?this.value:"no value"}`}}function u(s,e){const t=new p(s,e),r=t.getValue.bind(t);return r.peek=t.peek.bind(t),Object.defineProperty(r,Symbol.for("tachui.computed"),{value:t,enumerable:!1}),r}function d(s,e){return u(s,e)}function m(s){return typeof s=="function"&&Symbol.for("tachui.computed")in s}function f(s){return s[Symbol.for("tachui.computed")]||null}function b(s,e){return u(e?()=>{for(const r of e)r();return s()}:s)}function v(s,e){let t,r=!1;return u(()=>(e()&&(t=s(),r=!0),r||(t=s(),r=!0),t))}exports.createComputed=u;exports.createConditionalComputed=v;exports.createDerivedSignal=b;exports.createMemo=d;exports.getComputedImpl=f;exports.isComputed=m;
+//# sourceMappingURL=computed.cjs.map

package/dist/reactive/computed.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.cjs","sources":["../../src/reactive/computed.ts"],"sourcesContent":["/**\n * Computed values implementation\n *\n * Computed values are derived reactive values that automatically\n * update when their dependencies change, with memoization.\n */\n\nimport { ComputationImpl, getCurrentComputation, getCurrentOwner } from './context'\nimport { defaultEquals, type EqualityFunction } from './equality'\nimport type { Computation, Signal } from './types'\nimport { ComputationState } from './types'\nimport { type ReactiveNode, UpdatePriority } from './unified-scheduler'\n\nexport interface ComputedOptions<T> {\n  equals?: EqualityFunction<T>\n  priority?: UpdatePriority\n  debugName?: string\n  onError?: (error: Error) => T // Error recovery function\n}\n\n/**\n * Robust computed value implementation with error recovery\n */\nclass ComputedImpl<T> extends ComputationImpl implements ReactiveNode {\n  readonly type = 'computed' as const\n  readonly priority: UpdatePriority\n\n  private _hasValue = false\n  private _error: Error | null = null\n  private equalsFn: EqualityFunction<T>\n  private options: ComputedOptions<T>\n\n  constructor(fn: () => T, options: ComputedOptions<T> = {}, owner = getCurrentOwner()) {\n    super(fn, owner)\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.equalsFn = options.equals ?? defaultEquals\n    this.options = options\n  }\n\n  /**\n   * Get the computed value, tracking dependency and lazily computing\n   */\n  getValue(): T {\n    // Track this computed as a dependency if we're in a reactive context\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n\n    // Compute value if needed\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n\n    return this.value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n    return this.value\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Execute the computation and notify observers\n   */\n  execute(): T {\n    const previousValue = this._hasValue ? this.value : undefined\n    const result = super.execute()\n\n    // Only notify observers if the value actually changed\n    if (!this._hasValue || !this.equalsFn(previousValue, result)) {\n      // Notify dependent computations\n      for (const observer of this.observers) {\n        if (observer.state !== ComputationState.Disposed) {\n          observer.state = ComputationState.Dirty\n          // Use the signal's scheduling mechanism for consistency\n          if ('execute' in observer && typeof observer.execute === 'function') {\n            queueMicrotask(() => {\n              if (observer.state === ComputationState.Dirty) {\n                observer.execute()\n              }\n            })\n          }\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Notify method for ReactiveNode compatibility\n   */\n  notify(): void {\n    // For computations, notify means execute\n    this.execute()\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    // Complete bidirectional cleanup\n    for (const source of this.sources) {\n      if ('removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    this._hasValue = false\n    this._error = null\n    this.state = ComputationState.Disposed\n  }\n\n  /**\n   * Dispose the computed value\n   */\n  dispose(): void {\n    this.cleanup()\n    super.dispose()\n  }\n\n  /**\n   * Debug information\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      value: this._hasValue ? this.value : undefined,\n      hasValue: this._hasValue,\n      error: this._error?.message,\n      state: this.state,\n      sourceCount: this.sources.size,\n      observerCount: this.observers.size,\n      priority: UpdatePriority[this.priority],\n      debugName: this.options.debugName,\n      equalsFn: this.equalsFn.name || 'anonymous',\n    }\n  }\n\n  toString(): string {\n    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : 'no value'}`\n  }\n}\n\n/**\n * Create a computed value that automatically updates when dependencies change\n *\n * @param fn The computation function\n * @param options Configuration options for the computed value\n * @returns An accessor function for the computed value\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n * const doubleCount = createComputed(() => count() * 2, {\n *   debugName: 'doubleCounter',\n *   onError: (error) => {\n *     console.error('Computation failed:', error)\n *     return 0 // fallback value\n *   }\n * })\n *\n * console.log(doubleCount()) // 0\n * setCount(5)\n * console.log(doubleCount()) // 10\n * ```\n */\nexport function createComputed<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  const computed = new ComputedImpl(fn, options)\n\n  // Create bound accessor with peek method - this is already a Signal<T>\n  const accessor = computed.getValue.bind(computed) as Signal<T>\n  accessor.peek = computed.peek.bind(computed)\n\n  // Add debug information\n  Object.defineProperty(accessor, Symbol.for('tachui.computed'), {\n    value: computed,\n    enumerable: false,\n  })\n\n  return accessor\n}\n\n/**\n * Create a memo (alias for createComputed for SolidJS compatibility)\n */\nexport function createMemo<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  return createComputed(fn, options)\n}\n\n/**\n * Type guard to check if a value is a computed\n */\nexport function isComputed<T = any>(value: any): value is Signal<T> {\n  return typeof value === 'function' && Symbol.for('tachui.computed') in value\n}\n\n/**\n * Get the underlying computed implementation for debugging\n */\nexport function getComputedImpl<T>(computed: Signal<T>): ComputedImpl<T> | null {\n  return (computed as any)[Symbol.for('tachui.computed')] || null\n}\n\n/**\n * Create a computed value with explicit dependency tracking\n *\n * @param fn The computation function\n * @param deps Explicit dependencies (optional)\n * @returns An accessor function for the computed value\n */\nexport function createDerivedSignal<T>(fn: () => T, deps?: (() => any)[]): Signal<T> {\n  if (!deps) {\n    return createComputed(fn)\n  }\n\n  // Wrap function to explicitly track dependencies\n  const wrappedFn = () => {\n    // Read all dependencies to track them\n    for (const dep of deps) {\n      dep()\n    }\n    return fn()\n  }\n\n  return createComputed(wrappedFn)\n}\n\n/**\n * Create a computed value that only updates when a condition is met\n *\n * @param fn The computation function\n * @param when Condition function that must return true for updates\n * @returns An accessor function for the computed value\n */\nexport function createConditionalComputed<T>(fn: () => T, when: () => boolean): Signal<T> {\n  let lastValue: T\n  let hasValue = false\n\n  return createComputed(() => {\n    if (when()) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    if (!hasValue) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    return lastValue\n  })\n}\n\n/**\n * Public Computed type export\n */\nexport type Computed<T> = Signal<T>\n"],"names":["ComputedImpl","ComputationImpl","fn","options","owner","getCurrentOwner","__publicField","UpdatePriority","defaultEquals","computation","getCurrentComputation","ComputationState","previousValue","result","observer","source","createComputed","computed","accessor","createMemo","isComputed","value","getComputedImpl","createDerivedSignal","deps","dep","createConditionalComputed","when","lastValue","hasValue"],"mappings":"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"}

package/dist/reactive/computed.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Computed values implementation
+ *
+ * Computed values are derived reactive values that automatically
+ * update when their dependencies change, with memoization.
+ */
+import { ComputationImpl } from './context';
+import { type EqualityFunction } from './equality';
+import type { Computation, Signal } from './types';
+import { type ReactiveNode, UpdatePriority } from './unified-scheduler';
+export interface ComputedOptions<T> {
+    equals?: EqualityFunction<T>;
+    priority?: UpdatePriority;
+    debugName?: string;
+    onError?: (error: Error) => T;
+}
+/**
+ * Robust computed value implementation with error recovery
+ */
+declare class ComputedImpl<T> extends ComputationImpl implements ReactiveNode {
+    readonly type: "computed";
+    readonly priority: UpdatePriority;
+    private _hasValue;
+    private _error;
+    private equalsFn;
+    private options;
+    constructor(fn: () => T, options?: ComputedOptions<T>, owner?: import("./types").Owner | null);
+    /**
+     * Get the computed value, tracking dependency and lazily computing
+     */
+    getValue(): T;
+    /**
+     * Get the current value without tracking dependency
+     */
+    peek(): T;
+    /**
+     * Remove an observer (cleanup)
+     */
+    removeObserver(computation: Computation): void;
+    /**
+     * Execute the computation and notify observers
+     */
+    execute(): T;
+    /**
+     * Notify method for ReactiveNode compatibility
+     */
+    notify(): void;
+    /**
+     * Complete cleanup for memory management
+     */
+    cleanup(): void;
+    /**
+     * Dispose the computed value
+     */
+    dispose(): void;
+    toString(): string;
+}
+/**
+ * Create a computed value that automatically updates when dependencies change
+ *
+ * @param fn The computation function
+ * @param options Configuration options for the computed value
+ * @returns An accessor function for the computed value
+ *
+ * @example
+ * ```typescript
+ * const [count, setCount] = createSignal(0)
+ * const doubleCount = createComputed(() => count() * 2, {
+ *   debugName: 'doubleCounter',
+ *   onError: (error) => {
+ *     console.error('Computation failed:', error)
+ *     return 0 // fallback value
+ *   }
+ * })
+ *
+ * console.log(doubleCount()) // 0
+ * setCount(5)
+ * console.log(doubleCount()) // 10
+ * ```
+ */
+export declare function createComputed<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T>;
+/**
+ * Create a memo (alias for createComputed for SolidJS compatibility)
+ */
+export declare function createMemo<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T>;
+/**
+ * Type guard to check if a value is a computed
+ */
+export declare function isComputed<T = any>(value: any): value is Signal<T>;
+/**
+ * Get the underlying computed implementation for debugging
+ */
+export declare function getComputedImpl<T>(computed: Signal<T>): ComputedImpl<T> | null;
+/**
+ * Create a computed value with explicit dependency tracking
+ *
+ * @param fn The computation function
+ * @param deps Explicit dependencies (optional)
+ * @returns An accessor function for the computed value
+ */
+export declare function createDerivedSignal<T>(fn: () => T, deps?: (() => any)[]): Signal<T>;
+/**
+ * Create a computed value that only updates when a condition is met
+ *
+ * @param fn The computation function
+ * @param when Condition function that must return true for updates
+ * @returns An accessor function for the computed value
+ */
+export declare function createConditionalComputed<T>(fn: () => T, when: () => boolean): Signal<T>;
+/**
+ * Public Computed type export
+ */
+export type Computed<T> = Signal<T>;
+export {};
+//# sourceMappingURL=computed.d.ts.map

package/dist/reactive/computed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/reactive/computed.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAA0C,MAAM,WAAW,CAAA;AACnF,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAA;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAElD,OAAO,EAAE,KAAK,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEvE,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;IAC5B,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,CAAC,CAAA;CAC9B;AAED;;GAEG;AACH,cAAM,YAAY,CAAC,CAAC,CAAE,SAAQ,eAAgB,YAAW,YAAY;IACnE,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IACnC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IAEjC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,OAAO,CAAoB;gBAEvB,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM,EAAE,KAAK,iCAAoB;IAOpF;;OAEG;IACH,QAAQ,IAAI,CAAC;IAiBb;;OAEG;IACH,IAAI,IAAI,CAAC;IAQT;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAI9C;;OAEG;IACH,OAAO,IAAI,CAAC;IAyBZ;;OAEG;IACH,MAAM,IAAI,IAAI;IAKd;;OAEG;IACH,OAAO,IAAI,IAAI;IAmBf;;OAEG;IACH,OAAO,IAAI,IAAI;IAwBf,QAAQ,IAAI,MAAM;CAGnB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CActF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAElF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAElE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAenF;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAiBxF;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAA"}

package/dist/reactive/computed.js

@@ -0,0 +1,121 @@
+import { ComputationImpl as n, getCurrentOwner as h, getCurrentComputation as l } from "./context.js";
+import { defaultEquals as c } from "./equality.js";
+import { ComputationState as i } from "./types.js";
+import { UpdatePriority as a } from "./unified-scheduler.js";
+var p = Object.defineProperty, f = (s, e, t) => e in s ? p(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, o = (s, e, t) => f(s, typeof e != "symbol" ? e + "" : e, t);
+class d extends n {
+  constructor(e, t = {}, r = h()) {
+    super(e, r), o(this, "type", "computed"), o(this, "priority"), o(this, "_hasValue", !1), o(this, "_error", null), o(this, "equalsFn"), o(this, "options"), this.priority = t.priority ?? a.Normal, this.equalsFn = t.equals ?? c, this.options = t;
+  }
+  /**
+   * Get the computed value, tracking dependency and lazily computing
+   */
+  getValue() {
+    const e = l();
+    return e && e.state !== i.Disposed && (this.observers.add(e), e.sources.add(this)), (this.state === i.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return (this.state === i.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e);
+  }
+  /**
+   * Execute the computation and notify observers
+   */
+  execute() {
+    const e = this._hasValue ? this.value : void 0, t = super.execute();
+    if (!this._hasValue || !this.equalsFn(e, t))
+      for (const r of this.observers)
+        r.state !== i.Disposed && (r.state = i.Dirty, "execute" in r && typeof r.execute == "function" && queueMicrotask(() => {
+          r.state === i.Dirty && r.execute();
+        }));
+    return t;
+  }
+  /**
+   * Notify method for ReactiveNode compatibility
+   */
+  notify() {
+    this.execute();
+  }
+  /**
+   * Complete cleanup for memory management
+   */
+  cleanup() {
+    for (const e of this.sources)
+      "removeObserver" in e && e.removeObserver(this);
+    this.sources.clear();
+    for (const e of this.observers)
+      e.sources.delete(this);
+    this.observers.clear(), this._hasValue = !1, this._error = null, this.state = i.Disposed;
+  }
+  /**
+   * Dispose the computed value
+   */
+  dispose() {
+    this.cleanup(), super.dispose();
+  }
+  /**
+   * Debug information
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      type: this.type,
+      value: this._hasValue ? this.value : void 0,
+      hasValue: this._hasValue,
+      error: this._error?.message,
+      state: this.state,
+      sourceCount: this.sources.size,
+      observerCount: this.observers.size,
+      priority: a[this.priority],
+      debugName: this.options.debugName,
+      equalsFn: this.equalsFn.name || "anonymous"
+    };
+  }
+  toString() {
+    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : "no value"}`;
+  }
+}
+function u(s, e) {
+  const t = new d(s, e), r = t.getValue.bind(t);
+  return r.peek = t.peek.bind(t), Object.defineProperty(r, Symbol.for("tachui.computed"), {
+    value: t,
+    enumerable: !1
+  }), r;
+}
+function _(s, e) {
+  return u(s, e);
+}
+function V(s) {
+  return typeof s == "function" && Symbol.for("tachui.computed") in s;
+}
+function C(s) {
+  return s[Symbol.for("tachui.computed")] || null;
+}
+function g(s, e) {
+  return u(e ? () => {
+    for (const r of e)
+      r();
+    return s();
+  } : s);
+}
+function x(s, e) {
+  let t, r = !1;
+  return u(() => (e() && (t = s(), r = !0), r || (t = s(), r = !0), t));
+}
+export {
+  u as createComputed,
+  x as createConditionalComputed,
+  g as createDerivedSignal,
+  _ as createMemo,
+  C as getComputedImpl,
+  V as isComputed
+};
+//# sourceMappingURL=computed.js.map

package/dist/reactive/computed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.js","sources":["../../src/reactive/computed.ts"],"sourcesContent":["/**\n * Computed values implementation\n *\n * Computed values are derived reactive values that automatically\n * update when their dependencies change, with memoization.\n */\n\nimport { ComputationImpl, getCurrentComputation, getCurrentOwner } from './context'\nimport { defaultEquals, type EqualityFunction } from './equality'\nimport type { Computation, Signal } from './types'\nimport { ComputationState } from './types'\nimport { type ReactiveNode, UpdatePriority } from './unified-scheduler'\n\nexport interface ComputedOptions<T> {\n  equals?: EqualityFunction<T>\n  priority?: UpdatePriority\n  debugName?: string\n  onError?: (error: Error) => T // Error recovery function\n}\n\n/**\n * Robust computed value implementation with error recovery\n */\nclass ComputedImpl<T> extends ComputationImpl implements ReactiveNode {\n  readonly type = 'computed' as const\n  readonly priority: UpdatePriority\n\n  private _hasValue = false\n  private _error: Error | null = null\n  private equalsFn: EqualityFunction<T>\n  private options: ComputedOptions<T>\n\n  constructor(fn: () => T, options: ComputedOptions<T> = {}, owner = getCurrentOwner()) {\n    super(fn, owner)\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.equalsFn = options.equals ?? defaultEquals\n    this.options = options\n  }\n\n  /**\n   * Get the computed value, tracking dependency and lazily computing\n   */\n  getValue(): T {\n    // Track this computed as a dependency if we're in a reactive context\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n\n    // Compute value if needed\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n\n    return this.value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n    return this.value\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Execute the computation and notify observers\n   */\n  execute(): T {\n    const previousValue = this._hasValue ? this.value : undefined\n    const result = super.execute()\n\n    // Only notify observers if the value actually changed\n    if (!this._hasValue || !this.equalsFn(previousValue, result)) {\n      // Notify dependent computations\n      for (const observer of this.observers) {\n        if (observer.state !== ComputationState.Disposed) {\n          observer.state = ComputationState.Dirty\n          // Use the signal's scheduling mechanism for consistency\n          if ('execute' in observer && typeof observer.execute === 'function') {\n            queueMicrotask(() => {\n              if (observer.state === ComputationState.Dirty) {\n                observer.execute()\n              }\n            })\n          }\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Notify method for ReactiveNode compatibility\n   */\n  notify(): void {\n    // For computations, notify means execute\n    this.execute()\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    // Complete bidirectional cleanup\n    for (const source of this.sources) {\n      if ('removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    this._hasValue = false\n    this._error = null\n    this.state = ComputationState.Disposed\n  }\n\n  /**\n   * Dispose the computed value\n   */\n  dispose(): void {\n    this.cleanup()\n    super.dispose()\n  }\n\n  /**\n   * Debug information\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      value: this._hasValue ? this.value : undefined,\n      hasValue: this._hasValue,\n      error: this._error?.message,\n      state: this.state,\n      sourceCount: this.sources.size,\n      observerCount: this.observers.size,\n      priority: UpdatePriority[this.priority],\n      debugName: this.options.debugName,\n      equalsFn: this.equalsFn.name || 'anonymous',\n    }\n  }\n\n  toString(): string {\n    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : 'no value'}`\n  }\n}\n\n/**\n * Create a computed value that automatically updates when dependencies change\n *\n * @param fn The computation function\n * @param options Configuration options for the computed value\n * @returns An accessor function for the computed value\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n * const doubleCount = createComputed(() => count() * 2, {\n *   debugName: 'doubleCounter',\n *   onError: (error) => {\n *     console.error('Computation failed:', error)\n *     return 0 // fallback value\n *   }\n * })\n *\n * console.log(doubleCount()) // 0\n * setCount(5)\n * console.log(doubleCount()) // 10\n * ```\n */\nexport function createComputed<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  const computed = new ComputedImpl(fn, options)\n\n  // Create bound accessor with peek method - this is already a Signal<T>\n  const accessor = computed.getValue.bind(computed) as Signal<T>\n  accessor.peek = computed.peek.bind(computed)\n\n  // Add debug information\n  Object.defineProperty(accessor, Symbol.for('tachui.computed'), {\n    value: computed,\n    enumerable: false,\n  })\n\n  return accessor\n}\n\n/**\n * Create a memo (alias for createComputed for SolidJS compatibility)\n */\nexport function createMemo<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  return createComputed(fn, options)\n}\n\n/**\n * Type guard to check if a value is a computed\n */\nexport function isComputed<T = any>(value: any): value is Signal<T> {\n  return typeof value === 'function' && Symbol.for('tachui.computed') in value\n}\n\n/**\n * Get the underlying computed implementation for debugging\n */\nexport function getComputedImpl<T>(computed: Signal<T>): ComputedImpl<T> | null {\n  return (computed as any)[Symbol.for('tachui.computed')] || null\n}\n\n/**\n * Create a computed value with explicit dependency tracking\n *\n * @param fn The computation function\n * @param deps Explicit dependencies (optional)\n * @returns An accessor function for the computed value\n */\nexport function createDerivedSignal<T>(fn: () => T, deps?: (() => any)[]): Signal<T> {\n  if (!deps) {\n    return createComputed(fn)\n  }\n\n  // Wrap function to explicitly track dependencies\n  const wrappedFn = () => {\n    // Read all dependencies to track them\n    for (const dep of deps) {\n      dep()\n    }\n    return fn()\n  }\n\n  return createComputed(wrappedFn)\n}\n\n/**\n * Create a computed value that only updates when a condition is met\n *\n * @param fn The computation function\n * @param when Condition function that must return true for updates\n * @returns An accessor function for the computed value\n */\nexport function createConditionalComputed<T>(fn: () => T, when: () => boolean): Signal<T> {\n  let lastValue: T\n  let hasValue = false\n\n  return createComputed(() => {\n    if (when()) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    if (!hasValue) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    return lastValue\n  })\n}\n\n/**\n * Public Computed type export\n */\nexport type Computed<T> = Signal<T>\n"],"names":["ComputedImpl","ComputationImpl","fn","options","owner","getCurrentOwner","__publicField","UpdatePriority","defaultEquals","computation","getCurrentComputation","ComputationState","previousValue","result","observer","source","createComputed","computed","accessor","createMemo","isComputed","value","getComputedImpl","createDerivedSignal","deps","dep","createConditionalComputed","when","lastValue","hasValue"],"mappings":";;;;;AAuBA,MAAMA,UAAwBC,EAAwC;AAAA,EASpE,YAAYC,GAAaC,IAA8B,CAAA,GAAIC,IAAQC,KAAmB;AACpF,UAAMH,GAAIE,CAAK,GATjBE,EAAA,MAAS,QAAO,UAAA,GAChBA,EAAA,MAAS,UAAA,GAETA,EAAA,MAAQ,aAAY,EAAA,GACpBA,EAAA,MAAQ,UAAuB,IAAA,GAC/BA,EAAA,MAAQ,UAAA,GACRA,EAAA,MAAQ,SAAA,GAIN,KAAK,WAAWH,EAAQ,YAAYI,EAAe,QACnD,KAAK,WAAWJ,EAAQ,UAAUK,GAClC,KAAK,UAAUL;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKA,WAAc;AAEZ,UAAMM,IAAcC,EAAA;AACpB,WAAID,KAAeA,EAAY,UAAUE,EAAiB,aACxD,KAAK,UAAU,IAAIF,CAAW,GAC9BA,EAAY,QAAQ,IAAI,IAAI,KAI1B,KAAK,UAAUE,EAAiB,SAAS,CAAC,KAAK,eACjD,KAAK,QAAA,GACL,KAAK,YAAY,KAGZ,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,OAAU;AACR,YAAI,KAAK,UAAUA,EAAiB,SAAS,CAAC,KAAK,eACjD,KAAK,QAAA,GACL,KAAK,YAAY,KAEZ,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,eAAeF,GAAgC;AAC7C,SAAK,UAAU,OAAOA,CAAW;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,UAAa;AACX,UAAMG,IAAgB,KAAK,YAAY,KAAK,QAAQ,QAC9CC,IAAS,MAAM,QAAA;AAGrB,QAAI,CAAC,KAAK,aAAa,CAAC,KAAK,SAASD,GAAeC,CAAM;AAEzD,iBAAWC,KAAY,KAAK;AAC1B,QAAIA,EAAS,UAAUH,EAAiB,aACtCG,EAAS,QAAQH,EAAiB,OAE9B,aAAaG,KAAY,OAAOA,EAAS,WAAY,cACvD,eAAe,MAAM;AACnB,UAAIA,EAAS,UAAUH,EAAiB,SACtCG,EAAS,QAAA;AAAA,QAEb,CAAC;AAMT,WAAOD;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,SAAe;AAEb,SAAK,QAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AAEd,eAAWE,KAAU,KAAK;AACxB,MAAI,oBAAoBA,KACpBA,EAAe,eAAe,IAAI;AAGxC,SAAK,QAAQ,MAAA;AAEb,eAAWD,KAAY,KAAK;AAC1B,MAAAA,EAAS,QAAQ,OAAO,IAAI;AAE9B,SAAK,UAAU,MAAA,GAEf,KAAK,YAAY,IACjB,KAAK,SAAS,MACd,KAAK,QAAQH,EAAiB;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AACd,SAAK,QAAA,GACL,MAAM,QAAA;AAAA,EACR;AAAA;AAAA;AAAA;AAAA,EAKA,CAAC,OAAO,IAAI,cAAc,CAAC,IAAY;AACrC,WAAO;AAAA,MACL,IAAI,KAAK;AAAA,MACT,MAAM,KAAK;AAAA,MACX,OAAO,KAAK,YAAY,KAAK,QAAQ;AAAA,MACrC,UAAU,KAAK;AAAA,MACf,OAAO,KAAK,QAAQ;AAAA,MACpB,OAAO,KAAK;AAAA,MACZ,aAAa,KAAK,QAAQ;AAAA,MAC1B,eAAe,KAAK,UAAU;AAAA,MAC9B,UAAUJ,EAAe,KAAK,QAAQ;AAAA,MACtC,WAAW,KAAK,QAAQ;AAAA,MACxB,UAAU,KAAK,SAAS,QAAQ;AAAA,IAAA;AAAA,EAEpC;AAAA,EAEA,WAAmB;AACjB,WAAO,YAAY,KAAK,QAAQ,aAAa,KAAK,EAAE,MAAM,KAAK,YAAY,KAAK,QAAQ,UAAU;AAAA,EACpG;AACF;AAyBO,SAASS,EAAkBd,GAAaC,GAAyC;AACtF,QAAMc,IAAW,IAAIjB,EAAaE,GAAIC,CAAO,GAGvCe,IAAWD,EAAS,SAAS,KAAKA,CAAQ;AAChD,SAAAC,EAAS,OAAOD,EAAS,KAAK,KAAKA,CAAQ,GAG3C,OAAO,eAAeC,GAAU,OAAO,IAAI,iBAAiB,GAAG;AAAA,IAC7D,OAAOD;AAAA,IACP,YAAY;AAAA,EAAA,CACb,GAEMC;AACT;AAKO,SAASC,EAAcjB,GAAaC,GAAyC;AAClF,SAAOa,EAAed,GAAIC,CAAO;AACnC;AAKO,SAASiB,EAAoBC,GAAgC;AAClE,SAAO,OAAOA,KAAU,cAAc,OAAO,IAAI,iBAAiB,KAAKA;AACzE;AAKO,SAASC,EAAmBL,GAA6C;AAC9E,SAAQA,EAAiB,OAAO,IAAI,iBAAiB,CAAC,KAAK;AAC7D;AASO,SAASM,EAAuBrB,GAAasB,GAAiC;AACnF,SAaOR,EAbFQ,IAKa,MAAM;AAEtB,eAAWC,KAAOD;AAChB,MAAAC,EAAA;AAEF,WAAOvB,EAAA;AAAA,EACT,IAVwBA,CAYO;AACjC;AASO,SAASwB,EAA6BxB,GAAayB,GAAgC;AACxF,MAAIC,GACAC,IAAW;AAEf,SAAOb,EAAe,OAChBW,QACFC,IAAY1B,EAAA,GACZ2B,IAAW,KAGRA,MACHD,IAAY1B,EAAA,GACZ2B,IAAW,KAGND,EACR;AACH;"}

package/dist/reactive/context.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("./types.cjs");var p=Object.defineProperty,f=(r,t,e)=>t in r?p(r,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[t]=e,s=(r,t,e)=>f(r,typeof t!="symbol"?t+"":t,e);let a=0,h=0,o=null,n=null,i=!1;function d(){return o}function m(){return n}function C(){return i}class v{constructor(t=null){s(this,"id"),s(this,"parent"),s(this,"context",new Map),s(this,"cleanups",[]),s(this,"sources",new Set),s(this,"disposed",!1),this.id=++h,this.parent=t}dispose(){if(!this.disposed){this.disposed=!0;for(const t of this.sources)t.dispose();this.sources.clear();for(const t of this.cleanups)try{t()}catch(e){console.error("Error in cleanup function:",e)}this.cleanups.length=0,this.parent&&!this.parent.disposed&&this.parent.sources.delete(this)}}}class l{constructor(t,e=null){s(this,"id"),s(this,"owner"),s(this,"fn"),s(this,"sources",new Set),s(this,"observers",new Set),s(this,"state",u.ComputationState.Dirty),s(this,"value"),this.id=++a,this.fn=t,this.owner=e,e&&!e.disposed&&e.sources.add(this)}execute(){if(this.state===u.ComputationState.Disposed)return this.value;for(const e of this.sources)e&&typeof e=="object"&&"removeObserver"in e&&e.removeObserver(this);this.sources.clear();const t=o;o=this;try{return this.state=u.ComputationState.Clean,this.value=this.fn(),this.value}catch(e){throw this.state=u.ComputationState.Disposed,(typeof process>"u"||process.env.NODE_ENV!=="test")&&console.error("Error in computation:",e),e}finally{o=t}}dispose(){if(this.state!==u.ComputationState.Disposed){this.state=u.ComputationState.Disposed;for(const t of this.sources)t&&typeof t=="object"&&"removeObserver"in t&&t.removeObserver(this);this.sources.clear();for(const t of this.observers)t.sources.delete(this);this.observers.clear(),this.owner&&!this.owner.disposed&&this.owner.sources.delete(this)}}}function w(r){const t=new v(n),e=n;n=t;try{return r(()=>t.dispose())}finally{n=e}}function g(r,t){const e=n;n=r;try{return t()}finally{n=e}}function b(){return n}let c=null;function O(r){c=r}function y(r){if(i)return r();const t=i;i=!0;try{const e=r();return!t&&c&&c(),e}finally{i=t}}function S(r){const t=o;o=null;try{return r()}finally{o=t}}function D(r,t){const e=new l(r,t||n);return e.execute(),e}function B(){return{computation:o,batch:i}}const _={getCurrentComputation:()=>o,getCurrentOwner:()=>n,getComputationCount:()=>a,getOwnerCount:()=>h,isBatching:()=>i};exports.ComputationImpl=l;exports.DEBUG=_;exports.batch=y;exports.createComputation=D;exports.createRoot=w;exports.getCurrentComputation=d;exports.getCurrentOwner=m;exports.getOwner=b;exports.getReactiveContext=B;exports.isBatchingUpdates=C;exports.runWithOwner=g;exports.setFlushFunction=O;exports.untrack=S;
+//# sourceMappingURL=context.cjs.map

package/dist/reactive/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","sources":["../../src/reactive/context.ts"],"sourcesContent":["/**\n * Reactive context and computation management\n *\n * Manages the reactive execution context, dependency tracking,\n * and computation lifecycle.\n */\n\nimport type { CleanupFunction, Computation, Owner, ReactiveContext } from './types'\nimport { ComputationState } from './types'\n\nlet computationIdCounter = 0\nlet ownerIdCounter = 0\n\n/**\n * Global reactive context\n */\nlet currentComputation: Computation | null = null\nlet currentOwner: Owner | null = null\nlet isBatching = false\n\n/**\n * Get the current computation context\n */\nexport function getCurrentComputation(): Computation | null {\n  return currentComputation\n}\n\n/**\n * Get the current owner context\n */\nexport function getCurrentOwner(): Owner | null {\n  return currentOwner\n}\n\n/**\n * Check if we're currently batching updates\n */\nexport function isBatchingUpdates(): boolean {\n  return isBatching\n}\n\n/**\n * Owner implementation for managing cleanup and context\n */\nclass OwnerImpl implements Owner {\n  readonly id: number\n  readonly parent: Owner | null\n  readonly context = new Map<symbol, any>()\n  readonly cleanups: CleanupFunction[] = []\n  readonly sources = new Set<Computation>()\n  disposed = false\n\n  constructor(parent: Owner | null = null) {\n    this.id = ++ownerIdCounter\n    this.parent = parent\n  }\n\n  dispose(): void {\n    if (this.disposed) return\n\n    this.disposed = true\n\n    // Dispose all child computations\n    for (const computation of this.sources) {\n      computation.dispose()\n    }\n    this.sources.clear()\n\n    // Run cleanup functions\n    for (const cleanup of this.cleanups) {\n      try {\n        cleanup()\n      } catch (error) {\n        console.error('Error in cleanup function:', error)\n      }\n    }\n    this.cleanups.length = 0\n\n    // Remove from parent\n    if (this.parent && !this.parent.disposed) {\n      this.parent.sources.delete(this as any)\n    }\n  }\n}\n\n/**\n * Computation implementation\n */\nexport class ComputationImpl implements Computation {\n  readonly id: number\n  readonly owner: Owner | null\n  readonly fn: () => any\n  readonly sources = new Set<any>() // Signals this computation depends on\n  readonly observers = new Set<Computation>() // Computations that depend on this\n  state = ComputationState.Dirty\n  value: any = undefined\n\n  constructor(fn: () => any, owner: Owner | null = null) {\n    this.id = ++computationIdCounter\n    this.fn = fn\n    this.owner = owner\n\n    if (owner && !owner.disposed) {\n      owner.sources.add(this)\n    }\n  }\n\n  execute(): any {\n    if (this.state === ComputationState.Disposed) {\n      return this.value\n    }\n\n    // Clean up old dependencies\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    const prevComputation = currentComputation\n    currentComputation = this\n\n    try {\n      this.state = ComputationState.Clean\n      this.value = this.fn()\n      return this.value\n    } catch (error) {\n      this.state = ComputationState.Disposed\n      // Don't suppress errors - let them propagate for proper error handling\n      // Only log in non-test environments to avoid polluting test output\n      if (typeof process === 'undefined' || process.env.NODE_ENV !== 'test') {\n        console.error('Error in computation:', error)\n      }\n      throw error\n    } finally {\n      currentComputation = prevComputation\n    }\n  }\n\n  dispose(): void {\n    if (this.state === ComputationState.Disposed) return\n\n    this.state = ComputationState.Disposed\n\n    // Remove from all sources\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    // Notify observers that this computation is disposed\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    // Remove from owner\n    if (this.owner && !this.owner.disposed) {\n      this.owner.sources.delete(this)\n    }\n  }\n}\n\n/**\n * Create a new reactive computation root\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const owner = new OwnerImpl(currentOwner)\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn(() => owner.dispose())\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Run a function with a specific owner context\n */\nexport function runWithOwner<T>(owner: Owner | null, fn: () => T): T {\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn()\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Get the current owner context\n */\nexport function getOwner(): Owner | null {\n  return currentOwner\n}\n\n// Global flush function reference\nlet flushFunction: (() => void) | null = null\n\n/**\n * Set the flush function (called by signal module)\n */\nexport function setFlushFunction(fn: () => void): void {\n  flushFunction = fn\n}\n\n/**\n * Batch multiple updates together\n */\nexport function batch<T>(fn: () => T): T {\n  if (isBatching) {\n    return fn()\n  }\n\n  const wasBatching = isBatching\n  isBatching = true\n\n  try {\n    const result = fn()\n    // Flush updates after batch completes\n    if (!wasBatching && flushFunction) {\n      flushFunction()\n    }\n    return result\n  } finally {\n    isBatching = wasBatching\n  }\n}\n\n/**\n * Read a signal without tracking dependency\n */\nexport function untrack<T>(fn: () => T): T {\n  const prevComputation = currentComputation\n  currentComputation = null\n\n  try {\n    return fn()\n  } finally {\n    currentComputation = prevComputation\n  }\n}\n\n/**\n * Add cleanup function to current owner\n */\nexport function onCleanup(fn: CleanupFunction): void {\n  if (currentOwner && !currentOwner.disposed) {\n    currentOwner.cleanups.push(fn)\n  }\n}\n\n/**\n * Create a computation that runs immediately and tracks dependencies\n */\nexport function createComputation<T>(fn: () => T, owner?: Owner): ComputationImpl {\n  const computation = new ComputationImpl(fn, owner || currentOwner)\n  computation.execute()\n  return computation\n}\n\n/**\n * Get reactive context information\n */\nexport function getReactiveContext(): ReactiveContext {\n  return {\n    computation: currentComputation,\n    batch: isBatching,\n  }\n}\n\n/**\n * Debug utilities\n */\nexport const DEBUG = {\n  getCurrentComputation: () => currentComputation,\n  getCurrentOwner: () => currentOwner,\n  getComputationCount: () => computationIdCounter,\n  getOwnerCount: () => ownerIdCounter,\n  isBatching: () => isBatching,\n}\n"],"names":["computationIdCounter","ownerIdCounter","currentComputation","currentOwner","isBatching","getCurrentComputation","getCurrentOwner","isBatchingUpdates","OwnerImpl","parent","__publicField","computation","cleanup","error","ComputationImpl","fn","owner","ComputationState","source","prevComputation","observer","createRoot","prevOwner","runWithOwner","getOwner","flushFunction","setFlushFunction","batch","wasBatching","result","untrack","createComputation","getReactiveContext","DEBUG"],"mappings":"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"}

package/dist/reactive/context.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Reactive context and computation management
+ *
+ * Manages the reactive execution context, dependency tracking,
+ * and computation lifecycle.
+ */
+import type { CleanupFunction, Computation, Owner, ReactiveContext } from './types';
+import { ComputationState } from './types';
+/**
+ * Get the current computation context
+ */
+export declare function getCurrentComputation(): Computation | null;
+/**
+ * Get the current owner context
+ */
+export declare function getCurrentOwner(): Owner | null;
+/**
+ * Check if we're currently batching updates
+ */
+export declare function isBatchingUpdates(): boolean;
+/**
+ * Computation implementation
+ */
+export declare class ComputationImpl implements Computation {
+    readonly id: number;
+    readonly owner: Owner | null;
+    readonly fn: () => any;
+    readonly sources: Set<any>;
+    readonly observers: Set<Computation>;
+    state: ComputationState;
+    value: any;
+    constructor(fn: () => any, owner?: Owner | null);
+    execute(): any;
+    dispose(): void;
+}
+/**
+ * Create a new reactive computation root
+ */
+export declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+/**
+ * Run a function with a specific owner context
+ */
+export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
+/**
+ * Get the current owner context
+ */
+export declare function getOwner(): Owner | null;
+/**
+ * Set the flush function (called by signal module)
+ */
+export declare function setFlushFunction(fn: () => void): void;
+/**
+ * Batch multiple updates together
+ */
+export declare function batch<T>(fn: () => T): T;
+/**
+ * Read a signal without tracking dependency
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Add cleanup function to current owner
+ */
+export declare function onCleanup(fn: CleanupFunction): void;
+/**
+ * Create a computation that runs immediately and tracks dependencies
+ */
+export declare function createComputation<T>(fn: () => T, owner?: Owner): ComputationImpl;
+/**
+ * Get reactive context information
+ */
+export declare function getReactiveContext(): ReactiveContext;
+/**
+ * Debug utilities
+ */
+export declare const DEBUG: {
+    getCurrentComputation: () => Computation | null;
+    getCurrentOwner: () => Owner | null;
+    getComputationCount: () => number;
+    getOwnerCount: () => number;
+    isBatching: () => boolean;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/reactive/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/reactive/context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAY1C;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,WAAW,GAAG,IAAI,CAE1D;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,KAAK,GAAG,IAAI,CAE9C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AA8CD;;GAEG;AACH,qBAAa,eAAgB,YAAW,WAAW;IACjD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,CAAA;IACtB,QAAQ,CAAC,OAAO,WAAiB;IACjC,QAAQ,CAAC,SAAS,mBAAyB;IAC3C,KAAK,mBAAyB;IAC9B,KAAK,EAAE,GAAG,CAAY;gBAEV,EAAE,EAAE,MAAM,GAAG,EAAE,KAAK,GAAE,KAAK,GAAG,IAAW;IAUrD,OAAO,IAAI,GAAG;IAiCd,OAAO,IAAI,IAAI;CAwBhB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAU/D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CASnE;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI,KAAK,GAAG,IAAI,CAEvC;AAKD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAErD;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAkBvC;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CASzC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAInD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,eAAe,CAIhF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAKpD;AAED;;GAEG;AACH,eAAO,MAAM,KAAK;;;;;;CAMjB,CAAA"}

package/dist/reactive/context.js

@@ -0,0 +1,143 @@
+import { ComputationState as u } from "./types.js";
+var l = Object.defineProperty, p = (r, t, e) => t in r ? l(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, s = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
+let a = 0, h = 0, o = null, n = null, i = !1;
+function v() {
+  return o;
+}
+function w() {
+  return n;
+}
+function C() {
+  return i;
+}
+class f {
+  constructor(t = null) {
+    s(this, "id"), s(this, "parent"), s(this, "context", /* @__PURE__ */ new Map()), s(this, "cleanups", []), s(this, "sources", /* @__PURE__ */ new Set()), s(this, "disposed", !1), this.id = ++h, this.parent = t;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0;
+      for (const t of this.sources)
+        t.dispose();
+      this.sources.clear();
+      for (const t of this.cleanups)
+        try {
+          t();
+        } catch (e) {
+          console.error("Error in cleanup function:", e);
+        }
+      this.cleanups.length = 0, this.parent && !this.parent.disposed && this.parent.sources.delete(this);
+    }
+  }
+}
+class d {
+  constructor(t, e = null) {
+    s(this, "id"), s(this, "owner"), s(this, "fn"), s(this, "sources", /* @__PURE__ */ new Set()), s(this, "observers", /* @__PURE__ */ new Set()), s(this, "state", u.Dirty), s(this, "value"), this.id = ++a, this.fn = t, this.owner = e, e && !e.disposed && e.sources.add(this);
+  }
+  execute() {
+    if (this.state === u.Disposed)
+      return this.value;
+    for (const e of this.sources)
+      e && typeof e == "object" && "removeObserver" in e && e.removeObserver(this);
+    this.sources.clear();
+    const t = o;
+    o = this;
+    try {
+      return this.state = u.Clean, this.value = this.fn(), this.value;
+    } catch (e) {
+      throw this.state = u.Disposed, (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error in computation:", e), e;
+    } finally {
+      o = t;
+    }
+  }
+  dispose() {
+    if (this.state !== u.Disposed) {
+      this.state = u.Disposed;
+      for (const t of this.sources)
+        t && typeof t == "object" && "removeObserver" in t && t.removeObserver(this);
+      this.sources.clear();
+      for (const t of this.observers)
+        t.sources.delete(this);
+      this.observers.clear(), this.owner && !this.owner.disposed && this.owner.sources.delete(this);
+    }
+  }
+}
+function b(r) {
+  const t = new f(n), e = n;
+  n = t;
+  try {
+    return r(() => t.dispose());
+  } finally {
+    n = e;
+  }
+}
+function O(r, t) {
+  const e = n;
+  n = r;
+  try {
+    return t();
+  } finally {
+    n = e;
+  }
+}
+function g() {
+  return n;
+}
+let c = null;
+function y(r) {
+  c = r;
+}
+function D(r) {
+  if (i)
+    return r();
+  const t = i;
+  i = !0;
+  try {
+    const e = r();
+    return !t && c && c(), e;
+  } finally {
+    i = t;
+  }
+}
+function _(r) {
+  const t = o;
+  o = null;
+  try {
+    return r();
+  } finally {
+    o = t;
+  }
+}
+function x(r, t) {
+  const e = new d(r, t || n);
+  return e.execute(), e;
+}
+function B() {
+  return {
+    computation: o,
+    batch: i
+  };
+}
+const E = {
+  getCurrentComputation: () => o,
+  getCurrentOwner: () => n,
+  getComputationCount: () => a,
+  getOwnerCount: () => h,
+  isBatching: () => i
+};
+export {
+  d as ComputationImpl,
+  E as DEBUG,
+  D as batch,
+  x as createComputation,
+  b as createRoot,
+  v as getCurrentComputation,
+  w as getCurrentOwner,
+  g as getOwner,
+  B as getReactiveContext,
+  C as isBatchingUpdates,
+  O as runWithOwner,
+  y as setFlushFunction,
+  _ as untrack
+};
+//# sourceMappingURL=context.js.map

package/dist/reactive/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sources":["../../src/reactive/context.ts"],"sourcesContent":["/**\n * Reactive context and computation management\n *\n * Manages the reactive execution context, dependency tracking,\n * and computation lifecycle.\n */\n\nimport type { CleanupFunction, Computation, Owner, ReactiveContext } from './types'\nimport { ComputationState } from './types'\n\nlet computationIdCounter = 0\nlet ownerIdCounter = 0\n\n/**\n * Global reactive context\n */\nlet currentComputation: Computation | null = null\nlet currentOwner: Owner | null = null\nlet isBatching = false\n\n/**\n * Get the current computation context\n */\nexport function getCurrentComputation(): Computation | null {\n  return currentComputation\n}\n\n/**\n * Get the current owner context\n */\nexport function getCurrentOwner(): Owner | null {\n  return currentOwner\n}\n\n/**\n * Check if we're currently batching updates\n */\nexport function isBatchingUpdates(): boolean {\n  return isBatching\n}\n\n/**\n * Owner implementation for managing cleanup and context\n */\nclass OwnerImpl implements Owner {\n  readonly id: number\n  readonly parent: Owner | null\n  readonly context = new Map<symbol, any>()\n  readonly cleanups: CleanupFunction[] = []\n  readonly sources = new Set<Computation>()\n  disposed = false\n\n  constructor(parent: Owner | null = null) {\n    this.id = ++ownerIdCounter\n    this.parent = parent\n  }\n\n  dispose(): void {\n    if (this.disposed) return\n\n    this.disposed = true\n\n    // Dispose all child computations\n    for (const computation of this.sources) {\n      computation.dispose()\n    }\n    this.sources.clear()\n\n    // Run cleanup functions\n    for (const cleanup of this.cleanups) {\n      try {\n        cleanup()\n      } catch (error) {\n        console.error('Error in cleanup function:', error)\n      }\n    }\n    this.cleanups.length = 0\n\n    // Remove from parent\n    if (this.parent && !this.parent.disposed) {\n      this.parent.sources.delete(this as any)\n    }\n  }\n}\n\n/**\n * Computation implementation\n */\nexport class ComputationImpl implements Computation {\n  readonly id: number\n  readonly owner: Owner | null\n  readonly fn: () => any\n  readonly sources = new Set<any>() // Signals this computation depends on\n  readonly observers = new Set<Computation>() // Computations that depend on this\n  state = ComputationState.Dirty\n  value: any = undefined\n\n  constructor(fn: () => any, owner: Owner | null = null) {\n    this.id = ++computationIdCounter\n    this.fn = fn\n    this.owner = owner\n\n    if (owner && !owner.disposed) {\n      owner.sources.add(this)\n    }\n  }\n\n  execute(): any {\n    if (this.state === ComputationState.Disposed) {\n      return this.value\n    }\n\n    // Clean up old dependencies\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    const prevComputation = currentComputation\n    currentComputation = this\n\n    try {\n      this.state = ComputationState.Clean\n      this.value = this.fn()\n      return this.value\n    } catch (error) {\n      this.state = ComputationState.Disposed\n      // Don't suppress errors - let them propagate for proper error handling\n      // Only log in non-test environments to avoid polluting test output\n      if (typeof process === 'undefined' || process.env.NODE_ENV !== 'test') {\n        console.error('Error in computation:', error)\n      }\n      throw error\n    } finally {\n      currentComputation = prevComputation\n    }\n  }\n\n  dispose(): void {\n    if (this.state === ComputationState.Disposed) return\n\n    this.state = ComputationState.Disposed\n\n    // Remove from all sources\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    // Notify observers that this computation is disposed\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    // Remove from owner\n    if (this.owner && !this.owner.disposed) {\n      this.owner.sources.delete(this)\n    }\n  }\n}\n\n/**\n * Create a new reactive computation root\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const owner = new OwnerImpl(currentOwner)\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn(() => owner.dispose())\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Run a function with a specific owner context\n */\nexport function runWithOwner<T>(owner: Owner | null, fn: () => T): T {\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn()\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Get the current owner context\n */\nexport function getOwner(): Owner | null {\n  return currentOwner\n}\n\n// Global flush function reference\nlet flushFunction: (() => void) | null = null\n\n/**\n * Set the flush function (called by signal module)\n */\nexport function setFlushFunction(fn: () => void): void {\n  flushFunction = fn\n}\n\n/**\n * Batch multiple updates together\n */\nexport function batch<T>(fn: () => T): T {\n  if (isBatching) {\n    return fn()\n  }\n\n  const wasBatching = isBatching\n  isBatching = true\n\n  try {\n    const result = fn()\n    // Flush updates after batch completes\n    if (!wasBatching && flushFunction) {\n      flushFunction()\n    }\n    return result\n  } finally {\n    isBatching = wasBatching\n  }\n}\n\n/**\n * Read a signal without tracking dependency\n */\nexport function untrack<T>(fn: () => T): T {\n  const prevComputation = currentComputation\n  currentComputation = null\n\n  try {\n    return fn()\n  } finally {\n    currentComputation = prevComputation\n  }\n}\n\n/**\n * Add cleanup function to current owner\n */\nexport function onCleanup(fn: CleanupFunction): void {\n  if (currentOwner && !currentOwner.disposed) {\n    currentOwner.cleanups.push(fn)\n  }\n}\n\n/**\n * Create a computation that runs immediately and tracks dependencies\n */\nexport function createComputation<T>(fn: () => T, owner?: Owner): ComputationImpl {\n  const computation = new ComputationImpl(fn, owner || currentOwner)\n  computation.execute()\n  return computation\n}\n\n/**\n * Get reactive context information\n */\nexport function getReactiveContext(): ReactiveContext {\n  return {\n    computation: currentComputation,\n    batch: isBatching,\n  }\n}\n\n/**\n * Debug utilities\n */\nexport const DEBUG = {\n  getCurrentComputation: () => currentComputation,\n  getCurrentOwner: () => currentOwner,\n  getComputationCount: () => computationIdCounter,\n  getOwnerCount: () => ownerIdCounter,\n  isBatching: () => isBatching,\n}\n"],"names":["computationIdCounter","ownerIdCounter","currentComputation","currentOwner","isBatching","getCurrentComputation","getCurrentOwner","isBatchingUpdates","OwnerImpl","parent","__publicField","computation","cleanup","error","ComputationImpl","fn","owner","ComputationState","source","prevComputation","observer","createRoot","prevOwner","runWithOwner","getOwner","flushFunction","setFlushFunction","batch","wasBatching","result","untrack","createComputation","getReactiveContext","DEBUG"],"mappings":"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"}

package/dist/reactive/effect.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./context.cjs");function a(e,t={}){const u=s.getCurrentOwner();let r,n=!0;const o=()=>{const f=e(r);return n&&(n=!1),r=f,f},c=new s.ComputationImpl(o,u);return t.name&&Object.defineProperty(c,"name",{value:t.name,enumerable:!1}),c.execute(),c}function l(e,t={}){const u=s.getCurrentOwner();let r,n=!1;const o=()=>{if(!n)return n=!0,e(r);const f=e(r);return r=f,f},c=new s.ComputationImpl(o,u);return t.name&&Object.defineProperty(c,"name",{value:t.name,enumerable:!1}),c.execute(),c}function m(e,t={}){const u=s.getCurrentOwner(),r=()=>{const o=e(void 0);return n.dispose(),o},n=new s.ComputationImpl(r,u);return t.name&&Object.defineProperty(n,"name",{value:`${t.name}(once)`,enumerable:!1}),n.execute(),n}function d(e,t={}){return a(e,{...t,name:`${t.name||"sync"}(sync)`})}function p(e){e.dispose()}function i(e){return e.state===3}function E(e){return{id:e.id,name:e.name||"anonymous",state:e.state,sourceCount:e.sources.size,observerCount:e.observers.size,disposed:i(e),type:"Effect"}}exports.createEffect=a;exports.createOnceEffect=m;exports.createRenderEffect=l;exports.createSyncEffect=d;exports.disposeEffect=p;exports.getEffectInfo=E;exports.isEffectDisposed=i;
+//# sourceMappingURL=effect.cjs.map

package/dist/reactive/effect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.cjs","sources":["../../src/reactive/effect.ts"],"sourcesContent":["/**\n * Effect implementation for side effects in reactive system\n *\n * Effects run when their dependencies change, enabling reactive\n * side effects like DOM updates, logging, API calls, etc.\n */\n\nimport { ComputationImpl, getCurrentOwner } from './context'\nimport type { EffectFunction, EffectOptions } from './types'\n\n/**\n * Effect function type\n */\nexport type Effect = ComputationImpl\n\n/**\n * Create a reactive effect that runs when dependencies change\n *\n * @param fn The effect function to run\n * @param options Effect configuration options\n * @returns The effect computation\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * createEffect(() => {\n *   console.log('Count changed:', count())\n * })\n *\n * setCount(5) // Logs: \"Count changed: 5\"\n * ```\n */\nexport function createEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  const owner = getCurrentOwner()\n\n  let previousValue: T | undefined\n  let isFirst = true\n\n  const effectFn = () => {\n    const nextValue = fn(previousValue)\n\n    if (!isFirst) {\n      previousValue = nextValue\n    } else {\n      isFirst = false\n      previousValue = nextValue\n    }\n\n    return nextValue\n  }\n\n  // Create the computation\n  const effect = new ComputationImpl(effectFn, owner)\n\n  // Add debug name if provided\n  if (options.name) {\n    Object.defineProperty(effect, 'name', {\n      value: options.name,\n      enumerable: false,\n    })\n  }\n\n  // Execute immediately to establish dependencies\n  effect.execute()\n\n  return effect\n}\n\n/**\n * Create an effect that only runs after dependencies change (not on first run)\n *\n * @param fn The effect function to run\n * @param options Effect configuration options\n * @returns The effect computation\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * createRenderEffect(() => {\n *   // This won't run immediately, only when count changes\n *   document.title = `Count: ${count()}`\n * })\n * ```\n */\nexport function createRenderEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  const owner = getCurrentOwner()\n\n  let previousValue: T | undefined\n  let hasRun = false\n\n  const effectFn = () => {\n    if (!hasRun) {\n      hasRun = true\n      // Track dependencies but don't run the effect\n      return fn(previousValue)\n    }\n\n    const nextValue = fn(previousValue)\n    previousValue = nextValue\n    return nextValue\n  }\n\n  const effect = new ComputationImpl(effectFn, owner)\n\n  if (options.name) {\n    Object.defineProperty(effect, 'name', {\n      value: options.name,\n      enumerable: false,\n    })\n  }\n\n  // Execute to establish dependencies but not run the actual effect\n  effect.execute()\n\n  return effect\n}\n\n/**\n * Create a one-time effect that disposes itself after first execution\n *\n * @param fn The effect function to run once\n * @param options Effect configuration options\n * @returns The effect computation\n */\nexport function createOnceEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  const owner = getCurrentOwner()\n\n  const effectFn = () => {\n    const result = fn(undefined)\n    // Dispose the effect after first run\n    effect.dispose()\n    return result\n  }\n\n  const effect = new ComputationImpl(effectFn, owner)\n\n  if (options.name) {\n    Object.defineProperty(effect, 'name', {\n      value: `${options.name}(once)`,\n      enumerable: false,\n    })\n  }\n\n  effect.execute()\n\n  return effect\n}\n\n/**\n * Create an effect that runs synchronously (not batched)\n *\n * @param fn The effect function to run\n * @param options Effect configuration options\n * @returns The effect computation\n */\nexport function createSyncEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  // TODO: Implement synchronous execution\n  // For now, use regular effect\n  return createEffect(fn, { ...options, name: `${options.name || 'sync'}(sync)` })\n}\n\n/**\n * Dispose an effect\n */\nexport function disposeEffect(effect: Effect): void {\n  effect.dispose()\n}\n\n/**\n * Check if an effect is disposed\n */\nexport function isEffectDisposed(effect: Effect): boolean {\n  return effect.state === 3 // ComputationState.Disposed\n}\n\n/**\n * Get effect debug information\n */\nexport function getEffectInfo(effect: Effect): object {\n  return {\n    id: effect.id,\n    name: (effect as any).name || 'anonymous',\n    state: effect.state,\n    sourceCount: effect.sources.size,\n    observerCount: effect.observers.size,\n    disposed: isEffectDisposed(effect),\n    type: 'Effect',\n  }\n}\n\n// Re-export types\nexport type { EffectFunction, EffectOptions }\n"],"names":["createEffect","fn","options","owner","getCurrentOwner","previousValue","isFirst","effectFn","nextValue","effect","ComputationImpl","createRenderEffect","hasRun","createOnceEffect","result","createSyncEffect","disposeEffect","isEffectDisposed","getEffectInfo"],"mappings":"iHAiCO,SAASA,EAAgBC,EAAuBC,EAAyB,GAAY,CAC1F,MAAMC,EAAQC,EAAAA,gBAAA,EAEd,IAAIC,EACAC,EAAU,GAEd,MAAMC,EAAW,IAAM,CACrB,MAAMC,EAAYP,EAAGI,CAAa,EAElC,OAAKC,IAGHA,EAAU,IACVD,EAAgBG,EAGXA,CACT,EAGMC,EAAS,IAAIC,kBAAgBH,EAAUJ,CAAK,EAGlD,OAAID,EAAQ,MACV,OAAO,eAAeO,EAAQ,OAAQ,CACpC,MAAOP,EAAQ,KACf,WAAY,EAAA,CACb,EAIHO,EAAO,QAAA,EAEAA,CACT,CAmBO,SAASE,EAAsBV,EAAuBC,EAAyB,GAAY,CAChG,MAAMC,EAAQC,EAAAA,gBAAA,EAEd,IAAIC,EACAO,EAAS,GAEb,MAAML,EAAW,IAAM,CACrB,GAAI,CAACK,EACH,OAAAA,EAAS,GAEFX,EAAGI,CAAa,EAGzB,MAAMG,EAAYP,EAAGI,CAAa,EAClC,OAAAA,EAAgBG,EACTA,CACT,EAEMC,EAAS,IAAIC,kBAAgBH,EAAUJ,CAAK,EAElD,OAAID,EAAQ,MACV,OAAO,eAAeO,EAAQ,OAAQ,CACpC,MAAOP,EAAQ,KACf,WAAY,EAAA,CACb,EAIHO,EAAO,QAAA,EAEAA,CACT,CASO,SAASI,EAAoBZ,EAAuBC,EAAyB,GAAY,CAC9F,MAAMC,EAAQC,EAAAA,gBAAA,EAERG,EAAW,IAAM,CACrB,MAAMO,EAASb,EAAG,MAAS,EAE3B,OAAAQ,EAAO,QAAA,EACAK,CACT,EAEML,EAAS,IAAIC,kBAAgBH,EAAUJ,CAAK,EAElD,OAAID,EAAQ,MACV,OAAO,eAAeO,EAAQ,OAAQ,CACpC,MAAO,GAAGP,EAAQ,IAAI,SACtB,WAAY,EAAA,CACb,EAGHO,EAAO,QAAA,EAEAA,CACT,CASO,SAASM,EAAoBd,EAAuBC,EAAyB,GAAY,CAG9F,OAAOF,EAAaC,EAAI,CAAE,GAAGC,EAAS,KAAM,GAAGA,EAAQ,MAAQ,MAAM,QAAA,CAAU,CACjF,CAKO,SAASc,EAAcP,EAAsB,CAClDA,EAAO,QAAA,CACT,CAKO,SAASQ,EAAiBR,EAAyB,CACxD,OAAOA,EAAO,QAAU,CAC1B,CAKO,SAASS,EAAcT,EAAwB,CACpD,MAAO,CACL,GAAIA,EAAO,GACX,KAAOA,EAAe,MAAQ,YAC9B,MAAOA,EAAO,MACd,YAAaA,EAAO,QAAQ,KAC5B,cAAeA,EAAO,UAAU,KAChC,SAAUQ,EAAiBR,CAAM,EACjC,KAAM,QAAA,CAEV"}