@tachui/core 0.8.16 → 0.8.18

package/dist/index-DL9Cys3t.js

@@ -0,0 +1,733 @@
+import { infinity as c } from "./constants/layout.js";
+import { LayoutModifier as m } from "./modifiers/base.js";
+import { y as h, t as z, h as M } from "./concatenated-component-2Gzy5e2c.js";
+import { g as O, a as N } from "./proxy-Cp0QUXME.js";
+import "./assets/index.js";
+import "./scheduler-DppMK9mR.js";
+import "./theme-CRLPHryV.js";
+import "@tachui/types/reactive";
+import "@tachui/types/modifiers";
+import "typescript";
+import "@tachui/registry";
+import "./presets-B9x94uRn.js";
+import "./component-D-O9yq0P.js";
+import "./hooks-WGmpzYgD.js";
+import "./runtime/dom-bridge.js";
+import "./component-base-C41K3NTe.js";
+import "@tachui/types/gradients";
+import "./index-JQ1sW1SK.js";
+import "./plugins/index.js";
+import "./state/index.js";
+import "./validation/index.js";
+function st() {
+  return new m({
+    frame: {
+      maxWidth: c
+    }
+  });
+}
+function ct() {
+  return new m({
+    frame: {
+      maxHeight: c
+    }
+  });
+}
+function mt() {
+  return new m({
+    frame: {
+      maxWidth: c,
+      maxHeight: c
+    }
+  });
+}
+function lt() {
+  return new m({
+    frame: {
+      width: c,
+      height: c
+    }
+  });
+}
+function ut(r) {
+  return new m({
+    frame: {
+      width: r,
+      maxHeight: c
+    }
+  });
+}
+function dt(r) {
+  return new m({
+    frame: {
+      height: r,
+      maxWidth: c
+    }
+  });
+}
+function pt(r, t) {
+  return new m({
+    frame: {
+      width: c,
+      height: c,
+      maxWidth: r,
+      maxHeight: t
+    }
+  });
+}
+function ft(r, t, e, n) {
+  return new m({
+    frame: {
+      width: c,
+      height: c,
+      minWidth: r,
+      maxWidth: t,
+      minHeight: e,
+      maxHeight: n
+    }
+  });
+}
+function ht() {
+  return new m({
+    frame: {
+      maxWidth: c,
+      maxHeight: c
+    }
+  });
+}
+function gt() {
+  return new m({
+    frame: {
+      width: "100vw",
+      height: "100vh"
+    }
+  });
+}
+function yt() {
+  return new m({
+    frame: {
+      width: c,
+      height: c
+    }
+  });
+}
+function xt() {
+  return new m({
+    frame: {
+      width: c
+    }
+  });
+}
+const w = "http://www.w3.org/2000/svg", k = /* @__PURE__ */ new Set([
+  "svg",
+  "g",
+  "path",
+  "circle",
+  "rect",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "defs",
+  "clippath",
+  "mask",
+  "symbol",
+  "use",
+  "lineargradient",
+  "radialgradient",
+  "stop"
+]), v = /* @__PURE__ */ new Set(["script", "foreignobject", "style"]), A = /* @__PURE__ */ new Set([
+  "viewbox",
+  "d",
+  "fill",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "width",
+  "height",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  "x",
+  "y",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "points",
+  "transform",
+  "opacity",
+  "clip-path",
+  "mask",
+  "filter",
+  "gradientunits",
+  "gradienttransform",
+  "offset",
+  "stop-color",
+  "stop-opacity",
+  "id",
+  "class",
+  "preserveaspectratio",
+  "href",
+  "xlink:href",
+  "xmlns:xlink"
+]);
+function L(r) {
+  return r.replace(/<\?[\s\S]*?\?>/g, "").replace(/<!DOCTYPE[\s\S]*?>/gi, "").replace(/<!ENTITY[\s\S]*?>/gi, "");
+}
+function _(r) {
+  const t = r.toLowerCase().replace(/[\u0000-\u0020]+/g, "");
+  return t.includes("javascript:") || t.includes("data:");
+}
+function R(r) {
+  const t = r.trim();
+  return /^#[A-Za-z_][\w:.-]*$/.test(t);
+}
+function P(r) {
+  return !!r.trim().match(/^url\((["']?)(#[A-Za-z_][\w:.-]*)\1\)$/);
+}
+function D(r, t) {
+  const e = r.toLowerCase();
+  if (A.has(e) && !e.startsWith("on") && !_(t))
+    return e === "href" || e === "xlink:href" ? R(t) ? t.trim() : void 0 : t.includes("url(") ? P(t) ? t.trim() : void 0 : t;
+}
+function E(r, t) {
+  const e = r.tagName.toLowerCase();
+  if (v.has(e))
+    return [];
+  if (!k.has(e)) {
+    const i = [];
+    for (const o of r.childNodes)
+      i.push(...C(o, t));
+    return i;
+  }
+  const n = t.createElementNS(w, r.tagName);
+  for (const i of r.getAttributeNames()) {
+    const o = r.getAttribute(i);
+    if (o === null) continue;
+    const a = D(i, o);
+    a !== void 0 && n.setAttribute(i, a);
+  }
+  for (const i of r.childNodes) {
+    const o = C(i, t);
+    for (const a of o)
+      n.appendChild(a);
+  }
+  return [n];
+}
+function C(r, t) {
+  return r.nodeType === Node.ELEMENT_NODE ? E(r, t) : r.nodeType === Node.TEXT_NODE ? [t.createTextNode(r.textContent ?? "")] : [];
+}
+function St(r) {
+  if (typeof r != "string" || r.trim() === "") return "";
+  const n = new DOMParser().parseFromString(L(r), "image/svg+xml").documentElement;
+  if (!n || n.tagName.toLowerCase() !== "svg") return "";
+  const i = document.implementation.createDocument(w, "svg", null), a = E(n, i).find(
+    (s) => s.nodeType === Node.ELEMENT_NODE
+  );
+  return !a || a.tagName.toLowerCase() !== "svg" ? "" : (i.replaceChild(a, i.documentElement), new XMLSerializer().serializeToString(i.documentElement));
+}
+const Ct = Symbol.for("tachui.concat");
+function bt(r) {
+  return r && typeof r == "object" && typeof r.isConcatenatable == "function" && r.isConcatenatable();
+}
+function Tt(r) {
+  return r && typeof r == "object" && r.constructor.name === "ConcatenatedComponent";
+}
+const wt = Symbol.for("tachui.concat");
+class Et {
+  /**
+   * Concatenate this component with another concatenatable component
+   */
+  concat(t) {
+    const e = this.toSegment(), n = t.toSegment();
+    return t instanceof h ? new h(
+      [e, ...t.segments],
+      this.mergeMetadata(t.metadata, t.segments.length + 1)
+    ) : new h(
+      [e, n],
+      this.createMetadata(2)
+    );
+  }
+  /**
+   * Check if this component supports concatenation
+   */
+  isConcatenatable() {
+    return !0;
+  }
+  /**
+   * Create metadata for a new concatenated component
+   */
+  createMetadata(t) {
+    return {
+      totalSegments: t,
+      accessibilityRole: this.determineAccessibilityRole(),
+      semanticStructure: this.determineSemanticStructure()
+    };
+  }
+  /**
+   * Merge metadata when concatenating with existing concatenated component
+   */
+  mergeMetadata(t, e) {
+    return {
+      totalSegments: e,
+      accessibilityRole: this.mergeAccessibilityRoles(t.accessibilityRole),
+      semanticStructure: this.mergeSemanticStructures(t.semanticStructure)
+    };
+  }
+  /**
+   * Determine the accessibility role for this component
+   */
+  determineAccessibilityRole() {
+    const t = this.constructor.name;
+    return t === "EnhancedText" ? "text" : t === "EnhancedImage" || t === "EnhancedButton" || t === "EnhancedLink" ? "group" : "composite";
+  }
+  /**
+   * Determine the semantic structure for this component
+   */
+  determineSemanticStructure() {
+    const t = this.constructor.name;
+    return t === "EnhancedText" || t === "EnhancedImage" ? "inline" : "mixed";
+  }
+  /**
+   * Merge accessibility roles when combining components
+   */
+  mergeAccessibilityRoles(t) {
+    const e = this.determineAccessibilityRole();
+    return e === "text" && t === "text" ? "text" : e === "composite" || t === "composite" ? "composite" : "group";
+  }
+  /**
+   * Merge semantic structures when combining components
+   */
+  mergeSemanticStructures(t) {
+    const e = this.determineSemanticStructure();
+    return e === "inline" && t === "inline" ? "inline" : e === "block" && t === "block" ? "block" : "mixed";
+  }
+}
+function zt(r) {
+  const t = r;
+  return t.concat = function(e) {
+    const n = {
+      id: this.id,
+      component: this,
+      modifiers: this.modifiers || [],
+      render: () => {
+        const o = this.render();
+        return Array.isArray(o) ? o[0] : o;
+      }
+    }, i = e.toSegment();
+    return e instanceof h ? new h(
+      [n, ...e.segments],
+      {
+        totalSegments: e.segments.length + 1,
+        accessibilityRole: "group",
+        semanticStructure: "mixed"
+      }
+    ) : new h(
+      [n, i],
+      {
+        totalSegments: 2,
+        accessibilityRole: "group",
+        semanticStructure: "mixed"
+      }
+    );
+  }, t.toSegment = function() {
+    return {
+      id: this.id,
+      component: this,
+      modifiers: this.modifiers || [],
+      render: () => {
+        const e = this.render();
+        return Array.isArray(e) ? e[0] : e;
+      }
+    };
+  }, t.isConcatenatable = function() {
+    return !0;
+  }, t;
+}
+const u = /* @__PURE__ */ new Map(), H = 300 * 1e3, b = 100;
+class Mt {
+  /**
+   * Optimize an array of segments by merging compatible adjacent text segments
+   * Enhanced with caching and performance monitoring
+   */
+  static optimize(t) {
+    const e = performance.now();
+    if (t.length < 2) return t;
+    const n = this.generateCacheKey(t), i = this.getCachedOptimization(n);
+    if (i)
+      return i.optimizedSegments;
+    const o = this.performOptimization(t), a = performance.now() - e, s = {
+      ...this.getOptimizationStats(t, o),
+      processingTimeMs: a
+    };
+    return this.cacheOptimization(n, o, s), process.env.NODE_ENV === "development" && a > 5 && console.log(`TachUI Concatenation: Optimization took ${a.toFixed(2)}ms for ${t.length} segments`), o;
+  }
+  /**
+   * Core optimization algorithm separated for clarity
+   */
+  static performOptimization(t) {
+    const e = [];
+    for (const n of t) {
+      const i = e[e.length - 1];
+      i && this.canMergeTextSegments(i, n) ? e[e.length - 1] = this.mergeTextSegments(i, n) : e.push(n);
+    }
+    return e;
+  }
+  /**
+   * Generate a cache key from segments
+   */
+  static generateCacheKey(t) {
+    return t.map((n) => {
+      const i = n.component, o = this.extractTextContent(i), a = this.hashModifiers(n.modifiers);
+      return `${i.constructor.name}:${o}:${a}`;
+    }).join("|");
+  }
+  /**
+   * Hash modifiers for cache key generation
+   */
+  static hashModifiers(t) {
+    if (t.length === 0) return "none";
+    try {
+      const e = t.map((i) => ({
+        type: i.type,
+        props: i.properties
+      })), n = JSON.stringify(e);
+      return typeof btoa == "function" ? btoa(n).substring(0, 8) : this.simpleHash(n).toString(16).substring(0, 8);
+    } catch {
+      return "hash-error";
+    }
+  }
+  /**
+   * Simple hash function fallback for environments without btoa
+   */
+  static simpleHash(t) {
+    let e = 0;
+    for (let n = 0; n < t.length; n++) {
+      const i = t.charCodeAt(n);
+      e = (e << 5) - e + i, e = e & e;
+    }
+    return Math.abs(e);
+  }
+  /**
+   * Get cached optimization result
+   */
+  static getCachedOptimization(t) {
+    const e = u.get(t);
+    return e ? Date.now() - e.timestamp > H ? (u.delete(t), null) : e : null;
+  }
+  /**
+   * Cache optimization result
+   */
+  static cacheOptimization(t, e, n) {
+    if (u.size >= b) {
+      const i = u.keys().next().value;
+      i && u.delete(i);
+    }
+    u.set(t, {
+      optimizedSegments: e,
+      stats: n,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Clear optimization cache (useful for testing)
+   */
+  static clearCache() {
+    u.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  static getCacheStats() {
+    return {
+      size: u.size,
+      maxSize: b,
+      hitRate: 0
+      // Would need to track hits/misses to calculate this
+    };
+  }
+  /**
+   * Check if two segments can be merged
+   */
+  static canMergeTextSegments(t, e) {
+    return t.component.constructor.name !== "EnhancedText" || e.component.constructor.name !== "EnhancedText" ? !1 : this.modifiersCompatible(t.modifiers, e.modifiers);
+  }
+  /**
+   * Check if two modifier arrays are compatible for merging
+   */
+  static modifiersCompatible(t, e) {
+    if (t.length !== e.length) return !1;
+    for (let n = 0; n < t.length; n++)
+      if (!this.modifierEqual(t[n], e[n]))
+        return !1;
+    return !0;
+  }
+  /**
+   * Check if two modifiers are equal (simplified comparison)
+   */
+  static modifierEqual(t, e) {
+    if (t.type !== e.type) return !1;
+    try {
+      return JSON.stringify(t.properties) === JSON.stringify(e.properties);
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Merge two text segments into a single segment
+   */
+  static mergeTextSegments(t, e) {
+    const n = t.component, i = e.component, o = this.extractTextContent(n), a = this.extractTextContent(i), s = o + a;
+    return {
+      id: `merged-${t.id}-${e.id}`,
+      component: this.createMergedTextComponent(s, n.props, t.modifiers),
+      modifiers: t.modifiers,
+      // Use modifiers from first segment (they're identical)
+      render: () => this.createMergedTextComponent(s, n.props, t.modifiers).render()[0]
+    };
+  }
+  /**
+   * Extract text content from a text component
+   */
+  static extractTextContent(t) {
+    const e = t.props?.content;
+    return typeof e == "string" ? e : typeof e == "function" ? e() : e && typeof e == "object" && "peek" in e && e.peek() || "";
+  }
+  /**
+   * Create a new merged text component
+   */
+  static createMergedTextComponent(t, e, n) {
+    const i = {
+      ...e,
+      content: t
+    };
+    return {
+      type: "Text",
+      id: `merged-text-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      props: i,
+      mounted: !1,
+      cleanup: [],
+      modifiers: n,
+      render() {
+        const o = z(t);
+        return [M("span", {}, o)];
+      }
+    };
+  }
+  /**
+   * Analyze segments and determine if optimization would be beneficial
+   */
+  static shouldOptimize(t) {
+    if (t.length < 2) return !1;
+    let e = 0;
+    for (let n = 0; n < t.length - 1; n++) {
+      const i = t[n], o = t[n + 1];
+      i.component.constructor.name === "EnhancedText" && o.component.constructor.name === "EnhancedText" && e++;
+    }
+    return e > 0;
+  }
+  /**
+   * Get optimization statistics (enhanced for Phase 4.1)
+   */
+  static getOptimizationStats(t, e) {
+    const n = t.length - e.length, i = t.length > 0 ? Math.round(n / t.length * 100) : 0;
+    return {
+      originalCount: t.length,
+      optimizedCount: e.length,
+      reductionPercent: i,
+      textSegmentsMerged: n
+    };
+  }
+  /**
+   * Advanced optimization analysis for performance monitoring
+   */
+  static analyzeOptimizationOpportunities(t) {
+    let e = 0, n = 0, i = 0, o = 0;
+    for (let s = 0; s < t.length; s++) {
+      const l = t[s];
+      switch (l.component.constructor.name) {
+        case "EnhancedText":
+          if (e++, s < t.length - 1) {
+            const f = t[s + 1];
+            this.canMergeTextSegments(l, f) && o++;
+          }
+          break;
+        case "EnhancedImage":
+          n++;
+          break;
+        case "EnhancedButton":
+        case "EnhancedLinkComponent":
+          i++;
+          break;
+      }
+    }
+    const a = t.length > 0 ? Math.round(o / t.length * 100) : 0;
+    return {
+      totalSegments: t.length,
+      textSegments: e,
+      imageSegments: n,
+      interactiveSegments: i,
+      optimizableTextPairs: o,
+      estimatedReductionPercent: a
+    };
+  }
+}
+function S(r, t = {}) {
+  const { fallback: e, errorFallback: n, timeout: i = 1e4, preload: o = "never" } = t;
+  let a = !1, s = null, l = !1, p = null, f = null;
+  const y = async () => {
+    a || l || s || f || (a = !0, l = !0, p = null, f = (async () => {
+      try {
+        const d = await Promise.race([
+          r(),
+          new Promise(
+            (g, x) => setTimeout(() => x(new Error("Component load timeout")), i)
+          )
+        ]);
+        s = "default" in d ? d.default : d;
+      } catch (d) {
+        const g = d;
+        (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Failed to load lazy component:", g), p = g;
+      } finally {
+        l = !1, f = null;
+      }
+    })(), await f);
+  };
+  return o === "idle" && typeof requestIdleCallback < "u" ? requestIdleCallback(() => {
+    y().catch(() => {
+    });
+  }) : o === "idle" ? setTimeout(() => {
+    y().catch(() => {
+    });
+  }, 100) : o === "immediate" && y().catch(() => {
+  }), (d) => {
+    if (!a && !l && !s && y().catch(() => {
+    }), p)
+      return n ? n(p) : T(p);
+    if (l || !s)
+      return e || j();
+    try {
+      return typeof s == "function" ? s(d) : s;
+    } catch (g) {
+      const x = g;
+      return (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error rendering lazy component:", x), T(x);
+    }
+  };
+}
+function Ot(r) {
+  return {
+    type: "component",
+    render: () => ({
+      type: "element",
+      tag: "div",
+      props: { class: "tachui-suspense" },
+      children: r.children.map(() => ({
+        type: "element",
+        tag: "div",
+        children: []
+      }))
+    }),
+    props: r,
+    id: `suspense-${Math.random().toString(36).substr(2, 9)}`
+  };
+}
+function $(r) {
+  return r().then((t) => t && typeof t == "object" && "default" in t ? t.default : t);
+}
+function Nt(r, t = {}) {
+  const e = {};
+  for (const [n, i] of Object.entries(r))
+    e[n] = S(i, t);
+  return e;
+}
+function kt(r) {
+  const t = Object.entries(r).map(
+    async ([e, n]) => [e, await $(n)]
+  );
+  return Promise.all(t).then((e) => {
+    const n = {};
+    for (const [i, o] of e)
+      n[i] = o;
+    return n;
+  });
+}
+function j() {
+  return {
+    type: "element",
+    tag: "div",
+    props: {
+      class: "tachui-lazy-loading",
+      style: "padding: 16px; color: #666; text-align: center;"
+    },
+    children: [
+      {
+        type: "text",
+        text: "Loading component..."
+      }
+    ]
+  };
+}
+function T(r) {
+  return {
+    type: "element",
+    tag: "div",
+    props: {
+      class: "tachui-lazy-error",
+      style: "padding: 16px; color: #d32f2f; border: 1px solid #d32f2f; border-radius: 4px; background: #ffeaea;"
+    },
+    children: [
+      {
+        type: "text",
+        text: `Failed to load component: ${r.message}`
+      }
+    ]
+  };
+}
+function vt(r, t = {}) {
+  const { rootMargin: e = "50px", threshold: n = 0.1, ...i } = t;
+  return i.preload === "visible" && typeof IntersectionObserver < "u" ? (o) => {
+    const a = S(r, { ...i, preload: "never" });
+    return setTimeout(() => {
+      a(o);
+    }, 100), a(o);
+  } : S(r, i);
+}
+const At = Object.freeze({
+  configure: N,
+  getFeatureFlags: O
+});
+export {
+  Ct as C,
+  Ot as S,
+  Mt as T,
+  Tt as a,
+  Et as b,
+  wt as c,
+  ct as d,
+  mt as e,
+  st as f,
+  lt as g,
+  ut as h,
+  bt as i,
+  dt as j,
+  pt as k,
+  ht as l,
+  zt as m,
+  gt as n,
+  yt as o,
+  xt as p,
+  Nt as q,
+  ft as r,
+  St as s,
+  At as t,
+  vt as u,
+  S as v,
+  $ as w,
+  kt as x
+};