@tachui/core 0.8.16 → 0.8.17

package/dist/utils/sanitize-svg.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeSVG(markup: string): string;
+//# sourceMappingURL=sanitize-svg.d.ts.map

package/dist/utils/sanitize-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-svg.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize-svg.ts"],"names":[],"mappings":"AAgKA,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAsBlD"}

package/dist/version.js

@@ -1,4 +1,4 @@
-const c = "@tachui/core", o = "0.8.16", n = c, t = o, s = o;
+const c = "@tachui/core", o = "0.8.17", n = c, t = o, s = o;
 export {
   n as TACHUI_PACKAGE,
   t as TACHUI_PACKAGE_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tachui/core",
-  "version": "0.8.16",
+  "version": "0.8.17",
   "description": "tachUI core framework with reactive system and compiler",
   "homepage": "https://tachui.dev/",
   "type": "module",
@@ -141,8 +141,8 @@
     "dist"
   ],
   "dependencies": {
-    "@tachui/types": "0.8.16",
-    "@tachui/registry": "0.8.16"
+    "@tachui/types": "0.8.17",
+    "@tachui/registry": "0.8.17"
   },
   "devDependencies": {
     "@types/jsdom": "^21.1.6",

package/dist/index-BaBj0d3d.js

@@ -1,618 +0,0 @@
-import { infinity as c } from "./constants/layout.js";
-import { LayoutModifier as m } from "./modifiers/base.js";
-import { y as h, t as T, h as w } from "./concatenated-component-BCrw_7cC.js";
-import { g as z, a as E } from "./proxy-gO-vDCUZ.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 X() {
-  return new m({
-    frame: {
-      maxWidth: c
-    }
-  });
-}
-function Y() {
-  return new m({
-    frame: {
-      maxHeight: c
-    }
-  });
-}
-function Z() {
-  return new m({
-    frame: {
-      maxWidth: c,
-      maxHeight: c
-    }
-  });
-}
-function Q() {
-  return new m({
-    frame: {
-      width: c,
-      height: c
-    }
-  });
-}
-function ee(o) {
-  return new m({
-    frame: {
-      width: o,
-      maxHeight: c
-    }
-  });
-}
-function te(o) {
-  return new m({
-    frame: {
-      height: o,
-      maxWidth: c
-    }
-  });
-}
-function ne(o, e) {
-  return new m({
-    frame: {
-      width: c,
-      height: c,
-      maxWidth: o,
-      maxHeight: e
-    }
-  });
-}
-function re(o, e, t, n) {
-  return new m({
-    frame: {
-      width: c,
-      height: c,
-      minWidth: o,
-      maxWidth: e,
-      minHeight: t,
-      maxHeight: n
-    }
-  });
-}
-function oe() {
-  return new m({
-    frame: {
-      maxWidth: c,
-      maxHeight: c
-    }
-  });
-}
-function ie() {
-  return new m({
-    frame: {
-      width: "100vw",
-      height: "100vh"
-    }
-  });
-}
-function ae() {
-  return new m({
-    frame: {
-      width: c,
-      height: c
-    }
-  });
-}
-function ce() {
-  return new m({
-    frame: {
-      width: c
-    }
-  });
-}
-const se = Symbol.for("tachui.concat");
-function me(o) {
-  return o && typeof o == "object" && typeof o.isConcatenatable == "function" && o.isConcatenatable();
-}
-function ue(o) {
-  return o && typeof o == "object" && o.constructor.name === "ConcatenatedComponent";
-}
-const le = Symbol.for("tachui.concat");
-class pe {
-  /**
-   * Concatenate this component with another concatenatable component
-   */
-  concat(e) {
-    const t = this.toSegment(), n = e.toSegment();
-    return e instanceof h ? new h(
-      [t, ...e.segments],
-      this.mergeMetadata(e.metadata, e.segments.length + 1)
-    ) : new h(
-      [t, n],
-      this.createMetadata(2)
-    );
-  }
-  /**
-   * Check if this component supports concatenation
-   */
-  isConcatenatable() {
-    return !0;
-  }
-  /**
-   * Create metadata for a new concatenated component
-   */
-  createMetadata(e) {
-    return {
-      totalSegments: e,
-      accessibilityRole: this.determineAccessibilityRole(),
-      semanticStructure: this.determineSemanticStructure()
-    };
-  }
-  /**
-   * Merge metadata when concatenating with existing concatenated component
-   */
-  mergeMetadata(e, t) {
-    return {
-      totalSegments: t,
-      accessibilityRole: this.mergeAccessibilityRoles(e.accessibilityRole),
-      semanticStructure: this.mergeSemanticStructures(e.semanticStructure)
-    };
-  }
-  /**
-   * Determine the accessibility role for this component
-   */
-  determineAccessibilityRole() {
-    const e = this.constructor.name;
-    return e === "EnhancedText" ? "text" : e === "EnhancedImage" || e === "EnhancedButton" || e === "EnhancedLink" ? "group" : "composite";
-  }
-  /**
-   * Determine the semantic structure for this component
-   */
-  determineSemanticStructure() {
-    const e = this.constructor.name;
-    return e === "EnhancedText" || e === "EnhancedImage" ? "inline" : "mixed";
-  }
-  /**
-   * Merge accessibility roles when combining components
-   */
-  mergeAccessibilityRoles(e) {
-    const t = this.determineAccessibilityRole();
-    return t === "text" && e === "text" ? "text" : t === "composite" || e === "composite" ? "composite" : "group";
-  }
-  /**
-   * Merge semantic structures when combining components
-   */
-  mergeSemanticStructures(e) {
-    const t = this.determineSemanticStructure();
-    return t === "inline" && e === "inline" ? "inline" : t === "block" && e === "block" ? "block" : "mixed";
-  }
-}
-function de(o) {
-  const e = o;
-  return e.concat = function(t) {
-    const n = {
-      id: this.id,
-      component: this,
-      modifiers: this.modifiers || [],
-      render: () => {
-        const i = this.render();
-        return Array.isArray(i) ? i[0] : i;
-      }
-    }, r = t.toSegment();
-    return t instanceof h ? new h(
-      [n, ...t.segments],
-      {
-        totalSegments: t.segments.length + 1,
-        accessibilityRole: "group",
-        semanticStructure: "mixed"
-      }
-    ) : new h(
-      [n, r],
-      {
-        totalSegments: 2,
-        accessibilityRole: "group",
-        semanticStructure: "mixed"
-      }
-    );
-  }, e.toSegment = function() {
-    return {
-      id: this.id,
-      component: this,
-      modifiers: this.modifiers || [],
-      render: () => {
-        const t = this.render();
-        return Array.isArray(t) ? t[0] : t;
-      }
-    };
-  }, e.isConcatenatable = function() {
-    return !0;
-  }, e;
-}
-const l = /* @__PURE__ */ new Map(), M = 300 * 1e3, S = 100;
-class fe {
-  /**
-   * Optimize an array of segments by merging compatible adjacent text segments
-   * Enhanced with caching and performance monitoring
-   */
-  static optimize(e) {
-    const t = performance.now();
-    if (e.length < 2) return e;
-    const n = this.generateCacheKey(e), r = this.getCachedOptimization(n);
-    if (r)
-      return r.optimizedSegments;
-    const i = this.performOptimization(e), s = performance.now() - t, a = {
-      ...this.getOptimizationStats(e, i),
-      processingTimeMs: s
-    };
-    return this.cacheOptimization(n, i, a), process.env.NODE_ENV === "development" && s > 5 && console.log(`TachUI Concatenation: Optimization took ${s.toFixed(2)}ms for ${e.length} segments`), i;
-  }
-  /**
-   * Core optimization algorithm separated for clarity
-   */
-  static performOptimization(e) {
-    const t = [];
-    for (const n of e) {
-      const r = t[t.length - 1];
-      r && this.canMergeTextSegments(r, n) ? t[t.length - 1] = this.mergeTextSegments(r, n) : t.push(n);
-    }
-    return t;
-  }
-  /**
-   * Generate a cache key from segments
-   */
-  static generateCacheKey(e) {
-    return e.map((n) => {
-      const r = n.component, i = this.extractTextContent(r), s = this.hashModifiers(n.modifiers);
-      return `${r.constructor.name}:${i}:${s}`;
-    }).join("|");
-  }
-  /**
-   * Hash modifiers for cache key generation
-   */
-  static hashModifiers(e) {
-    if (e.length === 0) return "none";
-    try {
-      const t = e.map((r) => ({
-        type: r.type,
-        props: r.properties
-      })), n = JSON.stringify(t);
-      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(e) {
-    let t = 0;
-    for (let n = 0; n < e.length; n++) {
-      const r = e.charCodeAt(n);
-      t = (t << 5) - t + r, t = t & t;
-    }
-    return Math.abs(t);
-  }
-  /**
-   * Get cached optimization result
-   */
-  static getCachedOptimization(e) {
-    const t = l.get(e);
-    return t ? Date.now() - t.timestamp > M ? (l.delete(e), null) : t : null;
-  }
-  /**
-   * Cache optimization result
-   */
-  static cacheOptimization(e, t, n) {
-    if (l.size >= S) {
-      const r = l.keys().next().value;
-      r && l.delete(r);
-    }
-    l.set(e, {
-      optimizedSegments: t,
-      stats: n,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Clear optimization cache (useful for testing)
-   */
-  static clearCache() {
-    l.clear();
-  }
-  /**
-   * Get cache statistics
-   */
-  static getCacheStats() {
-    return {
-      size: l.size,
-      maxSize: S,
-      hitRate: 0
-      // Would need to track hits/misses to calculate this
-    };
-  }
-  /**
-   * Check if two segments can be merged
-   */
-  static canMergeTextSegments(e, t) {
-    return e.component.constructor.name !== "EnhancedText" || t.component.constructor.name !== "EnhancedText" ? !1 : this.modifiersCompatible(e.modifiers, t.modifiers);
-  }
-  /**
-   * Check if two modifier arrays are compatible for merging
-   */
-  static modifiersCompatible(e, t) {
-    if (e.length !== t.length) return !1;
-    for (let n = 0; n < e.length; n++)
-      if (!this.modifierEqual(e[n], t[n]))
-        return !1;
-    return !0;
-  }
-  /**
-   * Check if two modifiers are equal (simplified comparison)
-   */
-  static modifierEqual(e, t) {
-    if (e.type !== t.type) return !1;
-    try {
-      return JSON.stringify(e.properties) === JSON.stringify(t.properties);
-    } catch {
-      return !1;
-    }
-  }
-  /**
-   * Merge two text segments into a single segment
-   */
-  static mergeTextSegments(e, t) {
-    const n = e.component, r = t.component, i = this.extractTextContent(n), s = this.extractTextContent(r), a = i + s;
-    return {
-      id: `merged-${e.id}-${t.id}`,
-      component: this.createMergedTextComponent(a, n.props, e.modifiers),
-      modifiers: e.modifiers,
-      // Use modifiers from first segment (they're identical)
-      render: () => this.createMergedTextComponent(a, n.props, e.modifiers).render()[0]
-    };
-  }
-  /**
-   * Extract text content from a text component
-   */
-  static extractTextContent(e) {
-    const t = e.props?.content;
-    return typeof t == "string" ? t : typeof t == "function" ? t() : t && typeof t == "object" && "peek" in t && t.peek() || "";
-  }
-  /**
-   * Create a new merged text component
-   */
-  static createMergedTextComponent(e, t, n) {
-    const r = {
-      ...t,
-      content: e
-    };
-    return {
-      type: "Text",
-      id: `merged-text-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      props: r,
-      mounted: !1,
-      cleanup: [],
-      modifiers: n,
-      render() {
-        const i = T(e);
-        return [w("span", {}, i)];
-      }
-    };
-  }
-  /**
-   * Analyze segments and determine if optimization would be beneficial
-   */
-  static shouldOptimize(e) {
-    if (e.length < 2) return !1;
-    let t = 0;
-    for (let n = 0; n < e.length - 1; n++) {
-      const r = e[n], i = e[n + 1];
-      r.component.constructor.name === "EnhancedText" && i.component.constructor.name === "EnhancedText" && t++;
-    }
-    return t > 0;
-  }
-  /**
-   * Get optimization statistics (enhanced for Phase 4.1)
-   */
-  static getOptimizationStats(e, t) {
-    const n = e.length - t.length, r = e.length > 0 ? Math.round(n / e.length * 100) : 0;
-    return {
-      originalCount: e.length,
-      optimizedCount: t.length,
-      reductionPercent: r,
-      textSegmentsMerged: n
-    };
-  }
-  /**
-   * Advanced optimization analysis for performance monitoring
-   */
-  static analyzeOptimizationOpportunities(e) {
-    let t = 0, n = 0, r = 0, i = 0;
-    for (let a = 0; a < e.length; a++) {
-      const u = e[a];
-      switch (u.component.constructor.name) {
-        case "EnhancedText":
-          if (t++, a < e.length - 1) {
-            const f = e[a + 1];
-            this.canMergeTextSegments(u, f) && i++;
-          }
-          break;
-        case "EnhancedImage":
-          n++;
-          break;
-        case "EnhancedButton":
-        case "EnhancedLinkComponent":
-          r++;
-          break;
-      }
-    }
-    const s = e.length > 0 ? Math.round(i / e.length * 100) : 0;
-    return {
-      totalSegments: e.length,
-      textSegments: t,
-      imageSegments: n,
-      interactiveSegments: r,
-      optimizableTextPairs: i,
-      estimatedReductionPercent: s
-    };
-  }
-}
-function C(o, e = {}) {
-  const { fallback: t, errorFallback: n, timeout: r = 1e4, preload: i = "never" } = e;
-  let s = !1, a = null, u = !1, d = null, f = null;
-  const y = async () => {
-    s || u || a || f || (s = !0, u = !0, d = null, f = (async () => {
-      try {
-        const p = await Promise.race([
-          o(),
-          new Promise(
-            (g, x) => setTimeout(() => x(new Error("Component load timeout")), r)
-          )
-        ]);
-        a = "default" in p ? p.default : p;
-      } catch (p) {
-        const g = p;
-        (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Failed to load lazy component:", g), d = g;
-      } finally {
-        u = !1, f = null;
-      }
-    })(), await f);
-  };
-  return i === "idle" && typeof requestIdleCallback < "u" ? requestIdleCallback(() => {
-    y().catch(() => {
-    });
-  }) : i === "idle" ? setTimeout(() => {
-    y().catch(() => {
-    });
-  }, 100) : i === "immediate" && y().catch(() => {
-  }), (p) => {
-    if (!s && !u && !a && y().catch(() => {
-    }), d)
-      return n ? n(d) : b(d);
-    if (u || !a)
-      return t || k();
-    try {
-      return typeof a == "function" ? a(p) : a;
-    } catch (g) {
-      const x = g;
-      return (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error rendering lazy component:", x), b(x);
-    }
-  };
-}
-function he(o) {
-  return {
-    type: "component",
-    render: () => ({
-      type: "element",
-      tag: "div",
-      props: { class: "tachui-suspense" },
-      children: o.children.map(() => ({
-        type: "element",
-        tag: "div",
-        children: []
-      }))
-    }),
-    props: o,
-    id: `suspense-${Math.random().toString(36).substr(2, 9)}`
-  };
-}
-function O(o) {
-  return o().then((e) => e && typeof e == "object" && "default" in e ? e.default : e);
-}
-function ge(o, e = {}) {
-  const t = {};
-  for (const [n, r] of Object.entries(o))
-    t[n] = C(r, e);
-  return t;
-}
-function ye(o) {
-  const e = Object.entries(o).map(
-    async ([t, n]) => [t, await O(n)]
-  );
-  return Promise.all(e).then((t) => {
-    const n = {};
-    for (const [r, i] of t)
-      n[r] = i;
-    return n;
-  });
-}
-function k() {
-  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 b(o) {
-  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: ${o.message}`
-      }
-    ]
-  };
-}
-function xe(o, e = {}) {
-  const { rootMargin: t = "50px", threshold: n = 0.1, ...r } = e;
-  return r.preload === "visible" && typeof IntersectionObserver < "u" ? (i) => {
-    const s = C(o, { ...r, preload: "never" });
-    return setTimeout(() => {
-      s(i);
-    }, 100), s(i);
-  } : C(o, r);
-}
-const Ce = Object.freeze({
-  configure: E,
-  getFeatureFlags: z
-});
-export {
-  se as C,
-  he as S,
-  fe as T,
-  ue as a,
-  pe as b,
-  le as c,
-  Y as d,
-  Z as e,
-  X as f,
-  Q as g,
-  ee as h,
-  me as i,
-  te as j,
-  ne as k,
-  oe as l,
-  de as m,
-  ie as n,
-  ae as o,
-  ce as p,
-  ge as q,
-  re as r,
-  xe as s,
-  Ce as t,
-  C as u,
-  O as v,
-  ye as w
-};