@jasonshimmy/custom-elements-runtime 2.2.9 → 2.3.0

package/dist/namespace-helpers-Dw1mgQab.js

@@ -0,0 +1,692 @@
+import { d as x, a as _ } from "./logger-BuUYv7C_.js";
+class v {
+  pendingUpdates = /* @__PURE__ */ new Map();
+  isFlushScheduled = !1;
+  /**
+   * Schedule an update to be executed in the next microtask
+   * Uses component identity to deduplicate multiple render requests for the same component
+   */
+  schedule(t, r) {
+    const n = r || t;
+    if (this.pendingUpdates.set(n, t), !this.isFlushScheduled) {
+      this.isFlushScheduled = !0;
+      const s = globalThis.process;
+      typeof s < "u" && s.env?.NODE_ENV === "test" || typeof window < "u" && (window.__vitest__ || window.Cypress) ? this.flush() : queueMicrotask(() => this.flush());
+    }
+  }
+  /**
+   * Execute all pending updates
+   */
+  flush() {
+    const t = this.pendingUpdates;
+    this.pendingUpdates = /* @__PURE__ */ new Map(), this.isFlushScheduled = !1;
+    for (const r of t.values())
+      try {
+        r();
+      } catch (n) {
+        x("Error in batched update:", n);
+      }
+  }
+  /**
+   * Get the number of pending updates
+   */
+  get pendingCount() {
+    return this.pendingUpdates.size;
+  }
+}
+const H = new v();
+function L(e, t) {
+  H.schedule(e, t);
+}
+const C = /* @__PURE__ */ new WeakSet();
+class D {
+  static cache = /* @__PURE__ */ new WeakMap();
+  static arrayHandlerCache = /* @__PURE__ */ new WeakMap();
+  static objectHandlerCache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Get or create a reactive proxy for an object
+   */
+  static getOrCreateProxy(t, r, n = !1) {
+    const s = this.cache.get(t);
+    if (s)
+      return s;
+    const a = n ? this.getOrCreateArrayHandler(r) : this.getOrCreateObjectHandler(r), i = new Proxy(t, a);
+    try {
+      E.markAsProxy(i);
+    } catch {
+    }
+    return this.cache.set(t, i), i;
+  }
+  /**
+   * Get or create a cached array handler
+   */
+  static getOrCreateArrayHandler(t) {
+    if (!this.arrayHandlerCache.has(t)) {
+      const r = {
+        get: (n, s, a) => {
+          const i = Reflect.get(n, s, a);
+          return typeof i == "function" && typeof s == "string" && [
+            "push",
+            "pop",
+            "shift",
+            "unshift",
+            "splice",
+            "sort",
+            "reverse",
+            "fill",
+            "copyWithin"
+          ].includes(s) ? function(...u) {
+            const d = i.apply(n, u);
+            return t.triggerUpdate(), d;
+          } : i;
+        },
+        set: (n, s, a) => (n[s] = t.makeReactiveValue(a), t.triggerUpdate(), !0),
+        deleteProperty: (n, s) => (delete n[s], t.triggerUpdate(), !0)
+      };
+      this.arrayHandlerCache.set(t, r);
+    }
+    return this.arrayHandlerCache.get(t);
+  }
+  /**
+   * Get or create a cached object handler
+   */
+  static getOrCreateObjectHandler(t) {
+    if (!this.objectHandlerCache.has(t)) {
+      const r = {
+        get: (n, s, a) => Reflect.get(n, s, a),
+        set: (n, s, a) => (n[s] = t.makeReactiveValue(a), t.triggerUpdate(), !0),
+        deleteProperty: (n, s) => (delete n[s], t.triggerUpdate(), !0)
+      };
+      this.objectHandlerCache.set(t, r);
+    }
+    return this.objectHandlerCache.get(t);
+  }
+  /**
+   * Check if an object already has a cached proxy
+   */
+  static hasProxy(t) {
+    return this.cache.has(t);
+  }
+  /**
+   * Clear all cached proxies (useful for testing)
+   */
+  static clear() {
+    this.cache = /* @__PURE__ */ new WeakMap(), this.arrayHandlerCache = /* @__PURE__ */ new WeakMap(), this.objectHandlerCache = /* @__PURE__ */ new WeakMap();
+  }
+  /**
+   * Get cache statistics (for debugging)
+   * Note: WeakMap doesn't provide size, so this is limited
+   */
+  static getStats() {
+    return {
+      hasCachedProxies: this.cache instanceof WeakMap
+    };
+  }
+}
+class E {
+  // Cache a stable reactiveContext object keyed by onUpdate -> makeReactive
+  // This allows handler caches in ReactiveProxyCache to reuse handlers
+  // for identical reactive contexts instead of creating a new context object
+  // on each createReactiveProxy call.
+  static contextCache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Create an optimized reactive proxy with minimal overhead
+   */
+  static createReactiveProxy(t, r, n) {
+    try {
+      if (C.has(t)) return t;
+    } catch {
+    }
+    const s = Array.isArray(t);
+    let a = this.contextCache.get(r);
+    a || (a = /* @__PURE__ */ new WeakMap(), this.contextCache.set(r, a));
+    let i = a.get(n);
+    return i || (i = {
+      triggerUpdate: r,
+      makeReactiveValue: n
+    }, a.set(n, i)), D.getOrCreateProxy(t, i, s);
+  }
+  /**
+   * Mark an object as a proxy (for optimization)
+   */
+  static markAsProxy(t) {
+    if (t)
+      try {
+        C.add(t);
+      } catch {
+      }
+  }
+}
+class N {
+  // Use a stack to support nested callers (component render -> watcher)
+  // so that watchers can temporarily become the "current component" while
+  // establishing dependencies without clobbering the outer component id.
+  currentComponentStack = [];
+  // Consolidated component data: stores dependencies, render function, state index, and last warning time
+  componentData = /* @__PURE__ */ new Map();
+  // Flat storage: compound key `${componentId}:${stateIndex}` -> ReactiveState
+  stateStorage = /* @__PURE__ */ new Map();
+  trackingDisabled = !1;
+  /**
+   * Set the current component being rendered for dependency tracking
+   */
+  setCurrentComponent(t, r) {
+    if (this.currentComponentStack.push(t), !this.componentData.has(t))
+      this.componentData.set(t, {
+        dependencies: /* @__PURE__ */ new Set(),
+        renderFn: r,
+        stateIndex: 0,
+        lastWarnTime: 0,
+        watchers: /* @__PURE__ */ new Map()
+      });
+    else {
+      const n = this.componentData.get(t);
+      if (n.watchers && n.watchers.size) {
+        for (const s of n.watchers.values())
+          try {
+            this.cleanup(s);
+          } catch {
+          }
+        n.watchers.clear();
+      }
+      n.renderFn = r, n.stateIndex = 0;
+    }
+  }
+  /**
+   * Clear the current component after rendering
+   */
+  clearCurrentComponent() {
+    this.currentComponentStack.pop();
+  }
+  /**
+   * Get the current component id (top of stack) or null
+   */
+  getCurrentComponentId() {
+    return this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+  }
+  /**
+   * Register a watcher id under a component so it can be cleaned up on re-render
+   */
+  registerWatcher(t, r) {
+    const n = this.componentData.get(t);
+    n && n.watchers.set(r, r);
+  }
+  /**
+   * Temporarily disable dependency tracking
+   */
+  disableTracking() {
+    this.trackingDisabled = !0;
+  }
+  /**
+   * Re-enable dependency tracking
+   */
+  enableTracking() {
+    this.trackingDisabled = !1;
+  }
+  /**
+   * Check if a component is currently rendering
+   */
+  isRenderingComponent() {
+    return this.currentComponentStack.length > 0;
+  }
+  /**
+   * Return whether we should emit a render-time warning for the current component.
+   * This throttles warnings to avoid spamming the console for legitimate rapid updates.
+   */
+  shouldEmitRenderWarning() {
+    const t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!t) return !0;
+    const r = this.componentData.get(t);
+    if (!r) return !0;
+    const n = Date.now();
+    return n - r.lastWarnTime < 1e3 ? !1 : (r.lastWarnTime = n, !0);
+  }
+  /**
+   * Execute a function with tracking disabled
+   */
+  withoutTracking(t) {
+    const r = this.trackingDisabled;
+    this.trackingDisabled = !0;
+    try {
+      return t();
+    } finally {
+      this.trackingDisabled = r;
+    }
+  }
+  /**
+   * Get or create a state instance for the current component
+   */
+  getOrCreateState(t) {
+    const r = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!r)
+      return new g(t);
+    const n = this.componentData.get(r);
+    if (!n)
+      return new g(t);
+    const s = `${r}:${n.stateIndex++}`;
+    let a = this.stateStorage.get(s);
+    return a || (a = new g(t), this.stateStorage.set(s, a)), a;
+  }
+  /**
+   * Track a dependency for the current component
+   */
+  trackDependency(t) {
+    if (this.trackingDisabled) return;
+    const r = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!r) return;
+    const n = this.componentData.get(r);
+    n && (n.dependencies.add(t), t.addDependent(r));
+  }
+  /**
+   * Trigger updates for all components that depend on a state
+   */
+  triggerUpdate(t) {
+    const r = t.getDependents();
+    for (const n of r) {
+      const s = this.componentData.get(n);
+      s && L(s.renderFn, n);
+    }
+  }
+  /**
+   * Clean up component dependencies when component is destroyed
+   */
+  cleanup(t) {
+    const r = this.componentData.get(t);
+    if (r) {
+      for (const s of r.dependencies)
+        s.removeDependent(t);
+      this.componentData.delete(t);
+    }
+    const n = t + ":";
+    for (const s of this.stateStorage.keys())
+      s.startsWith(n) && this.stateStorage.delete(s);
+  }
+}
+const o = new N();
+class g {
+  _value;
+  dependents = /* @__PURE__ */ new Set();
+  constructor(t) {
+    this._value = this.makeReactive(t);
+    try {
+      const r = Symbol.for("@cer/ReactiveState");
+      Object.defineProperty(this, r, {
+        value: !0,
+        enumerable: !1,
+        configurable: !1
+      });
+    } catch {
+    }
+  }
+  get value() {
+    return o.trackDependency(this), this._value;
+  }
+  set value(t) {
+    o.isRenderingComponent() && o.shouldEmitRenderWarning() && _(
+      `🚨 State modification detected during render! This can cause infinite loops.
+  • Move state updates to event handlers
+  • Use useEffect/watch for side effects
+  • Ensure computed properties don't modify state`
+    ), this._value = this.makeReactive(t), o.triggerUpdate(this);
+  }
+  addDependent(t) {
+    this.dependents.add(t);
+  }
+  removeDependent(t) {
+    this.dependents.delete(t);
+  }
+  getDependents() {
+    return this.dependents;
+  }
+  makeReactive(t) {
+    return t === null || typeof t != "object" || t instanceof Node || t instanceof Element || t instanceof HTMLElement ? t : E.createReactiveProxy(
+      t,
+      () => o.triggerUpdate(this),
+      (r) => this.makeReactive(r)
+    );
+  }
+}
+function j(e) {
+  return o.getOrCreateState(
+    e === void 0 ? null : e
+  );
+}
+function m(e) {
+  if (!e || typeof e != "object") return !1;
+  try {
+    const t = Symbol.for("@cer/ReactiveState");
+    return Object.prototype.hasOwnProperty.call(e, t);
+  } catch {
+    return !1;
+  }
+}
+function F(e) {
+  const t = new g(e());
+  return {
+    get value() {
+      return o.trackDependency(t), e();
+    }
+  };
+}
+function z(e, t, r) {
+  let n;
+  const s = (() => {
+    try {
+      if (m(e))
+        return () => e.value;
+    } catch {
+    }
+    return e;
+  })(), a = `watch-${Math.random().toString(36).substr(2, 9)}`;
+  try {
+    const c = o.getCurrentComponentId();
+    c && o.registerWatcher(c, a);
+  } catch {
+  }
+  const i = () => {
+    o.setCurrentComponent(a, i);
+    const c = s();
+    o.clearCurrentComponent(), c !== n && (t(c, n), n = c);
+  };
+  return o.setCurrentComponent(a, i), n = s(), o.clearCurrentComponent(), r && r.immediate && t(n, void 0), () => {
+    o.cleanup(a);
+  };
+}
+const I = (e) => {
+  try {
+    e();
+  } catch {
+  }
+}, h = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), y = 500;
+let w, k, S = !1, b = !1, M;
+const R = !!globalThis.process?.versions?.node;
+function q(e) {
+  if (h.has(e))
+    return h.get(e);
+  const t = e.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return h.size < y && h.set(e, t), t;
+}
+function $(e) {
+  if (p.has(e))
+    return p.get(e);
+  const t = e.replace(/-([a-z])/g, (r, n) => n.toUpperCase());
+  return p.size < y && p.set(e, t), t;
+}
+function V(e) {
+  if (typeof e == "string") {
+    if (f.has(e))
+      return f.get(e);
+    const t = e.replace(
+      /[&<>"']/g,
+      (r) => ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;"
+      })[r]
+    );
+    return t !== e && f.size < y && f.set(e, t), t;
+  }
+  return e;
+}
+function l(e) {
+  if (!e) return "";
+  const t = String(e);
+  if (typeof document < "u" && typeof document.createElement == "function") {
+    const c = t.replace(/</g, "").replace(/>/g, ""), u = M || (M = document.createElement("div"));
+    try {
+      l._el = u;
+    } catch {
+    }
+    return u.innerHTML = c, (u.textContent || "").replace(new RegExp("", "g"), "<").replace(new RegExp("", "g"), ">");
+  }
+  const r = {
+    lt: "<",
+    gt: ">",
+    amp: "&",
+    quot: '"',
+    apos: "'",
+    nbsp: " "
+  }, n = w ?? l._namedMap;
+  let s = n;
+  if (!s && R)
+    try {
+      const a = globalThis.require;
+      if (typeof a == "function") {
+        const i = [
+          "@jasonshimmy/custom-elements-runtime/entities.json",
+          // installed package export
+          "../../entities.json",
+          // dist/runtime -> ../../entities.json
+          "../../../entities.json",
+          // src/lib/runtime -> ../../../entities.json
+          "../entities.json",
+          "./entities.json"
+        ];
+        for (const c of i)
+          try {
+            const u = a(c);
+            if (u && typeof u == "object") {
+              s = u;
+              break;
+            }
+          } catch {
+          }
+      }
+    } catch {
+    }
+  if (!s) {
+    s = r, S = !0;
+    try {
+      l._usedFallback = !0;
+    } catch {
+    }
+    const a = l._namedMapLoader ?? k;
+    a && a().then((i) => {
+      w = i;
+      try {
+        l._namedMap = i;
+      } catch {
+      }
+    }).catch(() => {
+    });
+  }
+  if ((S || l._usedFallback) && !(b || l._warnedFallback)) {
+    b = !0;
+    try {
+      l._warnedFallback = !0;
+    } catch {
+    }
+    try {
+      _(
+        "decodeEntities: using small SSR fallback entity map. Register the full entities.json via registerEntityMap(entities) on the server to enable full HTML5 named-entity decoding."
+      );
+    } catch {
+    }
+  }
+  return t.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (a, i) => {
+    if (i.charCodeAt(0) === 35) {
+      const d = (i.charAt(1) || "").toLowerCase() === "x" ? parseInt(i.slice(2), 16) : parseInt(i.slice(1), 10);
+      return Number.isNaN(d) ? `&${i};` : String.fromCodePoint(d);
+    }
+    const c = s[i] ?? (n && n[i]);
+    return c !== void 0 ? c : `&${i};`;
+  });
+}
+async function A() {
+  const e = [
+    "@jasonshimmy",
+    "custom-elements-runtime",
+    "entities.json"
+  ].join("/");
+  try {
+    const t = await import(
+      /* @vite-ignore */
+      e
+    );
+    return t && (t.default || t);
+  } catch {
+    try {
+      const t = [
+        e,
+        // try package export via dynamic import too (best for installed packages)
+        "./entities.json",
+        "../../entities.json",
+        "../../../entities.json"
+      ];
+      for (const r of t)
+        try {
+          const n = await import(
+            /* @vite-ignore */
+            r
+          );
+          if (n)
+            return n && (n.default || n);
+        } catch {
+        }
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    } catch {
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    }
+  }
+}
+k = A;
+l._namedMapLoader = A;
+function G(e) {
+  const t = String(e);
+  return { __unsafeHTML: t, __rawHTML: t };
+}
+function K(e) {
+  return !!e && (typeof e.__unsafeHTML == "string" || typeof e.__rawHTML == "string");
+}
+function Z(e, t) {
+  if (typeof t == "string") {
+    if (t === "") return;
+    const r = t.split(".");
+    let n = e;
+    for (const s of r) {
+      if (n == null || typeof n != "object") {
+        n = void 0;
+        break;
+      }
+      n = n[s];
+    }
+    return m(n) ? n.value : n;
+  }
+  return t;
+}
+function B(e, t, r) {
+  const n = String(t).split("."), s = n.pop();
+  if (!s) return;
+  const a = n.reduce(
+    (i, c) => (i[c] == null && (i[c] = {}), i[c]),
+    e
+  );
+  m(a[s]) ? a[s].value = r : a[s] = r;
+}
+function P(e) {
+  try {
+    if (e && typeof e == "object") {
+      if (m(e)) return e.value;
+      if ("value" in e) {
+        const t = e.value;
+        return t == null || typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? t : e;
+      }
+    }
+  } catch {
+  }
+  return e;
+}
+function X(e) {
+  const t = P(e);
+  if (t == null) return null;
+  const r = typeof t;
+  return r === "string" || r === "number" || r === "boolean" ? String(t) : null;
+}
+function J(e) {
+  if (!e || typeof e != "string") return !1;
+  if (e === "class" || e.endsWith("Class")) return !0;
+  if (e.includes("-"))
+    try {
+      if (e.split("-").some((r) => r === "class")) return !0;
+    } catch {
+    }
+  return !1;
+}
+const T = {
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
+function Q(e, t, r) {
+  try {
+    if (!t || !t.includes(":")) {
+      e.setAttribute(t, r);
+      return;
+    }
+    const n = t.indexOf(":"), s = t.substring(0, n), a = t.substring(n + 1), i = T[s];
+    i ? e.setAttributeNS(i, a, r) : e.setAttribute(t, r);
+  } catch {
+    try {
+      e.setAttribute(t, r);
+    } catch {
+    }
+  }
+}
+function Y(e, t) {
+  try {
+    if (!t || !t.includes(":")) {
+      e.removeAttribute(t);
+      return;
+    }
+    const r = t.indexOf(":"), n = t.substring(0, r), s = t.substring(r + 1), a = T[n];
+    a ? e.removeAttributeNS(a, s) : e.removeAttribute(t);
+  } catch {
+    try {
+      e.removeAttribute(t);
+    } catch {
+    }
+  }
+}
+const W = "http://www.w3.org/2000/svg", O = "http://www.w3.org/1998/Math/MathML", tt = {
+  svg: W,
+  math: O
+};
+export {
+  W as S,
+  tt as T,
+  I as a,
+  X as b,
+  F as c,
+  Q as d,
+  V as e,
+  Y as f,
+  Z as g,
+  $ as h,
+  m as i,
+  J as j,
+  o as k,
+  L as l,
+  K as m,
+  l as n,
+  j as r,
+  B as s,
+  q as t,
+  G as u,
+  z as w
+};
+//# sourceMappingURL=namespace-helpers-Dw1mgQab.js.map