@tachui/core 0.7.0-alpha1 → 0.8.0-alpha

package/dist/reactive/index.js

@@ -1,95 +1,493 @@
-import { createCleanupGroup as r, createEventListener as a, createInterval as c, createResource as o, createTimeout as n, dispose as i, onCleanup as l } from "./cleanup.js";
-import { createComputed as s, createMemo as g, isComputed as u } from "./computed.js";
-import { batch as h, createRoot as E, getOwner as d, getReactiveContext as p, runWithOwner as S, untrack as x } from "./context.js";
-import { createEffect as y, createOnceEffect as q, createRenderEffect as v, createSyncEffect as C } from "./effect.js";
-import { createEffectBatch as b, createEnhancedEffect as w, createHighPriorityEffect as M, createLowPriorityEffect as O, createResilientEffect as T, createWatchEffect as U, flushEffectUpdates as I, getEffectPerformanceMetrics as W } from "./enhanced-effect.js";
-import { createDeepSignal as L, createEnhancedSignal as j, createShallowSignal as k, flushSignalUpdates as z, getEnhancedSignalImpl as B, getSignalPerformanceMetrics as A, isEnhancedSignal as G } from "./enhanced-signal.js";
-import { combineEquals as F, createArrayEquals as J, createObjectEquals as K, createSelectorEquals as N, debugEquals as Q, deepEquals as V, defaultEquals as X, jsonEquals as Y, shallowEquals as Z, structuralEquals as _ } from "./equality.js";
-import { analyzeReactivePerformance as ee, analyzeSignalUsage as te, createLegacySignal as re, createMigrationReport as ae, enableReactiveDebugging as ce, getMigrationStats as oe, migrateBatch as ne, migrateReactiveCode as ie, migrateToEnhancedSignal as le, resetMigrationStats as fe, setMigrationWarnings as se } from "./migration.js";
-import { createDetachedRoot as ue, getOwnerChain as me, getRootOwner as he, isReactiveContext as Ee, runOutsideReactiveContext as de } from "./ownership.js";
-import { TaskPriority as Se, enableScheduling as xe, getScheduler as Re, scheduleIdle as ye, scheduleUpdate as qe, scheduleWithPriority as ve, setScheduler as Ce } from "./scheduler.js";
-import { createSignal as be, flushSync as we, getSignalImpl as Me, isSignal as Oe } from "./signal.js";
-import { detectSystemTheme as Ue, getCurrentTheme as Ie, getThemeSignal as We, setTheme as De } from "./theme.js";
-import { ReactiveError as je, ReactiveScheduler as ke, UpdatePriority as ze } from "./unified-scheduler.js";
+import { W as g, U as u, O as c, V as v, y as b, w as E, v as y, G as C, g as w, l as h, r as q, k as F } from "../scheduler-BKeqwrYE.js";
+import { R as he, T as pe, j as me, n as ge, p as ve, c as be, a as ye, b as Se, h as Ee, q as Ce, d as we, s as qe, e as Fe, t as Ne, K as _e, f as Oe, A as Re, H as $e, L as Ie, m as xe, B as Pe, I as De, M as Ue, i as Me, J as Te, x as ze, o as Ae, C as Le, D as Ve, E as We, F as je, N as He, z as Be, u as Ge } from "../scheduler-BKeqwrYE.js";
+import { c as Je, a as Ke, b as Qe, d as Xe } from "../effect-B9Knft0b.js";
+import { ComputationState as d } from "./types.js";
+var N = Object.defineProperty, _ = (t, e, r) => e in t ? N(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, o = (t, e, r) => _(t, typeof e != "symbol" ? e + "" : e, r);
+let O = 0;
+class R {
+  constructor(e, r = {}) {
+    this.effectFn = e, o(this, "id", ++O), o(this, "type", "effect"), o(this, "priority"), o(this, "sources", /* @__PURE__ */ new Set()), o(this, "observers", /* @__PURE__ */ new Set()), o(this, "isDisposed", !1), o(this, "cleanupFn"), o(this, "options"), o(this, "owner"), this.priority = r.priority ?? u.Normal, this.options = r, this.owner = g(), r.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 (s) {
+        console.error("Effect cleanup error:", s);
+      }
+      this.cleanupFn = void 0;
+    }
+    for (const s of this.sources)
+      "removeObserver" in s && typeof s.removeObserver == "function" ? s.removeObserver(this) : "observers" in s && s.observers instanceof Set && s.observers.delete(this);
+    this.sources.clear();
+    const e = v(), r = this.setCurrentComputation || (() => {
+    });
+    r(this);
+    try {
+      const s = this.effectFn();
+      typeof s == "function" && (this.cleanupFn = s);
+    } catch (s) {
+      if (this.options.onError)
+        try {
+          this.options.onError(s);
+        } catch (n) {
+          throw console.error("Effect error handler threw error:", n), s;
+        }
+      else
+        throw console.error(`Effect ${this.options.debugName || this.id} threw error:`, s), s;
+    } finally {
+      r(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: u[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 l(t, e) {
+  const r = new R(t, e), s = g();
+  return s && s.cleanups.push(() => r.cleanup()), () => r.cleanup();
+}
+function A(t, e) {
+  return l(t, { ...e, priority: u.High });
+}
+function L(t, e) {
+  return l(t, { ...e, priority: u.Low });
+}
+function V(t, e) {
+  return l(t, { ...e, fireImmediately: !1 });
+}
+function W(t, e, r = 3, s) {
+  let n = 0;
+  const f = () => {
+    try {
+      return t();
+    } catch (m) {
+      if (n++, e && n <= r && e(m, n)) {
+        setTimeout(() => f(), n * 100);
+        return;
+      } else
+        throw m;
+    }
+  };
+  return l(f, {
+    ...s,
+    debugName: `${s?.debugName || "effect"}(resilient)`
+  });
+}
+function j(t) {
+  const e = t.map(({ fn: r, options: s }) => l(r, s));
+  return () => {
+    e.forEach((r) => r());
+  };
+}
+function H() {
+  return c.getInstance().getPerformanceMetrics();
+}
+function B() {
+  c.getInstance().flushSync();
+}
+var $ = Object.defineProperty, I = (t, e, r) => e in t ? $(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, a = (t, e, r) => I(t, typeof e != "symbol" ? e + "" : e, r);
+let x = 0;
+class P {
+  constructor(e, r = {}) {
+    a(this, "id", ++x), a(this, "type", "signal"), a(this, "priority"), a(this, "observers", /* @__PURE__ */ new Set()), a(this, "_value"), a(this, "scheduler", c.getInstance()), a(this, "equalsFn"), a(this, "debugName"), a(this, "options"), this._value = e, this.options = r, this.priority = r.priority ?? u.Normal, this.equalsFn = r.equals ?? E, this.debugName = r.debugName;
+  }
+  /**
+   * Get the current value and track dependency
+   */
+  getValue() {
+    const e = v();
+    return e && e.state !== d.Disposed && (this.observers.add(e), e.sources.add(this)), this._value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Set a new value using custom equality function
+   */
+  setValue(e) {
+    const r = typeof e == "function" ? e(this._value) : e;
+    if (!this.equalsFn(r, this._value)) {
+      const s = this._value;
+      this._value = r, process.env.NODE_ENV === "development" && this.debugName && console.debug(`[Signal:${this.debugName}] ${s} -> ${r}`), this.scheduler.schedule(this);
+    }
+    return r;
+  }
+  /**
+   * Notify all observers (called by scheduler)
+   */
+  notify() {
+    for (const e of this.observers)
+      e.state !== d.Disposed && (e.state = d.Dirty, "type" in e && "priority" in e && this.scheduler.schedule(e));
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e);
+  }
+  /**
+   * Complete cleanup for memory management
+   */
+  cleanup() {
+    for (const e of this.observers)
+      e.sources.delete(this);
+    this.observers.clear();
+  }
+  /**
+   * Get debug information about this signal
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      type: this.type,
+      value: this._value,
+      observerCount: this.observers.size,
+      priority: u[this.priority],
+      debugName: this.debugName,
+      equalsFn: this.equalsFn.name || "anonymous"
+    };
+  }
+  toString() {
+    return `Signal(${this.options.debugName || this.id}): ${this._value}`;
+  }
+}
+function p(t, e) {
+  const r = new P(t, e), s = r.getValue.bind(r);
+  s.peek = r.peek.bind(r);
+  const n = r.setValue.bind(r);
+  return Object.defineProperty(s, Symbol.for("tachui.signal"), {
+    value: r,
+    enumerable: !1
+  }), [s, n];
+}
+function G(t, e) {
+  return p(t, {
+    ...e,
+    equals: y
+  });
+}
+function k(t, e) {
+  return p(t, {
+    ...e,
+    equals: b
+  });
+}
+function J(t) {
+  return t[Symbol.for("tachui.signal")] || null;
+}
+function K(t) {
+  return typeof t == "function" && Symbol.for("tachui.signal") in t;
+}
+function Q() {
+  c.getInstance().flushSync();
+}
+function X() {
+  return c.getInstance().getPerformanceMetrics();
+}
+let S = !0, i = {
+  signalsConverted: 0,
+  computedsConverted: 0,
+  effectsConverted: 0,
+  errorsFixed: 0
+};
+function Y(t) {
+  return S && console.warn(
+    "createLegacySignal is deprecated. Use createSignal() or createEnhancedSignal() instead. See: https://docs.tachui.dev/migration/reactive-system"
+  ), i.signalsConverted++, C(t);
+}
+function D(t, e) {
+  const r = t[0]();
+  let s;
+  switch (e?.equals) {
+    case "deep":
+      s = y;
+      break;
+    case "shallow":
+      s = b;
+      break;
+    case "custom":
+      s = e.customEquals;
+      break;
+    default:
+      s = void 0;
+  }
+  return i.signalsConverted++, p(r, {
+    equals: s,
+    priority: e?.priority,
+    debugName: e?.debugName
+  });
+}
+function Z(t) {
+  const e = t(), r = [];
+  let s = "enhanced";
+  return typeof e == "object" && e !== null && (Array.isArray(e) ? (r.push("Consider using deepEquals for array values to detect mutations"), r.push("Use createDeepSignal() for automatic deep comparison"), s = "deep") : (r.push("Consider using shallowEquals for object values with simple properties"), r.push("Use createShallowSignal() for automatic shallow comparison"), s = "shallow")), r.length === 0 && r.push("Signal looks good for reference equality"), { recommendations: r, suggestedMigration: s };
+}
+function ee(t) {
+  const e = {
+    signals: [],
+    computeds: [],
+    effects: [],
+    cleanup: () => {
+    }
+  };
+  t.signals && (e.signals = t.signals.map(
+    ({ original: s, options: n }) => D(s, n)
+  )), t.computeds && (e.computeds = t.computeds.map(({ original: s, options: n }) => (i.computedsConverted++, w(s, n))));
+  const r = [];
+  return t.effects && t.effects.forEach(({ original: s, options: n }) => {
+    i.effectsConverted++;
+    const f = l(s, n);
+    r.push(f);
+  }), e.cleanup = () => {
+    r.forEach((s) => s());
+  }, e;
+}
+function te(t) {
+  const e = [];
+  let r = t;
+  return [
+    {
+      from: /createSignal\(/g,
+      to: "createEnhancedSignal(",
+      description: "Upgraded createSignal to createEnhancedSignal"
+    },
+    {
+      from: /createComputed\(([^,]+)\)/g,
+      to: "createComputed($1, { debugName: 'computed' })",
+      description: "Added debug name to createComputed"
+    },
+    {
+      from: /createEffect\(([^,]+)\)/g,
+      to: "createEnhancedEffect($1, { debugName: 'effect' })",
+      description: "Upgraded createEffect to createEnhancedEffect with debug name"
+    }
+  ].forEach((n) => {
+    r.match(n.from) && (r = r.replace(n.from, n.to), e.push(n.description));
+  }), { newCode: r, transformations: e };
+}
+function U() {
+  const t = c.getInstance(), e = t.getPerformanceMetrics(), r = [];
+  let s = 100;
+  return e.errorCount > 0 && (r.push(`Fix ${e.errorCount} reactive errors for better stability`), s -= e.errorCount * 5), e.averageUpdateTime > 16 && (r.push("Update times exceed 16ms - consider optimizing computations"), s -= 20), e.totalNodes > 1e3 && (r.push("High number of reactive nodes - consider batching updates"), s -= 10), {
+    scheduler: t.getDebugInfo(),
+    signals: {
+      total: i.signalsConverted,
+      recommendations: ["Use appropriate equality functions for your data types"]
+    },
+    computeds: {
+      total: i.computedsConverted,
+      recommendations: ["Add error recovery for critical computations"]
+    },
+    effects: {
+      total: i.effectsConverted,
+      recommendations: ["Use appropriate priorities for different effect types"]
+    },
+    overallScore: Math.max(0, s),
+    recommendations: r
+  };
+}
+function re(t = { verbose: !1 }) {
+  const e = c.getInstance(), r = (n) => {
+    console.error("🔥 Reactive System Error:", n), i.errorsFixed++;
+  }, s = e.onError(r);
+  return t.verbose && (console.log("🔍 Reactive debugging enabled"), console.log("📊 Migration stats:", i)), () => {
+    s(), t.verbose && console.log("🔍 Reactive debugging disabled");
+  };
+}
+function se() {
+  return { ...i };
+}
+function ne() {
+  i = {
+    signalsConverted: 0,
+    computedsConverted: 0,
+    effectsConverted: 0,
+    errorsFixed: 0
+  };
+}
+function ie(t) {
+  S = t;
+}
+function oe() {
+  const t = U();
+  return `
+# TachUI Reactive System Migration Report
+
+## Statistics
+- Signals converted: ${i.signalsConverted}
+- Computeds converted: ${i.computedsConverted}
+- Effects converted: ${i.effectsConverted}
+- Errors fixed: ${i.errorsFixed}
+
+## Performance Score: ${t.overallScore}/100
+
+## Recommendations
+${t.recommendations.map((e) => `- ${e}`).join(`
+`)}
+
+## Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+}
+function ae() {
+  return h() !== null;
+}
+function M(t) {
+  return q(null, t);
+}
+function ce(t) {
+  return M(() => F(t));
+}
+function ue() {
+  let t = h();
+  if (!t) return null;
+  for (; t.parent; )
+    t = t.parent;
+  return t;
+}
+function le() {
+  const t = [];
+  let e = h();
+  for (; e; )
+    t.push(e), e = e.parent;
+  return t;
+}
 export {
-  je as ReactiveError,
-  ke as ReactiveScheduler,
-  Se as TaskPriority,
-  ze as UpdatePriority,
-  ee as analyzeReactivePerformance,
-  te as analyzeSignalUsage,
-  h as batch,
-  F as combineEquals,
-  J as createArrayEquals,
-  r as createCleanupGroup,
-  s as createComputed,
-  L as createDeepSignal,
-  ue as createDetachedRoot,
-  y as createEffect,
-  b as createEffectBatch,
-  w as createEnhancedEffect,
-  j as createEnhancedSignal,
-  a as createEventListener,
-  M as createHighPriorityEffect,
-  c as createInterval,
-  re as createLegacySignal,
-  O as createLowPriorityEffect,
-  g as createMemo,
-  ae as createMigrationReport,
-  K as createObjectEquals,
-  q as createOnceEffect,
-  v as createRenderEffect,
-  T as createResilientEffect,
-  o as createResource,
-  E as createRoot,
-  N as createSelectorEquals,
+  he as ReactiveError,
+  c as ReactiveScheduler,
+  pe as TaskPriority,
+  u as UpdatePriority,
+  U as analyzeReactivePerformance,
+  Z as analyzeSignalUsage,
+  me as batch,
+  ge as combineEquals,
+  ve as createArrayEquals,
+  be as createCleanupGroup,
+  w as createComputed,
+  G as createDeepSignal,
+  ce as createDetachedRoot,
+  Je as createEffect,
+  j as createEffectBatch,
+  l as createEnhancedEffect,
+  p as createEnhancedSignal,
+  ye as createEventListener,
+  A as createHighPriorityEffect,
+  Se as createInterval,
+  Y as createLegacySignal,
+  L as createLowPriorityEffect,
+  Ee as createMemo,
+  oe as createMigrationReport,
+  Ce as createObjectEquals,
+  Ke as createOnceEffect,
+  Qe as createRenderEffect,
+  W as createResilientEffect,
+  we as createResource,
+  F as createRoot,
+  qe as createSelectorEquals,
   k as createShallowSignal,
-  be as createSignal,
-  C as createSyncEffect,
-  n as createTimeout,
-  U as createWatchEffect,
-  Q as debugEquals,
-  V as deepEquals,
-  X as defaultEquals,
-  Ue as detectSystemTheme,
-  i as dispose,
-  ce as enableReactiveDebugging,
-  xe as enableScheduling,
-  I as flushEffectUpdates,
-  z as flushSignalUpdates,
-  we as flushSync,
+  C as createSignal,
+  Xe as createSyncEffect,
+  Fe as createTimeout,
+  V as createWatchEffect,
+  Ne as debugEquals,
+  y as deepEquals,
+  E as defaultEquals,
+  _e as detectSystemTheme,
+  Oe as dispose,
+  re as enableReactiveDebugging,
+  Re as enableScheduling,
+  B as flushEffectUpdates,
+  Q as flushSignalUpdates,
+  $e as flushSync,
   Ie as getCurrentTheme,
-  W as getEffectPerformanceMetrics,
-  B as getEnhancedSignalImpl,
-  oe as getMigrationStats,
-  d as getOwner,
-  me as getOwnerChain,
-  p as getReactiveContext,
-  he as getRootOwner,
-  Re as getScheduler,
-  Me as getSignalImpl,
-  A as getSignalPerformanceMetrics,
-  We as getThemeSignal,
-  u as isComputed,
-  G as isEnhancedSignal,
-  Ee as isReactiveContext,
-  Oe as isSignal,
-  Y as jsonEquals,
-  ne as migrateBatch,
-  ie as migrateReactiveCode,
-  le as migrateToEnhancedSignal,
-  l as onCleanup,
-  fe as resetMigrationStats,
-  de as runOutsideReactiveContext,
-  S as runWithOwner,
-  ye as scheduleIdle,
-  qe as scheduleUpdate,
-  ve as scheduleWithPriority,
-  se as setMigrationWarnings,
-  Ce as setScheduler,
-  De as setTheme,
-  Z as shallowEquals,
-  _ as structuralEquals,
-  x as untrack
+  H as getEffectPerformanceMetrics,
+  J as getEnhancedSignalImpl,
+  se as getMigrationStats,
+  h as getOwner,
+  le as getOwnerChain,
+  xe as getReactiveContext,
+  ue as getRootOwner,
+  Pe as getScheduler,
+  De as getSignalImpl,
+  X as getSignalPerformanceMetrics,
+  Ue as getThemeSignal,
+  Me as isComputed,
+  K as isEnhancedSignal,
+  ae as isReactiveContext,
+  Te as isSignal,
+  ze as jsonEquals,
+  ee as migrateBatch,
+  te as migrateReactiveCode,
+  D as migrateToEnhancedSignal,
+  Ae as onCleanup,
+  ne as resetMigrationStats,
+  M as runOutsideReactiveContext,
+  q as runWithOwner,
+  Le as scheduleIdle,
+  Ve as scheduleUpdate,
+  We as scheduleWithPriority,
+  ie as setMigrationWarnings,
+  je as setScheduler,
+  He as setTheme,
+  b as shallowEquals,
+  Be as structuralEquals,
+  Ge as untrack
 };
-//# sourceMappingURL=index.js.map

package/dist/reactive/types.js

@@ -2,4 +2,3 @@ var s = /* @__PURE__ */ ((r) => (r[r.Clean = 0] = "Clean", r[r.Check = 1] = "Che
 export {
   s as ComputationState
 };
-//# sourceMappingURL=types.js.map