@tachui/core 0.8.0-alpha → 0.8.5-alpha

package/dist/signal-list-BdpxSodS.js

@@ -0,0 +1,525 @@
+import { l as I, U as m, L as p, k as $, F as q, B as A, A as x, c as y, a as L, o as E, r as z, n as V } from "./theme-BFaKUcjZ.js";
+import { ComputationState as S } from "@tachui/types/reactive";
+var B = Object.defineProperty, H = (t, e, r) => e in t ? B(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, l = (t, e, r) => H(t, typeof e != "symbol" ? e + "" : e, r);
+let T = 0;
+class W {
+  constructor(e, r = {}) {
+    this.effectFn = e, l(this, "id", ++T), l(this, "type", "effect"), l(this, "priority"), l(this, "sources", /* @__PURE__ */ new Set()), l(this, "observers", /* @__PURE__ */ new Set()), l(this, "isDisposed", !1), l(this, "cleanupFn"), l(this, "options"), l(this, "owner"), this.priority = r.priority ?? m.Normal, this.options = r, this.owner = I(), 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 = $(), 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 (i) {
+          throw console.error("Effect error handler threw error:", i), 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: m[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 v(t, e) {
+  const r = new W(t, e), s = I();
+  return s && s.cleanups.push(() => r.cleanup()), () => r.cleanup();
+}
+function ie(t, e) {
+  return v(t, { ...e, priority: m.High });
+}
+function ae(t, e) {
+  return v(t, { ...e, priority: m.Low });
+}
+function ce(t, e) {
+  return v(t, { ...e, fireImmediately: !1 });
+}
+function ue(t, e, r = 3, s) {
+  let i = 0;
+  const d = () => {
+    try {
+      return t();
+    } catch (h) {
+      if (i++, e && i <= r && e(h, i)) {
+        setTimeout(() => d(), i * 100);
+        return;
+      } else
+        throw h;
+    }
+  };
+  return v(d, {
+    ...s,
+    debugName: `${s?.debugName || "effect"}(resilient)`
+  });
+}
+function le(t) {
+  const e = t.map(({ fn: r, options: s }) => v(r, s));
+  return () => {
+    e.forEach((r) => r());
+  };
+}
+function fe() {
+  return p.getInstance().getPerformanceMetrics();
+}
+function de() {
+  p.getInstance().flushSync();
+}
+var j = Object.defineProperty, k = (t, e, r) => e in t ? j(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, f = (t, e, r) => k(t, typeof e != "symbol" ? e + "" : e, r);
+let G = 0;
+class K {
+  constructor(e, r = {}) {
+    f(this, "id", ++G), f(this, "type", "signal"), f(this, "priority"), f(this, "observers", /* @__PURE__ */ new Set()), f(this, "_value"), f(this, "scheduler", p.getInstance()), f(this, "equalsFn"), f(this, "debugName"), f(this, "options"), this._value = e, this.options = r, this.priority = r.priority ?? m.Normal, this.equalsFn = r.equals ?? A, this.debugName = r.debugName;
+  }
+  /**
+   * Get the current value and track dependency
+   */
+  getValue() {
+    const e = $();
+    return e && e.state !== S.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 !== S.Disposed && (e.state = S.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: m[this.priority],
+      debugName: this.debugName,
+      equalsFn: this.equalsFn.name || "anonymous"
+    };
+  }
+  toString() {
+    return `Signal(${this.options.debugName || this.id}): ${this._value}`;
+  }
+}
+function C(t, e) {
+  const r = new K(t, e), s = r.getValue.bind(r);
+  s.peek = r.peek.bind(r);
+  const i = r.setValue.bind(r);
+  return Object.defineProperty(s, Symbol.for("tachui.signal"), {
+    value: r,
+    enumerable: !1
+  }), [s, i];
+}
+function he(t, e) {
+  return C(t, {
+    ...e,
+    equals: x
+  });
+}
+function pe(t, e) {
+  return C(t, {
+    ...e,
+    equals: q
+  });
+}
+function ge(t) {
+  return t[Symbol.for("tachui.signal")] || null;
+}
+function me(t) {
+  return typeof t == "function" && Symbol.for("tachui.signal") in t;
+}
+function ve() {
+  p.getInstance().flushSync();
+}
+function be() {
+  return p.getInstance().getPerformanceMetrics();
+}
+let O = !0, c = {
+  signalsConverted: 0,
+  computedsConverted: 0,
+  effectsConverted: 0,
+  errorsFixed: 0
+};
+function ye(t) {
+  return O && console.warn(
+    "createLegacySignal is deprecated. Use createSignal() or createEnhancedSignal() instead. See: https://docs.tachui.dev/migration/reactive-system"
+  ), c.signalsConverted++, y(t);
+}
+function J(t, e) {
+  const r = t[0]();
+  let s;
+  switch (e?.equals) {
+    case "deep":
+      s = x;
+      break;
+    case "shallow":
+      s = q;
+      break;
+    case "custom":
+      s = e.customEquals;
+      break;
+    default:
+      s = void 0;
+  }
+  return c.signalsConverted++, C(r, {
+    equals: s,
+    priority: e?.priority,
+    debugName: e?.debugName
+  });
+}
+function Se(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: i }) => J(s, i)
+  )), t.computeds && (e.computeds = t.computeds.map(({ original: s, options: i }) => (c.computedsConverted++, L(s, i))));
+  const r = [];
+  return t.effects && t.effects.forEach(({ original: s, options: i }) => {
+    c.effectsConverted++;
+    const d = v(s, i);
+    r.push(d);
+  }), e.cleanup = () => {
+    r.forEach((s) => s());
+  }, e;
+}
+function Ce(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((i) => {
+    r.match(i.from) && (r = r.replace(i.from, i.to), e.push(i.description));
+  }), { newCode: r, transformations: e };
+}
+function Q() {
+  const t = p.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: c.signalsConverted,
+      recommendations: ["Use appropriate equality functions for your data types"]
+    },
+    computeds: {
+      total: c.computedsConverted,
+      recommendations: ["Add error recovery for critical computations"]
+    },
+    effects: {
+      total: c.effectsConverted,
+      recommendations: ["Use appropriate priorities for different effect types"]
+    },
+    overallScore: Math.max(0, s),
+    recommendations: r
+  };
+}
+function we(t = { verbose: !1 }) {
+  const e = p.getInstance(), r = (i) => {
+    console.error("🔥 Reactive System Error:", i), c.errorsFixed++;
+  }, s = e.onError(r);
+  return t.verbose && (console.log("🔍 Reactive debugging enabled"), console.log("📊 Migration stats:", c)), () => {
+    s(), t.verbose && console.log("🔍 Reactive debugging disabled");
+  };
+}
+function Ne() {
+  return { ...c };
+}
+function _e() {
+  c = {
+    signalsConverted: 0,
+    computedsConverted: 0,
+    effectsConverted: 0,
+    errorsFixed: 0
+  };
+}
+function Fe(t) {
+  O = t;
+}
+function Ie() {
+  const t = Q();
+  return `
+# TachUI Reactive System Migration Report
+
+## Statistics
+- Signals converted: ${c.signalsConverted}
+- Computeds converted: ${c.computedsConverted}
+- Effects converted: ${c.effectsConverted}
+- Errors fixed: ${c.errorsFixed}
+
+## Performance Score: ${t.overallScore}/100
+
+## Recommendations
+${t.recommendations.map((e) => `- ${e}`).join(`
+`)}
+
+## Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+}
+function $e() {
+  return E() !== null;
+}
+function X(t) {
+  return z(null, t);
+}
+function qe(t) {
+  return X(() => V(t));
+}
+function xe() {
+  let t = E();
+  if (!t) return null;
+  for (; t.parent; )
+    t = t.parent;
+  return t;
+}
+function Oe() {
+  const t = [];
+  let e = E();
+  for (; e; )
+    t.push(e), e = e.parent;
+  return t;
+}
+function Y(t, e) {
+  const r = /* @__PURE__ */ new Map(), [s, i] = y(t.map(e)), d = s, h = () => s.peek(), b = (o) => {
+    const n = h();
+    R(n, o) || i(o);
+  }, R = (o, n) => {
+    if (o.length !== n.length) return !1;
+    for (let a = 0; a < o.length; a++)
+      if (o[a] !== n[a]) return !1;
+    return !0;
+  };
+  t.forEach((o) => {
+    const n = e(o);
+    r.set(n, y(o));
+  });
+  const D = (o) => {
+    const n = r.get(o);
+    if (!n)
+      throw new Error(`SignalList: Item with key "${String(o)}" not found`);
+    return n[0];
+  }, P = (o, n) => {
+    const a = r.get(o);
+    if (a)
+      a[1](n);
+    else {
+      r.set(o, y(n));
+      const u = h();
+      b([...u, o]);
+    }
+  }, U = (o, n) => {
+    if (o.length !== n.length)
+      return !0;
+    const a = new Set(o), u = new Set(n);
+    if (a.size !== u.size)
+      return !0;
+    for (const N of n)
+      if (!a.has(N))
+        return !0;
+    return !1;
+  }, M = (o) => {
+    const n = o.map(e), a = new Set(n), u = h();
+    o.forEach((g) => {
+      const _ = e(g), F = r.get(_);
+      F ? F[1](g) : r.set(_, y(g));
+    }), u.forEach((g) => {
+      a.has(g) || r.delete(g);
+    }), U(u, n) && b(n);
+  }, w = (o, n) => {
+    const a = r.get(o);
+    if (!a) return null;
+    const u = a[0];
+    return u ? n ? u() : typeof u.peek == "function" ? u.peek() : u() : null;
+  };
+  return [
+    () => d().map((n) => w(n, !0)).filter((n) => n !== null),
+    {
+      ids: d,
+      get: D,
+      update: P,
+      set: M,
+      clear: () => {
+        r.clear(), b([]);
+      },
+      remove: (o) => {
+        r.delete(o);
+        const n = h();
+        b(n.filter((a) => a !== o));
+      },
+      reorder: (o) => {
+        if (!o.every((a) => r.has(a)))
+          throw new Error("[SignalList.reorder] Cannot reorder with unknown ids");
+        b([...o]);
+      },
+      getAll: () => h().map((n) => w(n, !1)).filter((n) => n !== null)
+    }
+  ];
+}
+function Re(t, e) {
+  const [, r] = Y(t, e);
+  return r;
+}
+export {
+  qe as A,
+  Oe as B,
+  xe as C,
+  $e as D,
+  X as E,
+  Y as F,
+  Re as G,
+  v as a,
+  ie as b,
+  le as c,
+  ae as d,
+  ue as e,
+  ce as f,
+  de as g,
+  fe as h,
+  he as i,
+  C as j,
+  pe as k,
+  ve as l,
+  ge as m,
+  be as n,
+  me as o,
+  Q as p,
+  Se as q,
+  ye as r,
+  Ie as s,
+  we as t,
+  Ne as u,
+  Ee as v,
+  Ce as w,
+  J as x,
+  _e as y,
+  Fe as z
+};