@tachui/core 0.7.0-alpha1 → 0.8.0-alpha

package/dist/component-XAzF1xqs.js

@@ -0,0 +1,487 @@
+import { G as P, g as R, o as _ } from "./scheduler-BKeqwrYE.js";
+import { c as y } from "./effect-B9Knft0b.js";
+import { b as x } from "./dom-bridge-CAa1N2zX.js";
+var K = Object.defineProperty, $ = (n, e, r) => e in n ? K(n, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : n[e] = r, f = (n, e, r) => $(n, typeof e != "symbol" ? e + "" : e, r);
+class v {
+  constructor(e, r) {
+    this.validator = r, f(this, "propsSignal"), f(this, "childrenSignal"), f(this, "changedKeys", /* @__PURE__ */ new Set()), this.propsSignal = P(this.validateAndMergeProps(e)), this.childrenSignal = P(e.children), y(() => {
+      const t = this.propsSignal[0]();
+      this.trackChanges(t);
+    });
+  }
+  /**
+   * Get current props reactively
+   */
+  getProps() {
+    return this.propsSignal[0]();
+  }
+  /**
+   * Update props with validation and change detection
+   */
+  setProps(e) {
+    const r = this.propsSignal[0](), t = { ...r, ...e }, o = this.validateAndMergeProps(t);
+    this.changedKeys.clear(), Object.keys(e).forEach((i) => {
+      r[i] !== e[i] && this.changedKeys.add(i);
+    }), this.propsSignal[1](o), e.children !== void 0 && this.childrenSignal[1](e.children);
+  }
+  /**
+   * Get current children reactively
+   */
+  getChildren() {
+    return this.childrenSignal[0]();
+  }
+  /**
+   * Set children directly
+   */
+  setChildren(e) {
+    this.childrenSignal[1](e);
+  }
+  /**
+   * Get keys that changed in last update
+   */
+  getChangedKeys() {
+    return Array.from(this.changedKeys);
+  }
+  /**
+   * Create reactive computed for a specific prop
+   */
+  createPropComputed(e) {
+    return R(() => this.getProps()[e]);
+  }
+  /**
+   * Create effect that runs when specific props change
+   */
+  createPropsEffect(e, r) {
+    const t = y(() => {
+      const o = this.getProps(), i = this.getChangedKeys();
+      (i.length === 0 || e.some((l) => i.includes(l))) && r(
+        o,
+        i.filter((l) => e.includes(l))
+      );
+    });
+    return () => t.dispose();
+  }
+  validateAndMergeProps(e) {
+    let r = e;
+    if (this.validator?.defaults && (r = { ...this.validator.defaults, ...e }), this.validator?.required) {
+      for (const t of this.validator.required)
+        if (r[t] === void 0 || r[t] === null)
+          throw new Error(`Required prop '${String(t)}' is missing`);
+    }
+    if (this.validator?.validator) {
+      const t = this.validator.validator(r);
+      if (typeof t == "string")
+        throw new Error(`Props validation failed: ${t}`);
+      if (t === !1)
+        throw new Error("Props validation failed");
+    }
+    return r;
+  }
+  trackChanges(e) {
+  }
+}
+class d {
+  constructor(e = null) {
+    f(this, "childrenSignal"), this.childrenSignal = P(e);
+  }
+  /**
+   * Get current children reactively
+   */
+  getChildren() {
+    return this.childrenSignal[0]();
+  }
+  /**
+   * Set new children
+   */
+  setChildren(e) {
+    this.childrenSignal[1](e);
+  }
+  /**
+   * Render children to DOM nodes
+   */
+  renderChildren() {
+    const e = this.getChildren();
+    return this.renderChildrenArray(Array.isArray(e) ? e : [e]);
+  }
+  /**
+   * Create fragment with multiple children
+   */
+  createFragment(e) {
+    return { children: e };
+  }
+  /**
+   * Map children with a function
+   */
+  mapChildren(e) {
+    const r = this.getChildren();
+    return (Array.isArray(r) ? r : [r]).map(e);
+  }
+  /**
+   * Filter children
+   */
+  filterChildren(e) {
+    const r = this.getChildren();
+    return (Array.isArray(r) ? r : [r]).filter(e);
+  }
+  /**
+   * Count non-null children
+   */
+  countChildren() {
+    const e = this.getChildren();
+    return e == null ? 0 : Array.isArray(e) ? e.filter((r) => r != null).length : 1;
+  }
+  renderChildrenArray(e) {
+    const r = [];
+    for (const t of e)
+      if (t != null) {
+        if (typeof t == "string" || typeof t == "number")
+          r.push({
+            type: "text",
+            text: String(t)
+          });
+        else if (typeof t != "boolean") {
+          if (typeof t == "function") {
+            const o = t();
+            Array.isArray(o) ? r.push(...o) : r.push(o);
+          } else if (Array.isArray(t))
+            r.push(...this.renderChildrenArray(t));
+          else if (typeof t == "object" && "render" in t) {
+            const o = t.render();
+            Array.isArray(o) ? r.push(...o) : r.push(o);
+          }
+        }
+      }
+    return r;
+  }
+}
+class p {
+  constructor(e = null) {
+    f(this, "ref"), this.ref = { current: e };
+  }
+  /**
+   * Get the ref object
+   */
+  getRef() {
+    return this.ref;
+  }
+  /**
+   * Set ref value
+   */
+  setValue(e) {
+    this.ref.current = e;
+  }
+  /**
+   * Get current ref value
+   */
+  getValue() {
+    return this.ref.current;
+  }
+  /**
+   * Apply ref (handle both ref objects and callback refs)
+   */
+  static applyRef(e, r) {
+    e && (typeof e == "function" ? e(r) : typeof e == "object" && e !== null && (e.current = r));
+  }
+  /**
+   * Create a new ref
+   */
+  static createRef(e = null) {
+    return { current: e };
+  }
+  /**
+   * Forward ref to another component
+   */
+  static forwardRef(e) {
+    return (r) => {
+      const { ref: t, ...o } = r;
+      return e(o, t || void 0);
+    };
+  }
+}
+function B(n, e) {
+  return new v(n, e);
+}
+function G(n) {
+  return new d(n);
+}
+function I(n) {
+  return new p(n);
+}
+const b = {
+  /**
+   * Compare props for changes
+   */
+  compareProps(n, e) {
+    const r = [], t = /* @__PURE__ */ new Set([...Object.keys(n), ...Object.keys(e)]);
+    for (const o of t)
+      n[o] !== e[o] && r.push(o);
+    return r;
+  },
+  /**
+   * Shallow compare props
+   */
+  shallowEqual(n, e) {
+    const r = Object.keys(n), t = Object.keys(e);
+    if (r.length !== t.length)
+      return !1;
+    for (const o of r)
+      if (n[o] !== e[o])
+        return !1;
+    return !0;
+  },
+  /**
+   * Pick specific props
+   */
+  pickProps(n, e) {
+    const r = {};
+    for (const t of e)
+      r[t] = n[t];
+    return r;
+  },
+  /**
+   * Omit specific props
+   */
+  omitProps(n, e) {
+    const r = { ...n };
+    for (const t of e)
+      delete r[t];
+    return r;
+  }
+}, L = (n) => new d(n).renderChildren();
+var Q = Object.defineProperty, N = (n, e, r) => e in n ? Q(n, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : n[e] = r, u = (n, e, r) => N(n, typeof e != "symbol" ? e + "" : e, r);
+const S = class h {
+  constructor() {
+    u(this, "components", /* @__PURE__ */ new Map()), u(this, "contexts", /* @__PURE__ */ new Map()), u(this, "cleanupQueue", /* @__PURE__ */ new Set()), u(this, "updateQueue", /* @__PURE__ */ new Set()), u(this, "isUpdating", !1);
+  }
+  static getInstance() {
+    return h.instance || (h.instance = new h()), h.instance;
+  }
+  /**
+   * Register a new component instance
+   */
+  registerComponent(e) {
+    this.components.set(e.id, e), e.cleanup && e.cleanup.forEach((r) => {
+      this.cleanupQueue.add(r);
+    });
+  }
+  /**
+   * Unregister and cleanup a component
+   */
+  unregisterComponent(e) {
+    const r = this.components.get(e);
+    r && (r.cleanup && r.cleanup.forEach((t) => {
+      try {
+        t();
+      } catch (o) {
+        console.error(`Cleanup error for component ${e}:`, o);
+      }
+    }), this.components.delete(e), r.context && this.cleanupContext(r.context.id));
+  }
+  /**
+   * Get component instance by ID
+   */
+  getComponent(e) {
+    return this.components.get(e);
+  }
+  /**
+   * Schedule component for update
+   */
+  scheduleUpdate(e) {
+    this.updateQueue.add(e), this.isUpdating || this.flushUpdates();
+  }
+  /**
+   * Process all scheduled updates
+   */
+  async flushUpdates() {
+    if (this.isUpdating) return;
+    this.isUpdating = !0, await new Promise((r) => queueMicrotask(() => r(void 0)));
+    const e = Array.from(this.updateQueue);
+    this.updateQueue.clear(), e.forEach((r) => {
+      const t = this.components.get(r);
+      if (t)
+        try {
+          this.updateComponent(t);
+        } catch (o) {
+          console.error(`Update error for component ${r}:`, o);
+        }
+    }), this.isUpdating = !1;
+  }
+  /**
+   * Update a specific component instance
+   */
+  updateComponent(e) {
+    e.props && (e.prevProps = { ...e.props }), e.render(), e.mounted || (e.mounted = !0);
+  }
+  /**
+   * Cleanup context by ID
+   */
+  cleanupContext(e) {
+    const r = this.contexts.get(e);
+    r && (r.cleanup.forEach((t) => {
+      try {
+        t();
+      } catch (o) {
+        console.error(`Context cleanup error for ${e}:`, o);
+      }
+    }), this.contexts.delete(e));
+  }
+  /**
+   * Get all registered components (for debugging)
+   */
+  getAllComponents() {
+    return Array.from(this.components.values());
+  }
+  /**
+   * Cleanup all components and resources
+   */
+  cleanup() {
+    Array.from(this.components.keys()).forEach((e) => {
+      this.unregisterComponent(e);
+    }), this.cleanupQueue.forEach((e) => {
+      try {
+        e();
+      } catch (r) {
+        console.error("Global cleanup error:", r);
+      }
+    }), this.cleanupQueue.clear(), this.updateQueue.clear();
+  }
+};
+u(S, "instance");
+let O = S;
+function m(n, e = {}) {
+  const r = (t) => {
+    const o = E(), i = O.getInstance(), s = [], l = x(o), C = new v(t, {
+      defaults: e.defaultProps || void 0,
+      ...e.validation
+    }), w = new d(t.children), U = new p();
+    let c, A = !1;
+    const M = {
+      type: "component",
+      render: () => {
+        if (e.lifecycle?.onMount && !A) {
+          const a = e.lifecycle.onMount();
+          typeof a == "function" && s.push(a), A = !0;
+        }
+        y(() => {
+          const a = C.getProps();
+          if (c && e.lifecycle?.onPropsChange) {
+            const g = b.compareProps(c, a);
+            g.length > 0 && e.lifecycle.onPropsChange(c, a, g);
+          }
+          c && e.lifecycle?.onUpdate && e.lifecycle.onUpdate(c, a), c = { ...a };
+        }), y(() => {
+          const a = w.getChildren();
+          e.lifecycle?.onChildrenChange && c && e.lifecycle.onChildrenChange(c.children, a);
+        }), _(() => {
+          e.lifecycle?.onUnmount && e.lifecycle.onUnmount(), s.forEach((a) => a()), i.unregisterComponent(o);
+        });
+        try {
+          e.lifecycle?.onRender && e.lifecycle.onRender();
+          const a = C.getProps(), g = w.getChildren();
+          return c && e.shouldUpdate && !e.shouldUpdate(c, a) ? [] : n(a, g);
+        } catch (a) {
+          throw e.lifecycle?.onError && e.lifecycle.onError(a), a;
+        }
+      },
+      props: C.getProps(),
+      children: w.getChildren(),
+      context: l,
+      cleanup: s,
+      id: o,
+      ref: t.ref,
+      mounted: !1
+    };
+    return t.ref && p.applyRef(t.ref, U.getRef()), i.registerComponent(M), M;
+  };
+  return e.displayName && (r.displayName = e.displayName), e.defaultProps && (r.defaultProps = e.defaultProps), r;
+}
+function E() {
+  return `component_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+function V(n, e) {
+  const r = (t) => {
+    const o = n(t), i = o.cleanup || [], s = [];
+    if (e.onMount) {
+      const l = e.onMount();
+      typeof l == "function" && s.push(l);
+    }
+    return e.onUnmount && s.push(e.onUnmount), {
+      ...o,
+      cleanup: [...i, ...s]
+    };
+  };
+  return r.displayName = `withLifecycle(${n.displayName || "Component"})`, r;
+}
+function D(n) {
+  return m(n, {
+    shouldUpdate: (e, r) => !b.shallowEqual(e, r)
+  });
+}
+function z(n) {
+  return m(
+    (e, r) => {
+      const t = new d(r || e.children);
+      try {
+        return t.renderChildren();
+      } catch (o) {
+        return console.error("Component error caught by boundary:", o), n(o);
+      }
+    },
+    {
+      displayName: "ErrorBoundary",
+      lifecycle: {
+        onError: (e) => {
+          console.error("Error boundary caught error:", e);
+        }
+      }
+    }
+  );
+}
+function H(n, e = {}) {
+  return m((r, t) => {
+    const o = new v(r, e.validation), i = new d(t || r.children), s = new p();
+    return n(r, t || r.children, {
+      propsManager: o,
+      childrenManager: i,
+      refManager: s
+    });
+  }, e);
+}
+function J(n) {
+  const e = new d(n);
+  return {
+    type: "component",
+    render: () => e.renderChildren(),
+    props: { children: n },
+    children: n,
+    id: E()
+  };
+}
+function T(n = null) {
+  return p.createRef(n);
+}
+function W(n) {
+  return m((e) => {
+    const { ref: r, ...t } = e;
+    return n(t, r || void 0);
+  });
+}
+export {
+  O as C,
+  v as P,
+  p as R,
+  m as a,
+  J as b,
+  H as c,
+  D as d,
+  T as e,
+  W as f,
+  d as g,
+  G as h,
+  B as i,
+  I as j,
+  L as k,
+  z as l,
+  b as p,
+  V as w
+};