@tachui/core 0.8.0-alpha → 0.8.5-alpha

package/dist/theme-BFaKUcjZ.js

@@ -0,0 +1,677 @@
+import { ComputationState as o } from "@tachui/types/reactive";
+var M = Object.defineProperty, j = (t, e, r) => e in t ? M(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, u = (t, e, r) => j(t, typeof e != "symbol" ? e + "" : e, r);
+let S = 0, E = 0;
+const D = Math.random().toString(36).substr(2, 6);
+let O = null, _ = null, q = !1;
+const F = /* @__PURE__ */ new Set();
+F.add(D);
+const n = {
+  get currentComputation() {
+    return O;
+  },
+  set currentComputation(t) {
+    O = t;
+  },
+  get currentOwner() {
+    return _;
+  },
+  set currentOwner(t) {
+    _ = t;
+  },
+  get isBatching() {
+    return q;
+  },
+  set isBatching(t) {
+    q = t;
+  }
+};
+function I() {
+  return n.currentComputation;
+}
+function k() {
+  return n.currentOwner;
+}
+function z() {
+  return n.isBatching;
+}
+class T {
+  constructor(e = null) {
+    u(this, "id"), u(this, "parent"), u(this, "context", /* @__PURE__ */ new Map()), u(this, "cleanups", []), u(this, "sources", /* @__PURE__ */ new Set()), u(this, "disposed", !1), this.id = ++E, this.parent = e;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0;
+      for (const e of this.sources)
+        e.dispose();
+      this.sources.clear();
+      for (const e of this.cleanups)
+        try {
+          e();
+        } catch (r) {
+          console.error("Error in cleanup function:", r);
+        }
+      this.cleanups.length = 0, this.parent && !this.parent.disposed && this.parent.sources.delete(this);
+    }
+  }
+}
+class x {
+  constructor(e, r = null) {
+    u(this, "id"), u(this, "owner"), u(this, "fn"), u(this, "sources", /* @__PURE__ */ new Set()), u(this, "observers", /* @__PURE__ */ new Set()), u(this, "state", o.Dirty), u(this, "value"), this.id = ++S, this.fn = e, this.owner = r, r && !r.disposed && r.sources.add(this);
+  }
+  execute() {
+    if (this.state === o.Disposed)
+      return this.value;
+    for (const r of this.sources)
+      r && typeof r == "object" && "removeObserver" in r && r.removeObserver(this);
+    this.sources.clear();
+    const e = n.currentComputation;
+    n.currentComputation = this;
+    try {
+      return this.state = o.Clean, this.value = this.fn(), this.value;
+    } catch (r) {
+      throw this.state = o.Disposed, (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error in computation:", r), r;
+    } finally {
+      n.currentComputation = e;
+    }
+  }
+  dispose() {
+    if (this.state !== o.Disposed) {
+      this.state = o.Disposed;
+      for (const e of this.sources)
+        e && typeof e == "object" && "removeObserver" in e && e.removeObserver(this);
+      this.sources.clear();
+      for (const e of this.observers)
+        e.sources.delete(this);
+      this.observers.clear(), this.owner && !this.owner.disposed && this.owner.sources.delete(this);
+    }
+  }
+}
+function ne(t) {
+  const e = new T(n.currentOwner), r = n.currentOwner;
+  n.currentOwner = e;
+  try {
+    return t(() => e.dispose());
+  } finally {
+    n.currentOwner = r;
+  }
+}
+function ie(t, e) {
+  const r = n.currentOwner;
+  n.currentOwner = t;
+  try {
+    return e();
+  } finally {
+    n.currentOwner = r;
+  }
+}
+function oe() {
+  return n.currentOwner;
+}
+let w = null;
+function $(t) {
+  w = t;
+}
+function ue(t) {
+  if (n.isBatching)
+    return t();
+  const e = n.isBatching;
+  n.isBatching = !0;
+  try {
+    const r = t();
+    return !e && w && w(), r;
+  } finally {
+    n.isBatching = e;
+  }
+}
+function ae(t) {
+  const e = n.currentComputation;
+  n.currentComputation = null;
+  try {
+    return t();
+  } finally {
+    n.currentComputation = e;
+  }
+}
+function ce(t, e) {
+  const r = new x(
+    t,
+    e || n.currentOwner
+  );
+  return r.execute(), r;
+}
+function le() {
+  return {
+    computation: n.currentComputation,
+    batch: n.isBatching
+  };
+}
+const he = {
+  getCurrentComputation: () => n.currentComputation,
+  getCurrentOwner: () => n.currentOwner,
+  getComputationCount: () => S,
+  getOwnerCount: () => E,
+  isBatching: () => n.isBatching,
+  getModuleInstances: () => Array.from(F),
+  getModuleId: () => D
+};
+var Q = Object.defineProperty, H = (t, e, r) => e in t ? Q(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, v = (t, e, r) => H(t, typeof e != "symbol" ? e + "" : e, r);
+let U = 0;
+class W {
+  constructor(e) {
+    v(this, "id"), v(this, "observers", /* @__PURE__ */ new Set()), v(this, "_value"), this.id = ++U, this._value = e;
+  }
+  /**
+   * Get the current value and track dependency
+   */
+  getValue() {
+    const e = I();
+    return e && e.state !== o.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 and notify observers
+   */
+  set(e) {
+    const r = typeof e == "function" ? e(this._value) : e;
+    return r !== this._value && (this._value = r, this.notify()), r;
+  }
+  /**
+   * Notify all observers that this signal has changed
+   */
+  notify() {
+    for (const e of this.observers)
+      e.state !== o.Disposed && (e.state = o.Dirty, J(e));
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e);
+  }
+  /**
+   * Get debug information about this signal
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      value: this._value,
+      observerCount: this.observers.size,
+      type: "Signal"
+    };
+  }
+}
+const m = /* @__PURE__ */ new Set();
+let y = !1;
+function J(t) {
+  m.add(t), !y && !z() && queueMicrotask(N);
+}
+function N() {
+  if (!y) {
+    y = !0;
+    try {
+      for (; m.size > 0; ) {
+        const t = Array.from(m).sort((e, r) => e.id - r.id);
+        m.clear();
+        for (const e of t)
+          e.state === o.Dirty && e.execute();
+      }
+    } finally {
+      y = !1;
+    }
+  }
+}
+function L(t) {
+  const e = new W(t), r = e.getValue.bind(e);
+  r.peek = e.peek.bind(e);
+  const s = e.set.bind(e);
+  return Object.defineProperty(r, Symbol.for("tachui.signal"), {
+    value: e,
+    enumerable: !1
+  }), [r, s];
+}
+function fe(t) {
+  return typeof t == "function" && Symbol.for("tachui.signal") in t;
+}
+function de(t) {
+  return t[Symbol.for("tachui.signal")] || null;
+}
+$(N);
+const g = (t, e) => t === e, b = (t, e) => {
+  if (t === e) return !0;
+  if (t == null || e == null || typeof t != typeof e) return !1;
+  if (typeof t == "object") {
+    if (Array.isArray(t) !== Array.isArray(e)) return !1;
+    if (Array.isArray(t)) {
+      const c = t, C = e;
+      return c.length !== C.length ? !1 : c.every((V, A) => b(V, C[A]));
+    }
+    const r = t, s = e, i = Object.keys(r), a = Object.keys(s);
+    return i.length !== a.length ? !1 : i.every((c) => b(r[c], s[c]));
+  }
+  return !1;
+}, pe = (t, e) => {
+  if (t === e) return !0;
+  if (typeof t != "object" || typeof e != "object" || t == null || e == null) return !1;
+  const r = t, s = e, i = Object.keys(r), a = Object.keys(s);
+  return i.length !== a.length ? !1 : i.every((c) => r[c] === s[c]);
+}, me = (t, e) => {
+  if (t === e) return !0;
+  if (t instanceof Date && e instanceof Date)
+    return t.getTime() === e.getTime();
+  if (t instanceof RegExp && e instanceof RegExp)
+    return t.toString() === e.toString();
+  if (t instanceof Set && e instanceof Set) {
+    if (t.size !== e.size) return !1;
+    for (const r of t)
+      if (!e.has(r)) return !1;
+    return !0;
+  }
+  if (t instanceof Map && e instanceof Map) {
+    if (t.size !== e.size) return !1;
+    for (const [r, s] of t)
+      if (!e.has(r) || e.get(r) !== s) return !1;
+    return !0;
+  }
+  return b(t, e);
+}, ye = (t, e) => {
+  if (t === e) return !0;
+  try {
+    return JSON.stringify(t) === JSON.stringify(e);
+  } catch {
+    return t === e;
+  }
+}, ge = (t, e = g) => (r, s) => e(t(r), t(s)), ve = (t = g) => (e, r) => e === r ? !0 : e.length !== r.length ? !1 : e.every((s, i) => t(s, r[i])), we = (t = g) => (e, r) => {
+  if (e === r) return !0;
+  if (e == null || r == null) return !1;
+  const s = Object.keys(e), i = Object.keys(r);
+  return s.length !== i.length ? !1 : s.every((a) => t(e[a], r[a]));
+}, be = (...t) => (e, r) => t.every((s) => s(e, r)), Ce = (t, e) => (r, s) => {
+  const i = t(r, s);
+  return process.env.NODE_ENV === "development" && console.log(`[${e || "equals"}]`, { a: r, b: s, equal: i }), i;
+};
+var G = Object.defineProperty, K = (t, e, r) => e in t ? G(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, l = (t, e, r) => K(t, typeof e != "symbol" ? e + "" : e, r), d = /* @__PURE__ */ ((t) => (t[t.Immediate = 0] = "Immediate", t[t.High = 1] = "High", t[t.Normal = 2] = "Normal", t[t.Low = 3] = "Low", t[t.Idle = 4] = "Idle", t))(d || {});
+class X extends Error {
+  constructor(e, r, s) {
+    super(e), this.cause = r, this.node = s, this.name = "ReactiveError";
+  }
+}
+const B = class f {
+  constructor() {
+    l(this, "updateQueues", /* @__PURE__ */ new Map()), l(this, "isFlushPending", !1), l(this, "isDestroyed", !1), l(this, "errorHandlers", /* @__PURE__ */ new Set()), l(this, "maxRetries", 3), l(this, "totalUpdateCycles", 0), l(this, "totalUpdateTime", 0), l(this, "errorCount", 0), l(this, "nodeRegistry", /* @__PURE__ */ new WeakSet());
+    for (const e of Object.values(d))
+      typeof e == "number" && this.updateQueues.set(e, /* @__PURE__ */ new Set());
+  }
+  static getInstance() {
+    return f.instance || (f.instance = new f()), f.instance;
+  }
+  /**
+   * Schedule reactive node for update
+   */
+  schedule(e) {
+    if (this.isDestroyed) return;
+    this.nodeRegistry.add(e), this.getQueue(e.priority).add(e), this.isFlushPending || (this.isFlushPending = !0, this.scheduleFlush(e.priority));
+  }
+  /**
+   * Process all queued updates by priority
+   */
+  async flush() {
+    if (this.isDestroyed) return;
+    this.isFlushPending = !1;
+    const e = performance.now();
+    try {
+      for (const r of [
+        0,
+        1,
+        2,
+        3,
+        4
+        /* Idle */
+      ]) {
+        const s = this.updateQueues.get(r);
+        if (!s || s.size === 0) continue;
+        const i = Array.from(s);
+        s.clear();
+        for (const a of i)
+          try {
+            await this.updateNodeWithRetry(a);
+          } catch (c) {
+            this.handleReactiveError(
+              new X(`Failed to update ${a.type} node ${a.id}`, c, a)
+            );
+          }
+        if (this.hasHigherPriorityWork(r))
+          return this.flush();
+      }
+      this.totalUpdateCycles++;
+    } finally {
+      const r = performance.now();
+      this.totalUpdateTime += r - e;
+    }
+  }
+  /**
+   * Update node with retry logic
+   */
+  async updateNodeWithRetry(e, r = 1) {
+    try {
+      e.notify();
+    } catch (s) {
+      if (r < this.maxRetries)
+        return console.warn(`Reactive update failed, retrying (${r}/${this.maxRetries})`), await new Promise((i) => setTimeout(i, r * 10)), this.updateNodeWithRetry(e, r + 1);
+      throw s;
+    }
+  }
+  /**
+   * Schedule flush based on priority
+   */
+  scheduleFlush(e) {
+    switch (e) {
+      case 0:
+        this.flush();
+        break;
+      case 1:
+        queueMicrotask(() => this.flush());
+        break;
+      case 2:
+        typeof requestAnimationFrame < "u" ? requestAnimationFrame(() => this.flush()) : queueMicrotask(() => this.flush());
+        break;
+      case 3:
+      case 4:
+        typeof requestIdleCallback < "u" ? requestIdleCallback(() => this.flush(), { timeout: 1e3 }) : setTimeout(() => this.flush(), 50);
+        break;
+    }
+  }
+  /**
+   * Check if there's higher priority work waiting
+   */
+  hasHigherPriorityWork(e) {
+    for (let r = 0; r < e; r++) {
+      const s = this.updateQueues.get(r);
+      if (s && s.size > 0)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Get queue for priority level
+   */
+  getQueue(e) {
+    const r = this.updateQueues.get(e);
+    if (!r)
+      throw new Error(`Invalid priority level: ${e}`);
+    return r;
+  }
+  /**
+   * Register error handler
+   */
+  onError(e) {
+    return this.errorHandlers.add(e), () => this.errorHandlers.delete(e);
+  }
+  /**
+   * Handle reactive errors with recovery
+   */
+  handleReactiveError(e) {
+    this.errorCount++;
+    let r = !1;
+    for (const s of this.errorHandlers)
+      try {
+        s(e), r = !0;
+      } catch (i) {
+        console.error("Error handler threw error:", i);
+      }
+    if (!r && (console.error("Unhandled reactive error:", e), process.env.NODE_ENV === "development"))
+      throw e;
+  }
+  /**
+   * Get performance metrics
+   */
+  getPerformanceMetrics() {
+    let e = 0;
+    for (const r of this.updateQueues.values())
+      e += r.size;
+    return {
+      totalNodes: e,
+      updateCycles: this.totalUpdateCycles,
+      averageUpdateTime: this.totalUpdateCycles > 0 ? this.totalUpdateTime / this.totalUpdateCycles : 0,
+      memoryUsage: this.estimateMemoryUsage(),
+      errorCount: this.errorCount
+    };
+  }
+  /**
+   * Estimate memory usage (rough approximation)
+   */
+  estimateMemoryUsage() {
+    let e = 0;
+    for (const r of this.updateQueues.values())
+      e += r.size * 50;
+    return e += this.errorHandlers.size * 100, e;
+  }
+  /**
+   * Check if node is scheduled
+   */
+  hasNode(e) {
+    for (const r of this.updateQueues.values())
+      if (r.has(e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Flush all pending updates synchronously
+   */
+  flushSync() {
+    this.isFlushPending && (this.isFlushPending = !1, this.flush());
+  }
+  /**
+   * Clear all pending updates
+   */
+  clearPending() {
+    for (const e of this.updateQueues.values())
+      e.clear();
+    this.isFlushPending = !1;
+  }
+  /**
+   * Cleanup all reactive nodes and destroy scheduler
+   */
+  destroy() {
+    this.isDestroyed = !0;
+    for (const e of this.updateQueues.values()) {
+      for (const r of e)
+        try {
+          r.cleanup();
+        } catch (s) {
+          console.error("Error cleaning up reactive node:", s);
+        }
+      e.clear();
+    }
+    this.updateQueues.clear(), this.errorHandlers.clear(), f.instance = null;
+  }
+  /**
+   * Get debug information
+   */
+  getDebugInfo() {
+    const e = {};
+    for (const [r, s] of this.updateQueues)
+      e[d[r]] = s.size;
+    return {
+      isFlushPending: this.isFlushPending,
+      isDestroyed: this.isDestroyed,
+      queueSizes: e,
+      errorHandlerCount: this.errorHandlers.size,
+      performance: this.getPerformanceMetrics()
+    };
+  }
+};
+l(B, "instance", null);
+let Oe = B;
+var Y = Object.defineProperty, Z = (t, e, r) => e in t ? Y(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, h = (t, e, r) => Z(t, typeof e != "symbol" ? e + "" : e, r);
+class ee extends x {
+  constructor(e, r = {}, s = k()) {
+    super(e, s), h(this, "type", "computed"), h(this, "priority"), h(this, "_hasValue", !1), h(this, "_error", null), h(this, "equalsFn"), h(this, "options"), this.priority = r.priority ?? d.Normal, this.equalsFn = r.equals ?? g, this.options = r;
+  }
+  /**
+   * Get the computed value, tracking dependency and lazily computing
+   */
+  getValue() {
+    const e = I();
+    return e && e.state !== o.Disposed && (this.observers.add(e), e.sources.add(this)), (this.state === o.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return (this.state === o.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e);
+  }
+  /**
+   * Execute the computation and notify observers
+   */
+  execute() {
+    const e = this._hasValue ? this.value : void 0, r = super.execute();
+    if (!this._hasValue || !this.equalsFn(e, r))
+      for (const s of this.observers)
+        s.state !== o.Disposed && (s.state = o.Dirty, "execute" in s && typeof s.execute == "function" && queueMicrotask(() => {
+          s.state === o.Dirty && s.execute();
+        }));
+    return r;
+  }
+  /**
+   * Notify method for ReactiveNode compatibility
+   */
+  notify() {
+    this.execute();
+  }
+  /**
+   * Complete cleanup for memory management
+   */
+  cleanup() {
+    for (const e of this.sources)
+      "removeObserver" in e && e.removeObserver(this);
+    this.sources.clear();
+    for (const e of this.observers)
+      e.sources.delete(this);
+    this.observers.clear(), this._hasValue = !1, this._error = null, this.state = o.Disposed;
+  }
+  /**
+   * Dispose the computed value
+   */
+  dispose() {
+    this.cleanup(), super.dispose();
+  }
+  /**
+   * Debug information
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      type: this.type,
+      value: this._hasValue ? this.value : void 0,
+      hasValue: this._hasValue,
+      error: this._error?.message,
+      state: this.state,
+      sourceCount: this.sources.size,
+      observerCount: this.observers.size,
+      priority: d[this.priority],
+      debugName: this.options.debugName,
+      equalsFn: this.equalsFn.name || "anonymous"
+    };
+  }
+  toString() {
+    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : "no value"}`;
+  }
+}
+function p(t, e) {
+  const r = new ee(t, e), s = r.getValue.bind(r);
+  return s.peek = r.peek.bind(r), Object.defineProperty(s, Symbol.for("tachui.computed"), {
+    value: r,
+    enumerable: !1
+  }), s;
+}
+function _e(t, e) {
+  return p(t, e);
+}
+function qe(t) {
+  return typeof t == "function" && Symbol.for("tachui.computed") in t;
+}
+function Se(t) {
+  return t[Symbol.for("tachui.computed")] || null;
+}
+function Ee(t, e) {
+  return p(e ? () => {
+    for (const s of e)
+      s();
+    return t();
+  } : t);
+}
+function De(t, e) {
+  let r, s = !1;
+  return p(() => (e() && (r = t(), s = !0), s || (r = t(), s = !0), r));
+}
+const [R, te] = L("light");
+function Fe() {
+  const t = R();
+  return t === "system" ? P() : t;
+}
+function Ie(t) {
+  te(t);
+}
+const re = p(() => {
+  const t = R();
+  return t === "system" ? P() : t;
+});
+function xe() {
+  return re;
+}
+function P() {
+  return typeof window < "u" && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+export {
+  b as A,
+  g as B,
+  x as C,
+  he as D,
+  ye as E,
+  pe as F,
+  me as G,
+  P as H,
+  Fe as I,
+  xe as J,
+  Ie as K,
+  Oe as L,
+  X as R,
+  d as U,
+  p as a,
+  _e as b,
+  L as c,
+  qe as d,
+  Se as e,
+  N as f,
+  de as g,
+  Ee as h,
+  fe as i,
+  De as j,
+  I as k,
+  k as l,
+  z as m,
+  ne as n,
+  oe as o,
+  ue as p,
+  ce as q,
+  ie as r,
+  $ as s,
+  le as t,
+  ae as u,
+  be as v,
+  ve as w,
+  we as x,
+  ge as y,
+  Ce as z
+};

package/dist/utils/clone-helpers.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentInstance, CloneOptions } from '../runtime/types';
+export declare function clonePropsPreservingReactivity<T extends Record<string, unknown>>(props: T, options?: CloneOptions): T;
+export declare function createResetLifecycleState(): {
+    mounted: boolean;
+    cleanup: (() => void)[];
+    domElements: Map<string, Element> | undefined;
+    primaryElement: Element | undefined;
+    domReady: boolean;
+};
+export declare function resetLifecycleState(target: ComponentInstance): void;
+//# sourceMappingURL=clone-helpers.d.ts.map

package/dist/utils/clone-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/clone-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAyBvE,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9E,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,YAAiB,GACzB,CAAC,CAwCH;AAED,wBAAgB,yBAAyB;;aAGtB,CAAC,MAAM,IAAI,CAAC,EAAE;iBACH,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;oBAC7B,OAAO,GAAG,SAAS;;EAGnD;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,QAO5D"}