@tachui/core 0.7.0-alpha1

package/dist/reactive/effect.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Effect implementation for side effects in reactive system
+ *
+ * Effects run when their dependencies change, enabling reactive
+ * side effects like DOM updates, logging, API calls, etc.
+ */
+import { ComputationImpl } from './context';
+import type { EffectFunction, EffectOptions } from './types';
+/**
+ * Effect function type
+ */
+export type Effect = ComputationImpl;
+/**
+ * Create a reactive effect that runs when dependencies change
+ *
+ * @param fn The effect function to run
+ * @param options Effect configuration options
+ * @returns The effect computation
+ *
+ * @example
+ * ```typescript
+ * const [count, setCount] = createSignal(0)
+ *
+ * createEffect(() => {
+ *   console.log('Count changed:', count())
+ * })
+ *
+ * setCount(5) // Logs: "Count changed: 5"
+ * ```
+ */
+export declare function createEffect<T>(fn: EffectFunction<T>, options?: EffectOptions): Effect;
+/**
+ * Create an effect that only runs after dependencies change (not on first run)
+ *
+ * @param fn The effect function to run
+ * @param options Effect configuration options
+ * @returns The effect computation
+ *
+ * @example
+ * ```typescript
+ * const [count, setCount] = createSignal(0)
+ *
+ * createRenderEffect(() => {
+ *   // This won't run immediately, only when count changes
+ *   document.title = `Count: ${count()}`
+ * })
+ * ```
+ */
+export declare function createRenderEffect<T>(fn: EffectFunction<T>, options?: EffectOptions): Effect;
+/**
+ * Create a one-time effect that disposes itself after first execution
+ *
+ * @param fn The effect function to run once
+ * @param options Effect configuration options
+ * @returns The effect computation
+ */
+export declare function createOnceEffect<T>(fn: EffectFunction<T>, options?: EffectOptions): Effect;
+/**
+ * Create an effect that runs synchronously (not batched)
+ *
+ * @param fn The effect function to run
+ * @param options Effect configuration options
+ * @returns The effect computation
+ */
+export declare function createSyncEffect<T>(fn: EffectFunction<T>, options?: EffectOptions): Effect;
+/**
+ * Dispose an effect
+ */
+export declare function disposeEffect(effect: Effect): void;
+/**
+ * Check if an effect is disposed
+ */
+export declare function isEffectDisposed(effect: Effect): boolean;
+/**
+ * Get effect debug information
+ */
+export declare function getEffectInfo(effect: Effect): object;
+export type { EffectFunction, EffectOptions };
+//# sourceMappingURL=effect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/reactive/effect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAmB,MAAM,WAAW,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5D;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,eAAe,CAAA;AAEpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAkC1F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CA+BhG;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAsB9F;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAI9F;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAElD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUpD;AAGD,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,CAAA"}

package/dist/reactive/effect.js

@@ -0,0 +1,67 @@
+import { ComputationImpl as f, getCurrentOwner as a } from "./context.js";
+function i(e, n = {}) {
+  const u = a();
+  let r, t = !0;
+  const o = () => {
+    const s = e(r);
+    return t && (t = !1), r = s, s;
+  }, c = new f(o, u);
+  return n.name && Object.defineProperty(c, "name", {
+    value: n.name,
+    enumerable: !1
+  }), c.execute(), c;
+}
+function d(e, n = {}) {
+  const u = a();
+  let r, t = !1;
+  const o = () => {
+    if (!t)
+      return t = !0, e(r);
+    const s = e(r);
+    return r = s, s;
+  }, c = new f(o, u);
+  return n.name && Object.defineProperty(c, "name", {
+    value: n.name,
+    enumerable: !1
+  }), c.execute(), c;
+}
+function p(e, n = {}) {
+  const u = a(), r = () => {
+    const o = e(void 0);
+    return t.dispose(), o;
+  }, t = new f(r, u);
+  return n.name && Object.defineProperty(t, "name", {
+    value: `${n.name}(once)`,
+    enumerable: !1
+  }), t.execute(), t;
+}
+function b(e, n = {}) {
+  return i(e, { ...n, name: `${n.name || "sync"}(sync)` });
+}
+function v(e) {
+  e.dispose();
+}
+function l(e) {
+  return e.state === 3;
+}
+function y(e) {
+  return {
+    id: e.id,
+    name: e.name || "anonymous",
+    state: e.state,
+    sourceCount: e.sources.size,
+    observerCount: e.observers.size,
+    disposed: l(e),
+    type: "Effect"
+  };
+}
+export {
+  i as createEffect,
+  p as createOnceEffect,
+  d as createRenderEffect,
+  b as createSyncEffect,
+  v as disposeEffect,
+  y as getEffectInfo,
+  l as isEffectDisposed
+};
+//# sourceMappingURL=effect.js.map

package/dist/reactive/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","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":";AAiCO,SAASA,EAAgBC,GAAuBC,IAAyB,IAAY;AAC1F,QAAMC,IAAQC,EAAA;AAEd,MAAIC,GACAC,IAAU;AAEd,QAAMC,IAAW,MAAM;AACrB,UAAMC,IAAYP,EAAGI,CAAa;AAElC,WAAKC,MAGHA,IAAU,KACVD,IAAgBG,GAGXA;AAAA,EACT,GAGMC,IAAS,IAAIC,EAAgBH,GAAUJ,CAAK;AAGlD,SAAID,EAAQ,QACV,OAAO,eAAeO,GAAQ,QAAQ;AAAA,IACpC,OAAOP,EAAQ;AAAA,IACf,YAAY;AAAA,EAAA,CACb,GAIHO,EAAO,QAAA,GAEAA;AACT;AAmBO,SAASE,EAAsBV,GAAuBC,IAAyB,IAAY;AAChG,QAAMC,IAAQC,EAAA;AAEd,MAAIC,GACAO,IAAS;AAEb,QAAML,IAAW,MAAM;AACrB,QAAI,CAACK;AACH,aAAAA,IAAS,IAEFX,EAAGI,CAAa;AAGzB,UAAMG,IAAYP,EAAGI,CAAa;AAClC,WAAAA,IAAgBG,GACTA;AAAA,EACT,GAEMC,IAAS,IAAIC,EAAgBH,GAAUJ,CAAK;AAElD,SAAID,EAAQ,QACV,OAAO,eAAeO,GAAQ,QAAQ;AAAA,IACpC,OAAOP,EAAQ;AAAA,IACf,YAAY;AAAA,EAAA,CACb,GAIHO,EAAO,QAAA,GAEAA;AACT;AASO,SAASI,EAAoBZ,GAAuBC,IAAyB,IAAY;AAC9F,QAAMC,IAAQC,EAAA,GAERG,IAAW,MAAM;AACrB,UAAMO,IAASb,EAAG,MAAS;AAE3B,WAAAQ,EAAO,QAAA,GACAK;AAAA,EACT,GAEML,IAAS,IAAIC,EAAgBH,GAAUJ,CAAK;AAElD,SAAID,EAAQ,QACV,OAAO,eAAeO,GAAQ,QAAQ;AAAA,IACpC,OAAO,GAAGP,EAAQ,IAAI;AAAA,IACtB,YAAY;AAAA,EAAA,CACb,GAGHO,EAAO,QAAA,GAEAA;AACT;AASO,SAASM,EAAoBd,GAAuBC,IAAyB,IAAY;AAG9F,SAAOF,EAAaC,GAAI,EAAE,GAAGC,GAAS,MAAM,GAAGA,EAAQ,QAAQ,MAAM,SAAA,CAAU;AACjF;AAKO,SAASc,EAAcP,GAAsB;AAClD,EAAAA,EAAO,QAAA;AACT;AAKO,SAASQ,EAAiBR,GAAyB;AACxD,SAAOA,EAAO,UAAU;AAC1B;AAKO,SAASS,EAAcT,GAAwB;AACpD,SAAO;AAAA,IACL,IAAIA,EAAO;AAAA,IACX,MAAOA,EAAe,QAAQ;AAAA,IAC9B,OAAOA,EAAO;AAAA,IACd,aAAaA,EAAO,QAAQ;AAAA,IAC5B,eAAeA,EAAO,UAAU;AAAA,IAChC,UAAUQ,EAAiBR,CAAM;AAAA,IACjC,MAAM;AAAA,EAAA;AAEV;"}

package/dist/reactive/enhanced-effect.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("./context.cjs"),n=require("./unified-scheduler.cjs");var l=Object.defineProperty,p=(r,e,i)=>e in r?l(r,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):r[e]=i,s=(r,e,i)=>p(r,typeof e!="symbol"?e+"":e,i);let d=0;class h{constructor(e,i={}){this.effectFn=e,s(this,"id",++d),s(this,"type","effect"),s(this,"priority"),s(this,"sources",new Set),s(this,"observers",new Set),s(this,"isDisposed",!1),s(this,"cleanupFn"),s(this,"options"),s(this,"owner"),this.priority=i.priority??n.UpdatePriority.Normal,this.options=i,this.owner=f.getCurrentOwner(),i.fireImmediately!==!1&&this.execute()}notify(){this.isDisposed||this.execute()}execute(){if(this.isDisposed)return;if(this.cleanupFn){try{this.cleanupFn()}catch(t){console.error("Effect cleanup error:",t)}this.cleanupFn=void 0}for(const t of this.sources)"removeObserver"in t&&typeof t.removeObserver=="function"?t.removeObserver(this):"observers"in t&&t.observers instanceof Set&&t.observers.delete(this);this.sources.clear();const e=f.getCurrentComputation(),i=this.setCurrentComputation||(()=>{});i(this);try{const t=this.effectFn();typeof t=="function"&&(this.cleanupFn=t)}catch(t){if(this.options.onError)try{this.options.onError(t)}catch(o){throw console.error("Effect error handler threw error:",o),t}else throw console.error(`Effect ${this.options.debugName||this.id} threw error:`,t),t}finally{i(e)}}cleanup(){if(this.isDisposed=!0,this.cleanupFn){try{this.cleanupFn()}catch(e){console.error("Effect cleanup error:",e)}this.cleanupFn=void 0}for(const e of this.sources)"removeObserver"in e&&typeof e.removeObserver=="function"?e.removeObserver(this):"observers"in e&&e.observers instanceof Set&&e.observers.delete(this);if(this.sources.clear(),this.owner?.cleanups){const e=this.owner.cleanups.indexOf(this.cleanup.bind(this));e>=0&&this.owner.cleanups.splice(e,1)}}dispose(){this.cleanup()}get disposed(){return this.isDisposed}[Symbol.for("tachui.debug")](){return{id:this.id,type:this.type,priority:n.UpdatePriority[this.priority],debugName:this.options.debugName,disposed:this.isDisposed,sourceCount:this.sources.size,hasCleanup:!!this.cleanupFn}}toString(){return`Effect(${this.options.debugName||this.id})`}}function c(r,e){const i=new h(r,e),t=f.getCurrentOwner();return t&&t.cleanups.push(()=>i.cleanup()),()=>i.cleanup()}function m(r,e){return c(r,{...e,priority:n.UpdatePriority.High})}function y(r,e){return c(r,{...e,priority:n.UpdatePriority.Low})}function b(r,e){return c(r,{...e,fireImmediately:!1})}function E(r,e,i=3,t){let o=0;const u=()=>{try{return r()}catch(a){if(o++,e&&o<=i&&e(a,o)){setTimeout(()=>u(),o*100);return}else throw a}};return c(u,{...t,debugName:`${t?.debugName||"effect"}(resilient)`})}function v(r){const e=r.map(({fn:i,options:t})=>c(i,t));return()=>{e.forEach(i=>i())}}function g(){return n.ReactiveScheduler.getInstance().getPerformanceMetrics()}function w(){n.ReactiveScheduler.getInstance().flushSync()}exports.EffectImpl=h;exports.createEffectBatch=v;exports.createEnhancedEffect=c;exports.createHighPriorityEffect=m;exports.createLowPriorityEffect=y;exports.createResilientEffect=E;exports.createWatchEffect=b;exports.flushEffectUpdates=w;exports.getEffectPerformanceMetrics=g;
+//# sourceMappingURL=enhanced-effect.cjs.map

package/dist/reactive/enhanced-effect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-effect.cjs","sources":["../../src/reactive/enhanced-effect.ts"],"sourcesContent":["/**\n * Enhanced Effect System v2.0\n *\n * Provides proper error propagation and integrates with the unified scheduler\n * to fix silent error suppression and incomplete cleanup issues.\n */\n\nimport { getCurrentComputation, getCurrentOwner } from './context'\nimport type { Owner } from './types'\nimport { type ReactiveNode, ReactiveScheduler, UpdatePriority } from './unified-scheduler'\n\nlet effectIdCounter = 0\n\nexport interface EffectOptions {\n  priority?: UpdatePriority\n  debugName?: string\n  onError?: (error: Error) => void\n  fireImmediately?: boolean\n}\n\n/**\n * Enhanced effect implementation with proper error propagation\n */\nexport class EffectImpl implements ReactiveNode {\n  readonly id = ++effectIdCounter\n  readonly type = 'effect' as const\n  readonly priority: UpdatePriority\n  readonly sources = new Set<any>()\n  readonly observers = new Set<never>() // Effects don't have observers\n\n  private isDisposed = false\n  private cleanupFn?: () => void\n  private options: EffectOptions\n  private owner: Owner | null\n\n  constructor(\n    private effectFn: () => undefined | (() => void),\n    options: EffectOptions = {}\n  ) {\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.options = options\n    this.owner = getCurrentOwner()\n\n    if (options.fireImmediately !== false) {\n      this.execute()\n    }\n  }\n\n  /**\n   * Notify method called by unified scheduler\n   */\n  notify(): void {\n    if (this.isDisposed) return\n\n    this.execute()\n  }\n\n  /**\n   * Execute the effect with proper error handling\n   */\n  private execute(): void {\n    if (this.isDisposed) return\n\n    // Cleanup previous effect run\n    if (this.cleanupFn) {\n      try {\n        this.cleanupFn()\n      } catch (error) {\n        console.error('Effect cleanup error:', error)\n      }\n      this.cleanupFn = undefined\n    }\n\n    // Clear existing dependencies\n    for (const source of this.sources) {\n      if ('removeObserver' in source && typeof source.removeObserver === 'function') {\n        source.removeObserver(this)\n      } else if ('observers' in source && source.observers instanceof Set) {\n        source.observers.delete(this)\n      }\n    }\n    this.sources.clear()\n\n    // Execute effect with dependency tracking\n    const previousComputation = getCurrentComputation()\n    // We need to set this as the current computation for dependency tracking\n    const setCurrentComputation = (this as any).setCurrentComputation || (() => {})\n    setCurrentComputation(this)\n\n    try {\n      const result = this.effectFn()\n\n      // Store cleanup function if returned\n      if (typeof result === 'function') {\n        this.cleanupFn = result\n      }\n    } catch (error) {\n      if (this.options.onError) {\n        try {\n          this.options.onError(error as Error)\n        } catch (handlerError) {\n          console.error('Effect error handler threw error:', handlerError)\n          // Re-throw the original error since handler failed\n          throw error\n        }\n      } else {\n        // Don't suppress errors like the old implementation - re-throw them\n        console.error(`Effect ${this.options.debugName || this.id} threw error:`, error)\n        throw error\n      }\n    } finally {\n      setCurrentComputation(previousComputation)\n    }\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    this.isDisposed = true\n\n    // Cleanup effect function\n    if (this.cleanupFn) {\n      try {\n        this.cleanupFn()\n      } catch (error) {\n        console.error('Effect cleanup error:', error)\n      }\n      this.cleanupFn = undefined\n    }\n\n    // Remove from all sources\n    for (const source of this.sources) {\n      if ('removeObserver' in source && typeof source.removeObserver === 'function') {\n        source.removeObserver(this)\n      } else if ('observers' in source && source.observers instanceof Set) {\n        source.observers.delete(this)\n      }\n    }\n    this.sources.clear()\n\n    // Remove from owner cleanup\n    if (this.owner?.cleanups) {\n      const index = this.owner.cleanups.indexOf(this.cleanup.bind(this))\n      if (index >= 0) {\n        this.owner.cleanups.splice(index, 1)\n      }\n    }\n  }\n\n  /**\n   * Dispose the effect (alias for cleanup)\n   */\n  dispose(): void {\n    this.cleanup()\n  }\n\n  /**\n   * Check if effect is disposed\n   */\n  get disposed(): boolean {\n    return this.isDisposed\n  }\n\n  /**\n   * Debug information\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      priority: UpdatePriority[this.priority],\n      debugName: this.options.debugName,\n      disposed: this.isDisposed,\n      sourceCount: this.sources.size,\n      hasCleanup: !!this.cleanupFn,\n    }\n  }\n\n  toString(): string {\n    return `Effect(${this.options.debugName || this.id})`\n  }\n}\n\n/**\n * Create a reactive effect with proper error handling\n *\n * @param effectFn The effect function to run\n * @param options Effect configuration options\n * @returns Cleanup function to dispose the effect\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * const cleanup = createEnhancedEffect(() => {\n *   console.log('Count changed:', count())\n * }, {\n *   debugName: 'countLogger',\n *   onError: (error) => {\n *     console.error('Effect failed:', error)\n *   }\n * })\n *\n * // Later, cleanup when no longer needed\n * cleanup()\n * ```\n */\nexport function createEnhancedEffect(\n  effectFn: () => undefined | (() => void),\n  options?: EffectOptions\n): () => void {\n  const effect = new EffectImpl(effectFn, options)\n\n  // Register cleanup with owner if available\n  const owner = getCurrentOwner()\n  if (owner) {\n    owner.cleanups.push(() => effect.cleanup())\n  }\n\n  return () => effect.cleanup()\n}\n\n/**\n * Create an effect with high priority for user interactions\n */\nexport function createHighPriorityEffect(\n  effectFn: () => undefined | (() => void),\n  options?: Omit<EffectOptions, 'priority'>\n): () => void {\n  return createEnhancedEffect(effectFn, { ...options, priority: UpdatePriority.High })\n}\n\n/**\n * Create an effect with low priority for background tasks\n */\nexport function createLowPriorityEffect(\n  effectFn: () => undefined | (() => void),\n  options?: Omit<EffectOptions, 'priority'>\n): () => void {\n  return createEnhancedEffect(effectFn, { ...options, priority: UpdatePriority.Low })\n}\n\n/**\n * Create an effect that only runs when dependencies change (not immediately)\n */\nexport function createWatchEffect(\n  effectFn: () => undefined | (() => void),\n  options?: Omit<EffectOptions, 'fireImmediately'>\n): () => void {\n  return createEnhancedEffect(effectFn, { ...options, fireImmediately: false })\n}\n\n/**\n * Create an effect with automatic error recovery\n */\nexport function createResilientEffect(\n  effectFn: () => undefined | (() => void),\n  onError?: (error: Error, attempt: number) => boolean, // return true to retry\n  maxRetries = 3,\n  options?: EffectOptions\n): () => void {\n  let attempt = 0\n\n  const resilientFn = () => {\n    try {\n      return effectFn()\n    } catch (error) {\n      attempt++\n\n      if (onError && attempt <= maxRetries && onError(error as Error, attempt)) {\n        // Retry after a short delay\n        setTimeout(() => resilientFn(), attempt * 100)\n        return\n      } else {\n        // Give up and re-throw\n        throw error\n      }\n    }\n  }\n\n  return createEnhancedEffect(resilientFn, {\n    ...options,\n    debugName: `${options?.debugName || 'effect'}(resilient)`,\n  })\n}\n\n/**\n * Batch multiple effect creations for performance\n */\nexport function createEffectBatch(\n  effects: Array<{\n    fn: () => undefined | (() => void)\n    options?: EffectOptions\n  }>\n): () => void {\n  const cleanups = effects.map(({ fn, options }) => createEnhancedEffect(fn, options))\n\n  return () => {\n    cleanups.forEach((cleanup) => cleanup())\n  }\n}\n\n/**\n * Get performance metrics for all effects\n */\nexport function getEffectPerformanceMetrics() {\n  const scheduler = ReactiveScheduler.getInstance()\n  return scheduler.getPerformanceMetrics()\n}\n\n/**\n * Flush all pending effect updates synchronously\n */\nexport function flushEffectUpdates(): void {\n  const scheduler = ReactiveScheduler.getInstance()\n  scheduler.flushSync()\n}\n"],"names":["effectIdCounter","EffectImpl","effectFn","options","__publicField","UpdatePriority","getCurrentOwner","error","source","previousComputation","getCurrentComputation","setCurrentComputation","result","handlerError","index","createEnhancedEffect","effect","owner","createHighPriorityEffect","createLowPriorityEffect","createWatchEffect","createResilientEffect","onError","maxRetries","attempt","resilientFn","createEffectBatch","effects","cleanups","fn","cleanup","getEffectPerformanceMetrics","ReactiveScheduler","flushEffectUpdates"],"mappings":"kTAWA,IAAIA,EAAkB,EAYf,MAAMC,CAAmC,CAY9C,YACUC,EACRC,EAAyB,GACzB,CAFQ,KAAA,SAAAD,EAZVE,EAAA,KAAS,KAAK,EAAEJ,CAAA,EAChBI,EAAA,KAAS,OAAO,QAAA,EAChBA,EAAA,KAAS,UAAA,EACTA,EAAA,KAAS,cAAc,GAAS,EAChCA,EAAA,KAAS,gBAAgB,GAAW,EAEpCA,EAAA,KAAQ,aAAa,EAAA,EACrBA,EAAA,KAAQ,WAAA,EACRA,EAAA,KAAQ,SAAA,EACRA,EAAA,KAAQ,OAAA,EAMN,KAAK,SAAWD,EAAQ,UAAYE,EAAAA,eAAe,OACnD,KAAK,QAAUF,EACf,KAAK,MAAQG,kBAAA,EAETH,EAAQ,kBAAoB,IAC9B,KAAK,QAAA,CAET,CAKA,QAAe,CACT,KAAK,YAET,KAAK,QAAA,CACP,CAKQ,SAAgB,CACtB,GAAI,KAAK,WAAY,OAGrB,GAAI,KAAK,UAAW,CAClB,GAAI,CACF,KAAK,UAAA,CACP,OAASI,EAAO,CACd,QAAQ,MAAM,wBAAyBA,CAAK,CAC9C,CACA,KAAK,UAAY,MACnB,CAGA,UAAWC,KAAU,KAAK,QACpB,mBAAoBA,GAAU,OAAOA,EAAO,gBAAmB,WACjEA,EAAO,eAAe,IAAI,EACjB,cAAeA,GAAUA,EAAO,qBAAqB,KAC9DA,EAAO,UAAU,OAAO,IAAI,EAGhC,KAAK,QAAQ,MAAA,EAGb,MAAMC,EAAsBC,EAAAA,sBAAA,EAEtBC,EAAyB,KAAa,wBAA0B,IAAM,CAAC,GAC7EA,EAAsB,IAAI,EAE1B,GAAI,CACF,MAAMC,EAAS,KAAK,SAAA,EAGhB,OAAOA,GAAW,aACpB,KAAK,UAAYA,EAErB,OAASL,EAAO,CACd,GAAI,KAAK,QAAQ,QACf,GAAI,CACF,KAAK,QAAQ,QAAQA,CAAc,CACrC,OAASM,EAAc,CACrB,cAAQ,MAAM,oCAAqCA,CAAY,EAEzDN,CACR,KAGA,eAAQ,MAAM,UAAU,KAAK,QAAQ,WAAa,KAAK,EAAE,gBAAiBA,CAAK,EACzEA,CAEV,QAAA,CACEI,EAAsBF,CAAmB,CAC3C,CACF,CAKA,SAAgB,CAId,GAHA,KAAK,WAAa,GAGd,KAAK,UAAW,CAClB,GAAI,CACF,KAAK,UAAA,CACP,OAASF,EAAO,CACd,QAAQ,MAAM,wBAAyBA,CAAK,CAC9C,CACA,KAAK,UAAY,MACnB,CAGA,UAAWC,KAAU,KAAK,QACpB,mBAAoBA,GAAU,OAAOA,EAAO,gBAAmB,WACjEA,EAAO,eAAe,IAAI,EACjB,cAAeA,GAAUA,EAAO,qBAAqB,KAC9DA,EAAO,UAAU,OAAO,IAAI,EAMhC,GAHA,KAAK,QAAQ,MAAA,EAGT,KAAK,OAAO,SAAU,CACxB,MAAMM,EAAQ,KAAK,MAAM,SAAS,QAAQ,KAAK,QAAQ,KAAK,IAAI,CAAC,EAC7DA,GAAS,GACX,KAAK,MAAM,SAAS,OAAOA,EAAO,CAAC,CAEvC,CACF,CAKA,SAAgB,CACd,KAAK,QAAA,CACP,CAKA,IAAI,UAAoB,CACtB,OAAO,KAAK,UACd,CAKA,CAAC,OAAO,IAAI,cAAc,CAAC,GAAY,CACrC,MAAO,CACL,GAAI,KAAK,GACT,KAAM,KAAK,KACX,SAAUT,EAAAA,eAAe,KAAK,QAAQ,EACtC,UAAW,KAAK,QAAQ,UACxB,SAAU,KAAK,WACf,YAAa,KAAK,QAAQ,KAC1B,WAAY,CAAC,CAAC,KAAK,SAAA,CAEvB,CAEA,UAAmB,CACjB,MAAO,UAAU,KAAK,QAAQ,WAAa,KAAK,EAAE,GACpD,CACF,CA0BO,SAASU,EACdb,EACAC,EACY,CACZ,MAAMa,EAAS,IAAIf,EAAWC,EAAUC,CAAO,EAGzCc,EAAQX,EAAAA,gBAAA,EACd,OAAIW,GACFA,EAAM,SAAS,KAAK,IAAMD,EAAO,SAAS,EAGrC,IAAMA,EAAO,QAAA,CACtB,CAKO,SAASE,EACdhB,EACAC,EACY,CACZ,OAAOY,EAAqBb,EAAU,CAAE,GAAGC,EAAS,SAAUE,EAAAA,eAAe,KAAM,CACrF,CAKO,SAASc,EACdjB,EACAC,EACY,CACZ,OAAOY,EAAqBb,EAAU,CAAE,GAAGC,EAAS,SAAUE,EAAAA,eAAe,IAAK,CACpF,CAKO,SAASe,EACdlB,EACAC,EACY,CACZ,OAAOY,EAAqBb,EAAU,CAAE,GAAGC,EAAS,gBAAiB,GAAO,CAC9E,CAKO,SAASkB,EACdnB,EACAoB,EACAC,EAAa,EACbpB,EACY,CACZ,IAAIqB,EAAU,EAEd,MAAMC,EAAc,IAAM,CACxB,GAAI,CACF,OAAOvB,EAAA,CACT,OAASK,EAAO,CAGd,GAFAiB,IAEIF,GAAWE,GAAWD,GAAcD,EAAQf,EAAgBiB,CAAO,EAAG,CAExE,WAAW,IAAMC,IAAeD,EAAU,GAAG,EAC7C,MACF,KAEE,OAAMjB,CAEV,CACF,EAEA,OAAOQ,EAAqBU,EAAa,CACvC,GAAGtB,EACH,UAAW,GAAGA,GAAS,WAAa,QAAQ,aAAA,CAC7C,CACH,CAKO,SAASuB,EACdC,EAIY,CACZ,MAAMC,EAAWD,EAAQ,IAAI,CAAC,CAAE,GAAAE,EAAI,QAAA1B,CAAA,IAAcY,EAAqBc,EAAI1B,CAAO,CAAC,EAEnF,MAAO,IAAM,CACXyB,EAAS,QAASE,GAAYA,EAAA,CAAS,CACzC,CACF,CAKO,SAASC,GAA8B,CAE5C,OADkBC,EAAAA,kBAAkB,YAAA,EACnB,sBAAA,CACnB,CAKO,SAASC,GAA2B,CACvBD,EAAAA,kBAAkB,YAAA,EAC1B,UAAA,CACZ"}

package/dist/reactive/enhanced-effect.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Enhanced Effect System v2.0
+ *
+ * Provides proper error propagation and integrates with the unified scheduler
+ * to fix silent error suppression and incomplete cleanup issues.
+ */
+import { type ReactiveNode, UpdatePriority } from './unified-scheduler';
+export interface EffectOptions {
+    priority?: UpdatePriority;
+    debugName?: string;
+    onError?: (error: Error) => void;
+    fireImmediately?: boolean;
+}
+/**
+ * Enhanced effect implementation with proper error propagation
+ */
+export declare class EffectImpl implements ReactiveNode {
+    private effectFn;
+    readonly id: number;
+    readonly type: "effect";
+    readonly priority: UpdatePriority;
+    readonly sources: Set<any>;
+    readonly observers: Set<never>;
+    private isDisposed;
+    private cleanupFn?;
+    private options;
+    private owner;
+    constructor(effectFn: () => undefined | (() => void), options?: EffectOptions);
+    /**
+     * Notify method called by unified scheduler
+     */
+    notify(): void;
+    /**
+     * Execute the effect with proper error handling
+     */
+    private execute;
+    /**
+     * Complete cleanup for memory management
+     */
+    cleanup(): void;
+    /**
+     * Dispose the effect (alias for cleanup)
+     */
+    dispose(): void;
+    /**
+     * Check if effect is disposed
+     */
+    get disposed(): boolean;
+    toString(): string;
+}
+/**
+ * Create a reactive effect with proper error handling
+ *
+ * @param effectFn The effect function to run
+ * @param options Effect configuration options
+ * @returns Cleanup function to dispose the effect
+ *
+ * @example
+ * ```typescript
+ * const [count, setCount] = createSignal(0)
+ *
+ * const cleanup = createEnhancedEffect(() => {
+ *   console.log('Count changed:', count())
+ * }, {
+ *   debugName: 'countLogger',
+ *   onError: (error) => {
+ *     console.error('Effect failed:', error)
+ *   }
+ * })
+ *
+ * // Later, cleanup when no longer needed
+ * cleanup()
+ * ```
+ */
+export declare function createEnhancedEffect(effectFn: () => undefined | (() => void), options?: EffectOptions): () => void;
+/**
+ * Create an effect with high priority for user interactions
+ */
+export declare function createHighPriorityEffect(effectFn: () => undefined | (() => void), options?: Omit<EffectOptions, 'priority'>): () => void;
+/**
+ * Create an effect with low priority for background tasks
+ */
+export declare function createLowPriorityEffect(effectFn: () => undefined | (() => void), options?: Omit<EffectOptions, 'priority'>): () => void;
+/**
+ * Create an effect that only runs when dependencies change (not immediately)
+ */
+export declare function createWatchEffect(effectFn: () => undefined | (() => void), options?: Omit<EffectOptions, 'fireImmediately'>): () => void;
+/**
+ * Create an effect with automatic error recovery
+ */
+export declare function createResilientEffect(effectFn: () => undefined | (() => void), onError?: (error: Error, attempt: number) => boolean, // return true to retry
+maxRetries?: number, options?: EffectOptions): () => void;
+/**
+ * Batch multiple effect creations for performance
+ */
+export declare function createEffectBatch(effects: Array<{
+    fn: () => undefined | (() => void);
+    options?: EffectOptions;
+}>): () => void;
+/**
+ * Get performance metrics for all effects
+ */
+export declare function getEffectPerformanceMetrics(): import("./unified-scheduler").ReactivePerformanceMetrics;
+/**
+ * Flush all pending effect updates synchronously
+ */
+export declare function flushEffectUpdates(): void;
+//# sourceMappingURL=enhanced-effect.d.ts.map

package/dist/reactive/enhanced-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-effect.d.ts","sourceRoot":"","sources":["../../src/reactive/enhanced-effect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,KAAK,YAAY,EAAqB,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAI1F,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED;;GAEG;AACH,qBAAa,UAAW,YAAW,YAAY;IAa3C,OAAO,CAAC,QAAQ;IAZlB,QAAQ,CAAC,EAAE,SAAoB;IAC/B,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IACjC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,OAAO,WAAiB;IACjC,QAAQ,CAAC,SAAS,aAAmB;IAErC,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,KAAK,CAAc;gBAGjB,QAAQ,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,EAChD,OAAO,GAAE,aAAkB;IAW7B;;OAEG;IACH,MAAM,IAAI,IAAI;IAMd;;OAEG;IACH,OAAO,CAAC,OAAO;IAuDf;;OAEG;IACH,OAAO,IAAI,IAAI;IAgCf;;OAEG;IACH,OAAO,IAAI,IAAI;IAIf;;OAEG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAiBD,QAAQ,IAAI,MAAM;CAGnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,IAAI,CAUZ;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,GACxC,MAAM,IAAI,CAEZ;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,GACxC,MAAM,IAAI,CAEZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,GAC/C,MAAM,IAAI,CAEZ;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,EAAE,uBAAuB;AAC7E,UAAU,SAAI,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,IAAI,CAwBZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,KAAK,CAAC;IACb,EAAE,EAAE,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,CAAA;IAClC,OAAO,CAAC,EAAE,aAAa,CAAA;CACxB,CAAC,GACD,MAAM,IAAI,CAMZ;AAED;;GAEG;AACH,wBAAgB,2BAA2B,6DAG1C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC"}

package/dist/reactive/enhanced-effect.js

@@ -0,0 +1,153 @@
+import { getCurrentOwner as h, getCurrentComputation as p } from "./context.js";
+import { UpdatePriority as c, ReactiveScheduler as a } from "./unified-scheduler.js";
+var l = Object.defineProperty, d = (r, e, s) => e in r ? l(r, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : r[e] = s, i = (r, e, s) => d(r, typeof e != "symbol" ? e + "" : e, s);
+let m = 0;
+class b {
+  constructor(e, s = {}) {
+    this.effectFn = e, i(this, "id", ++m), i(this, "type", "effect"), i(this, "priority"), i(this, "sources", /* @__PURE__ */ new Set()), i(this, "observers", /* @__PURE__ */ new Set()), i(this, "isDisposed", !1), i(this, "cleanupFn"), i(this, "options"), i(this, "owner"), this.priority = s.priority ?? c.Normal, this.options = s, this.owner = h(), s.fireImmediately !== !1 && this.execute();
+  }
+  /**
+   * Notify method called by unified scheduler
+   */
+  notify() {
+    this.isDisposed || this.execute();
+  }
+  /**
+   * Execute the effect with proper error handling
+   */
+  execute() {
+    if (this.isDisposed) return;
+    if (this.cleanupFn) {
+      try {
+        this.cleanupFn();
+      } catch (t) {
+        console.error("Effect cleanup error:", t);
+      }
+      this.cleanupFn = void 0;
+    }
+    for (const t of this.sources)
+      "removeObserver" in t && typeof t.removeObserver == "function" ? t.removeObserver(this) : "observers" in t && t.observers instanceof Set && t.observers.delete(this);
+    this.sources.clear();
+    const e = p(), s = this.setCurrentComputation || (() => {
+    });
+    s(this);
+    try {
+      const t = this.effectFn();
+      typeof t == "function" && (this.cleanupFn = t);
+    } catch (t) {
+      if (this.options.onError)
+        try {
+          this.options.onError(t);
+        } catch (o) {
+          throw console.error("Effect error handler threw error:", o), t;
+        }
+      else
+        throw console.error(`Effect ${this.options.debugName || this.id} threw error:`, t), t;
+    } finally {
+      s(e);
+    }
+  }
+  /**
+   * Complete cleanup for memory management
+   */
+  cleanup() {
+    if (this.isDisposed = !0, this.cleanupFn) {
+      try {
+        this.cleanupFn();
+      } catch (e) {
+        console.error("Effect cleanup error:", e);
+      }
+      this.cleanupFn = void 0;
+    }
+    for (const e of this.sources)
+      "removeObserver" in e && typeof e.removeObserver == "function" ? e.removeObserver(this) : "observers" in e && e.observers instanceof Set && e.observers.delete(this);
+    if (this.sources.clear(), this.owner?.cleanups) {
+      const e = this.owner.cleanups.indexOf(this.cleanup.bind(this));
+      e >= 0 && this.owner.cleanups.splice(e, 1);
+    }
+  }
+  /**
+   * Dispose the effect (alias for cleanup)
+   */
+  dispose() {
+    this.cleanup();
+  }
+  /**
+   * Check if effect is disposed
+   */
+  get disposed() {
+    return this.isDisposed;
+  }
+  /**
+   * Debug information
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      type: this.type,
+      priority: c[this.priority],
+      debugName: this.options.debugName,
+      disposed: this.isDisposed,
+      sourceCount: this.sources.size,
+      hasCleanup: !!this.cleanupFn
+    };
+  }
+  toString() {
+    return `Effect(${this.options.debugName || this.id})`;
+  }
+}
+function n(r, e) {
+  const s = new b(r, e), t = h();
+  return t && t.cleanups.push(() => s.cleanup()), () => s.cleanup();
+}
+function g(r, e) {
+  return n(r, { ...e, priority: c.High });
+}
+function w(r, e) {
+  return n(r, { ...e, priority: c.Low });
+}
+function E(r, e) {
+  return n(r, { ...e, fireImmediately: !1 });
+}
+function F(r, e, s = 3, t) {
+  let o = 0;
+  const f = () => {
+    try {
+      return r();
+    } catch (u) {
+      if (o++, e && o <= s && e(u, o)) {
+        setTimeout(() => f(), o * 100);
+        return;
+      } else
+        throw u;
+    }
+  };
+  return n(f, {
+    ...t,
+    debugName: `${t?.debugName || "effect"}(resilient)`
+  });
+}
+function C(r) {
+  const e = r.map(({ fn: s, options: t }) => n(s, t));
+  return () => {
+    e.forEach((s) => s());
+  };
+}
+function O() {
+  return a.getInstance().getPerformanceMetrics();
+}
+function N() {
+  a.getInstance().flushSync();
+}
+export {
+  b as EffectImpl,
+  C as createEffectBatch,
+  n as createEnhancedEffect,
+  g as createHighPriorityEffect,
+  w as createLowPriorityEffect,
+  F as createResilientEffect,
+  E as createWatchEffect,
+  N as flushEffectUpdates,
+  O as getEffectPerformanceMetrics
+};
+//# sourceMappingURL=enhanced-effect.js.map

package/dist/reactive/enhanced-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-effect.js","sources":["../../src/reactive/enhanced-effect.ts"],"sourcesContent":["/**\n * Enhanced Effect System v2.0\n *\n * Provides proper error propagation and integrates with the unified scheduler\n * to fix silent error suppression and incomplete cleanup issues.\n */\n\nimport { getCurrentComputation, getCurrentOwner } from './context'\nimport type { Owner } from './types'\nimport { type ReactiveNode, ReactiveScheduler, UpdatePriority } from './unified-scheduler'\n\nlet effectIdCounter = 0\n\nexport interface EffectOptions {\n  priority?: UpdatePriority\n  debugName?: string\n  onError?: (error: Error) => void\n  fireImmediately?: boolean\n}\n\n/**\n * Enhanced effect implementation with proper error propagation\n */\nexport class EffectImpl implements ReactiveNode {\n  readonly id = ++effectIdCounter\n  readonly type = 'effect' as const\n  readonly priority: UpdatePriority\n  readonly sources = new Set<any>()\n  readonly observers = new Set<never>() // Effects don't have observers\n\n  private isDisposed = false\n  private cleanupFn?: () => void\n  private options: EffectOptions\n  private owner: Owner | null\n\n  constructor(\n    private effectFn: () => undefined | (() => void),\n    options: EffectOptions = {}\n  ) {\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.options = options\n    this.owner = getCurrentOwner()\n\n    if (options.fireImmediately !== false) {\n      this.execute()\n    }\n  }\n\n  /**\n   * Notify method called by unified scheduler\n   */\n  notify(): void {\n    if (this.isDisposed) return\n\n    this.execute()\n  }\n\n  /**\n   * Execute the effect with proper error handling\n   */\n  private execute(): void {\n    if (this.isDisposed) return\n\n    // Cleanup previous effect run\n    if (this.cleanupFn) {\n      try {\n        this.cleanupFn()\n      } catch (error) {\n        console.error('Effect cleanup error:', error)\n      }\n      this.cleanupFn = undefined\n    }\n\n    // Clear existing dependencies\n    for (const source of this.sources) {\n      if ('removeObserver' in source && typeof source.removeObserver === 'function') {\n        source.removeObserver(this)\n      } else if ('observers' in source && source.observers instanceof Set) {\n        source.observers.delete(this)\n      }\n    }\n    this.sources.clear()\n\n    // Execute effect with dependency tracking\n    const previousComputation = getCurrentComputation()\n    // We need to set this as the current computation for dependency tracking\n    const setCurrentComputation = (this as any).setCurrentComputation || (() => {})\n    setCurrentComputation(this)\n\n    try {\n      const result = this.effectFn()\n\n      // Store cleanup function if returned\n      if (typeof result === 'function') {\n        this.cleanupFn = result\n      }\n    } catch (error) {\n      if (this.options.onError) {\n        try {\n          this.options.onError(error as Error)\n        } catch (handlerError) {\n          console.error('Effect error handler threw error:', handlerError)\n          // Re-throw the original error since handler failed\n          throw error\n        }\n      } else {\n        // Don't suppress errors like the old implementation - re-throw them\n        console.error(`Effect ${this.options.debugName || this.id} threw error:`, error)\n        throw error\n      }\n    } finally {\n      setCurrentComputation(previousComputation)\n    }\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    this.isDisposed = true\n\n    // Cleanup effect function\n    if (this.cleanupFn) {\n      try {\n        this.cleanupFn()\n      } catch (error) {\n        console.error('Effect cleanup error:', error)\n      }\n      this.cleanupFn = undefined\n    }\n\n    // Remove from all sources\n    for (const source of this.sources) {\n      if ('removeObserver' in source && typeof source.removeObserver === 'function') {\n        source.removeObserver(this)\n      } else if ('observers' in source && source.observers instanceof Set) {\n        source.observers.delete(this)\n      }\n    }\n    this.sources.clear()\n\n    // Remove from owner cleanup\n    if (this.owner?.cleanups) {\n      const index = this.owner.cleanups.indexOf(this.cleanup.bind(this))\n      if (index >= 0) {\n        this.owner.cleanups.splice(index, 1)\n      }\n    }\n  }\n\n  /**\n   * Dispose the effect (alias for cleanup)\n   */\n  dispose(): void {\n    this.cleanup()\n  }\n\n  /**\n   * Check if effect is disposed\n   */\n  get disposed(): boolean {\n    return this.isDisposed\n  }\n\n  /**\n   * Debug information\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      priority: UpdatePriority[this.priority],\n      debugName: this.options.debugName,\n      disposed: this.isDisposed,\n      sourceCount: this.sources.size,\n      hasCleanup: !!this.cleanupFn,\n    }\n  }\n\n  toString(): string {\n    return `Effect(${this.options.debugName || this.id})`\n  }\n}\n\n/**\n * Create a reactive effect with proper error handling\n *\n * @param effectFn The effect function to run\n * @param options Effect configuration options\n * @returns Cleanup function to dispose the effect\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * const cleanup = createEnhancedEffect(() => {\n *   console.log('Count changed:', count())\n * }, {\n *   debugName: 'countLogger',\n *   onError: (error) => {\n *     console.error('Effect failed:', error)\n *   }\n * })\n *\n * // Later, cleanup when no longer needed\n * cleanup()\n * ```\n */\nexport function createEnhancedEffect(\n  effectFn: () => undefined | (() => void),\n  options?: EffectOptions\n): () => void {\n  const effect = new EffectImpl(effectFn, options)\n\n  // Register cleanup with owner if available\n  const owner = getCurrentOwner()\n  if (owner) {\n    owner.cleanups.push(() => effect.cleanup())\n  }\n\n  return () => effect.cleanup()\n}\n\n/**\n * Create an effect with high priority for user interactions\n */\nexport function createHighPriorityEffect(\n  effectFn: () => undefined | (() => void),\n  options?: Omit<EffectOptions, 'priority'>\n): () => void {\n  return createEnhancedEffect(effectFn, { ...options, priority: UpdatePriority.High })\n}\n\n/**\n * Create an effect with low priority for background tasks\n */\nexport function createLowPriorityEffect(\n  effectFn: () => undefined | (() => void),\n  options?: Omit<EffectOptions, 'priority'>\n): () => void {\n  return createEnhancedEffect(effectFn, { ...options, priority: UpdatePriority.Low })\n}\n\n/**\n * Create an effect that only runs when dependencies change (not immediately)\n */\nexport function createWatchEffect(\n  effectFn: () => undefined | (() => void),\n  options?: Omit<EffectOptions, 'fireImmediately'>\n): () => void {\n  return createEnhancedEffect(effectFn, { ...options, fireImmediately: false })\n}\n\n/**\n * Create an effect with automatic error recovery\n */\nexport function createResilientEffect(\n  effectFn: () => undefined | (() => void),\n  onError?: (error: Error, attempt: number) => boolean, // return true to retry\n  maxRetries = 3,\n  options?: EffectOptions\n): () => void {\n  let attempt = 0\n\n  const resilientFn = () => {\n    try {\n      return effectFn()\n    } catch (error) {\n      attempt++\n\n      if (onError && attempt <= maxRetries && onError(error as Error, attempt)) {\n        // Retry after a short delay\n        setTimeout(() => resilientFn(), attempt * 100)\n        return\n      } else {\n        // Give up and re-throw\n        throw error\n      }\n    }\n  }\n\n  return createEnhancedEffect(resilientFn, {\n    ...options,\n    debugName: `${options?.debugName || 'effect'}(resilient)`,\n  })\n}\n\n/**\n * Batch multiple effect creations for performance\n */\nexport function createEffectBatch(\n  effects: Array<{\n    fn: () => undefined | (() => void)\n    options?: EffectOptions\n  }>\n): () => void {\n  const cleanups = effects.map(({ fn, options }) => createEnhancedEffect(fn, options))\n\n  return () => {\n    cleanups.forEach((cleanup) => cleanup())\n  }\n}\n\n/**\n * Get performance metrics for all effects\n */\nexport function getEffectPerformanceMetrics() {\n  const scheduler = ReactiveScheduler.getInstance()\n  return scheduler.getPerformanceMetrics()\n}\n\n/**\n * Flush all pending effect updates synchronously\n */\nexport function flushEffectUpdates(): void {\n  const scheduler = ReactiveScheduler.getInstance()\n  scheduler.flushSync()\n}\n"],"names":["effectIdCounter","EffectImpl","effectFn","options","__publicField","UpdatePriority","getCurrentOwner","error","source","previousComputation","getCurrentComputation","setCurrentComputation","result","handlerError","index","createEnhancedEffect","effect","owner","createHighPriorityEffect","createLowPriorityEffect","createWatchEffect","createResilientEffect","onError","maxRetries","attempt","resilientFn","createEffectBatch","effects","cleanups","fn","cleanup","getEffectPerformanceMetrics","ReactiveScheduler","flushEffectUpdates"],"mappings":"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"}

package/dist/reactive/enhanced-signal.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./context.cjs"),u=require("./equality.cjs"),a=require("./types.cjs"),n=require("./unified-scheduler.cjs");var d=Object.defineProperty,g=(i,e,t)=>e in i?d(i,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):i[e]=t,s=(i,e,t)=>g(i,typeof e!="symbol"?e+"":e,t);let p=0;class o{constructor(e,t={}){s(this,"id",++p),s(this,"type","signal"),s(this,"priority"),s(this,"observers",new Set),s(this,"_value"),s(this,"scheduler",n.ReactiveScheduler.getInstance()),s(this,"equalsFn"),s(this,"debugName"),s(this,"options"),this._value=e,this.options=t,this.priority=t.priority??n.UpdatePriority.Normal,this.equalsFn=t.equals??u.defaultEquals,this.debugName=t.debugName}getValue(){const e=h.getCurrentComputation();return e&&e.state!==a.ComputationState.Disposed&&(this.observers.add(e),e.sources.add(this)),this._value}peek(){return this._value}setValue(e){const t=typeof e=="function"?e(this._value):e;if(!this.equalsFn(t,this._value)){const r=this._value;this._value=t,process.env.NODE_ENV==="development"&&this.debugName&&console.debug(`[Signal:${this.debugName}] ${r} -> ${t}`),this.scheduler.schedule(this)}return t}notify(){for(const e of this.observers)e.state!==a.ComputationState.Disposed&&(e.state=a.ComputationState.Dirty,"type"in e&&"priority"in e&&this.scheduler.schedule(e))}removeObserver(e){this.observers.delete(e)}cleanup(){for(const e of this.observers)e.sources.delete(this);this.observers.clear()}[Symbol.for("tachui.debug")](){return{id:this.id,type:this.type,value:this._value,observerCount:this.observers.size,priority:n.UpdatePriority[this.priority],debugName:this.debugName,equalsFn:this.equalsFn.name||"anonymous"}}toString(){return`Signal(${this.options.debugName||this.id}): ${this._value}`}}function l(i,e){const t=new o(i,e),r=t.getValue.bind(t);r.peek=t.peek.bind(t);const c=t.setValue.bind(t);return Object.defineProperty(r,Symbol.for("tachui.signal"),{value:t,enumerable:!1}),[r,c]}function f(i,e){return l(i,{...e,equals:u.deepEquals})}function b(i,e){return l(i,{...e,equals:u.shallowEquals})}function S(i){return i[Symbol.for("tachui.signal")]||null}function m(i){return typeof i=="function"&&Symbol.for("tachui.signal")in i}function v(){n.ReactiveScheduler.getInstance().flushSync()}function y(){return n.ReactiveScheduler.getInstance().getPerformanceMetrics()}exports.EnhancedSignalImpl=o;exports.createDeepSignal=f;exports.createEnhancedSignal=l;exports.createShallowSignal=b;exports.flushSignalUpdates=v;exports.getEnhancedSignalImpl=S;exports.getSignalPerformanceMetrics=y;exports.isEnhancedSignal=m;
+//# sourceMappingURL=enhanced-signal.cjs.map

package/dist/reactive/enhanced-signal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-signal.cjs","sources":["../../src/reactive/enhanced-signal.ts"],"sourcesContent":["/**\n * Enhanced Signal Implementation v2.0\n *\n * Integrates with the unified scheduler and provides custom equality functions\n * to fix signal update detection bugs and eliminate race conditions.\n */\n\nimport { getCurrentComputation } from './context'\nimport { defaultEquals, deepEquals, shallowEquals, type EqualityFunction } from './equality'\nimport type { Computation } from './types'\nimport { ComputationState } from './types'\nimport { type ReactiveNode, ReactiveScheduler, UpdatePriority } from './unified-scheduler'\n\nlet signalIdCounter = 0\n\nexport interface SignalOptions<T> {\n  equals?: EqualityFunction<T>\n  priority?: UpdatePriority\n  debugName?: string\n}\n\n/**\n * Enhanced signal implementation with unified scheduler integration\n */\nexport class EnhancedSignalImpl<T> implements ReactiveNode {\n  readonly id = ++signalIdCounter\n  readonly type = 'signal' as const\n  readonly priority: UpdatePriority\n  readonly observers = new Set<Computation>()\n\n  private _value: T\n  private scheduler = ReactiveScheduler.getInstance()\n  private equalsFn: EqualityFunction<T>\n  private debugName?: string\n  private options: SignalOptions<T>\n\n  constructor(initialValue: T, options: SignalOptions<T> = {}) {\n    this._value = initialValue\n    this.options = options\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.equalsFn = options.equals ?? defaultEquals\n    this.debugName = options.debugName\n  }\n\n  /**\n   * Get the current value and track dependency\n   */\n  getValue(): T {\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      // Establish bidirectional relationship\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n    return this._value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    return this._value\n  }\n\n  /**\n   * Set a new value using custom equality function\n   */\n  setValue(newValue: T | ((prev: T) => T)): T {\n    const value =\n      typeof newValue === 'function' ? (newValue as (prev: T) => T)(this._value) : newValue\n\n    // Use custom equality function instead of simple !== check\n    if (!this.equalsFn(value, this._value)) {\n      const oldValue = this._value\n      this._value = value\n\n      if (process.env.NODE_ENV === 'development' && this.debugName) {\n        console.debug(`[Signal:${this.debugName}] ${oldValue} -> ${value}`)\n      }\n\n      // Schedule update through unified scheduler\n      this.scheduler.schedule(this)\n    }\n\n    return value\n  }\n\n  /**\n   * Notify all observers (called by scheduler)\n   */\n  notify(): void {\n    // Mark all observers as dirty and schedule them\n    for (const observer of this.observers) {\n      if (observer.state !== ComputationState.Disposed) {\n        observer.state = ComputationState.Dirty\n\n        // Schedule observer if it's also a ReactiveNode\n        if ('type' in observer && 'priority' in observer) {\n          this.scheduler.schedule(observer as any)\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    // Complete bidirectional cleanup to prevent memory leaks\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n  }\n\n  /**\n   * Get debug information about this signal\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      value: this._value,\n      observerCount: this.observers.size,\n      priority: UpdatePriority[this.priority],\n      debugName: this.debugName,\n      equalsFn: this.equalsFn.name || 'anonymous',\n    }\n  }\n\n  toString(): string {\n    return `Signal(${this.options.debugName || this.id}): ${this._value}`\n  }\n}\n\n/**\n * Signal setter function type\n */\nexport type SignalSetter<T> = (value: T | ((prev: T) => T)) => T\n\n/**\n * Create a new enhanced reactive signal with custom equality\n */\nexport function createEnhancedSignal<T>(\n  initialValue: T,\n  options?: SignalOptions<T>\n): [() => T, SignalSetter<T>] {\n  const signal = new EnhancedSignalImpl(initialValue, options)\n\n  const getter = signal.getValue.bind(signal) as (() => T) & { peek: () => T }\n  getter.peek = signal.peek.bind(signal)\n\n  const setter: SignalSetter<T> = signal.setValue.bind(signal)\n\n  // Add debug information for compatibility\n  Object.defineProperty(getter, Symbol.for('tachui.signal'), {\n    value: signal,\n    enumerable: false,\n  })\n\n  return [getter, setter]\n}\n\n/**\n * Create a signal with deep equality comparison\n */\nexport function createDeepSignal<T>(\n  initialValue: T,\n  options?: Omit<SignalOptions<T>, 'equals'>\n): [() => T, SignalSetter<T>] {\n  return createEnhancedSignal(initialValue, {\n    ...options,\n    equals: deepEquals,\n  })\n}\n\n/**\n * Create a signal with shallow equality comparison\n */\nexport function createShallowSignal<T>(\n  initialValue: T,\n  options?: Omit<SignalOptions<T>, 'equals'>\n): [() => T, SignalSetter<T>] {\n  return createEnhancedSignal(initialValue, {\n    ...options,\n    equals: shallowEquals,\n  })\n}\n\n/**\n * Get the underlying signal implementation for debugging\n */\nexport function getEnhancedSignalImpl<T>(\n  signal: (() => T) & { peek: () => T }\n): EnhancedSignalImpl<T> | null {\n  return (signal as any)[Symbol.for('tachui.signal')] || null\n}\n\n/**\n * Type guard to check if a value is an enhanced signal\n */\nexport function isEnhancedSignal<T = any>(value: any): value is (() => T) & { peek: () => T } {\n  return typeof value === 'function' && Symbol.for('tachui.signal') in value\n}\n\n/**\n * Flush all pending signal updates synchronously\n */\nexport function flushSignalUpdates(): void {\n  const scheduler = ReactiveScheduler.getInstance()\n  scheduler.flushSync()\n}\n\n/**\n * Get performance metrics for all signals\n */\nexport function getSignalPerformanceMetrics() {\n  const scheduler = ReactiveScheduler.getInstance()\n  return scheduler.getPerformanceMetrics()\n}\n"],"names":["signalIdCounter","EnhancedSignalImpl","initialValue","options","__publicField","ReactiveScheduler","UpdatePriority","defaultEquals","computation","getCurrentComputation","ComputationState","newValue","value","oldValue","observer","createEnhancedSignal","signal","getter","setter","createDeepSignal","deepEquals","createShallowSignal","shallowEquals","getEnhancedSignalImpl","isEnhancedSignal","flushSignalUpdates","getSignalPerformanceMetrics"],"mappings":"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"}

package/dist/reactive/enhanced-signal.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Enhanced Signal Implementation v2.0
+ *
+ * Integrates with the unified scheduler and provides custom equality functions
+ * to fix signal update detection bugs and eliminate race conditions.
+ */
+import { type EqualityFunction } from './equality';
+import type { Computation } from './types';
+import { type ReactiveNode, UpdatePriority } from './unified-scheduler';
+export interface SignalOptions<T> {
+    equals?: EqualityFunction<T>;
+    priority?: UpdatePriority;
+    debugName?: string;
+}
+/**
+ * Enhanced signal implementation with unified scheduler integration
+ */
+export declare class EnhancedSignalImpl<T> implements ReactiveNode {
+    readonly id: number;
+    readonly type: "signal";
+    readonly priority: UpdatePriority;
+    readonly observers: Set<Computation>;
+    private _value;
+    private scheduler;
+    private equalsFn;
+    private debugName?;
+    private options;
+    constructor(initialValue: T, options?: SignalOptions<T>);
+    /**
+     * Get the current value and track dependency
+     */
+    getValue(): T;
+    /**
+     * Get the current value without tracking dependency
+     */
+    peek(): T;
+    /**
+     * Set a new value using custom equality function
+     */
+    setValue(newValue: T | ((prev: T) => T)): T;
+    /**
+     * Notify all observers (called by scheduler)
+     */
+    notify(): void;
+    /**
+     * Remove an observer (cleanup)
+     */
+    removeObserver(computation: Computation): void;
+    /**
+     * Complete cleanup for memory management
+     */
+    cleanup(): void;
+    toString(): string;
+}
+/**
+ * Signal setter function type
+ */
+export type SignalSetter<T> = (value: T | ((prev: T) => T)) => T;
+/**
+ * Create a new enhanced reactive signal with custom equality
+ */
+export declare function createEnhancedSignal<T>(initialValue: T, options?: SignalOptions<T>): [() => T, SignalSetter<T>];
+/**
+ * Create a signal with deep equality comparison
+ */
+export declare function createDeepSignal<T>(initialValue: T, options?: Omit<SignalOptions<T>, 'equals'>): [() => T, SignalSetter<T>];
+/**
+ * Create a signal with shallow equality comparison
+ */
+export declare function createShallowSignal<T>(initialValue: T, options?: Omit<SignalOptions<T>, 'equals'>): [() => T, SignalSetter<T>];
+/**
+ * Get the underlying signal implementation for debugging
+ */
+export declare function getEnhancedSignalImpl<T>(signal: (() => T) & {
+    peek: () => T;
+}): EnhancedSignalImpl<T> | null;
+/**
+ * Type guard to check if a value is an enhanced signal
+ */
+export declare function isEnhancedSignal<T = any>(value: any): value is (() => T) & {
+    peek: () => T;
+};
+/**
+ * Flush all pending signal updates synchronously
+ */
+export declare function flushSignalUpdates(): void;
+/**
+ * Get performance metrics for all signals
+ */
+export declare function getSignalPerformanceMetrics(): import("./unified-scheduler").ReactivePerformanceMetrics;
+//# sourceMappingURL=enhanced-signal.d.ts.map

package/dist/reactive/enhanced-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-signal.d.ts","sourceRoot":"","sources":["../../src/reactive/enhanced-signal.ts"],"names":[],"mappings":"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"}