@jasonshimmy/custom-elements-runtime 2.5.0 → 2.5.2

package/dist/namespace-helpers-CF28TyaG.js

@@ -0,0 +1,786 @@
+import { d as L, a as m } from "./logger-BuUYv7C_.js";
+function x() {
+  const n = (() => {
+    try {
+      return globalThis.process?.env?.NODE_ENV;
+    } catch {
+      return;
+    }
+  })(), e = (() => {
+    try {
+      if (typeof window > "u")
+        return { vitest: !1, cypress: !1 };
+      const t = window;
+      return {
+        vitest: !!t.__vitest__,
+        cypress: !!t.Cypress
+      };
+    } catch {
+      return { vitest: !1, cypress: !1 };
+    }
+  })();
+  return {
+    isTest: n === "test" || e.vitest || e.cypress,
+    isVitest: e.vitest,
+    isCypress: e.cypress
+  };
+}
+class N {
+  pendingUpdates = /* @__PURE__ */ new Map();
+  isFlushScheduled = !1;
+  isFlushing = !1;
+  testEnv;
+  lastCleanup = 0;
+  CLEANUP_INTERVAL = 300 * 1e3;
+  // 5 minutes
+  MAX_PENDING_SIZE = 1e4;
+  // Prevent memory bloat
+  constructor() {
+    this.testEnv = x(), this.schedulePeriodicCleanup();
+  }
+  /**
+   * Schedule an update to be executed in the next microtask
+   * Uses component identity to deduplicate multiple render requests for the same component
+   */
+  schedule(e, s) {
+    const t = s || e;
+    this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(t, e), this.isFlushScheduled || this.scheduleFlush();
+  }
+  /**
+   * Schedule the flush operation based on environment
+   */
+  scheduleFlush() {
+    this.isFlushScheduled = !0, this.testEnv.isTest && !this.isFlushing ? this.flush() : queueMicrotask(() => this.flush());
+  }
+  /**
+   * Execute all pending updates
+   */
+  flush() {
+    if (this.isFlushing)
+      return;
+    this.isFlushing = !0;
+    const e = this.pendingUpdates;
+    this.pendingUpdates = /* @__PURE__ */ new Map(), this.isFlushScheduled = !1;
+    try {
+      for (const s of e.values())
+        try {
+          s();
+        } catch (t) {
+          L("Error in batched update:", t);
+        }
+    } finally {
+      this.isFlushing = !1;
+    }
+  }
+  /**
+   * Force flush any pending DOM updates immediately. This is useful in
+   * test environments or callers that require synchronous guarantees after
+   * state changes. Prefer relying on the scheduler's automatic flush when
+   * possible; use this only when a caller needs to synchronously observe
+   * rendered DOM changes.
+   */
+  flushImmediately() {
+    this.pendingUpdates.size !== 0 && (this.isFlushScheduled = !1, this.flush());
+  }
+  /**
+   * Get the number of pending updates
+   */
+  get pendingCount() {
+    return this.pendingUpdates.size;
+  }
+  /**
+   * Check if there are pending updates
+   */
+  get hasPendingUpdates() {
+    return this.pendingUpdates.size > 0;
+  }
+  /**
+   * Check if currently flushing updates
+   */
+  get isFlushingUpdates() {
+    return this.isFlushing;
+  }
+  /**
+   * Schedule periodic cleanup to prevent memory leaks
+   */
+  schedulePeriodicCleanup() {
+    if (this.testEnv.isTest) return;
+    const e = () => {
+      this.performPeriodicCleanup(), this.testEnv.isTest || setTimeout(e, this.CLEANUP_INTERVAL);
+    };
+    setTimeout(e, this.CLEANUP_INTERVAL);
+  }
+  /**
+   * Perform periodic cleanup of stale entries
+   */
+  performPeriodicCleanup() {
+    const e = Date.now();
+    e - this.lastCleanup < this.CLEANUP_INTERVAL || (this.pendingUpdates.size > 100 && m(
+      `Scheduler has ${this.pendingUpdates.size} pending updates. Consider investigating.`
+    ), this.lastCleanup = e);
+  }
+  /**
+   * Emergency cleanup when pending updates exceed safe limits
+   */
+  performEmergencyCleanup() {
+    m(
+      "Scheduler emergency cleanup: too many pending updates, clearing oldest entries"
+    );
+    const e = Array.from(this.pendingUpdates.entries()), s = Math.floor(e.length / 2);
+    for (let t = 0; t < s; t++)
+      this.pendingUpdates.delete(e[t][0]);
+  }
+}
+const b = new N();
+function D(n, e) {
+  b.schedule(n, e);
+}
+function I() {
+  b.flushImmediately();
+}
+const w = /* @__PURE__ */ new WeakSet();
+class H {
+  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(e, s, t = !1) {
+    const r = this.cache.get(e);
+    if (r)
+      return r;
+    const a = t ? this.getOrCreateArrayHandler(s) : this.getOrCreateObjectHandler(s), i = new Proxy(e, a);
+    try {
+      A.markAsProxy(i);
+    } catch {
+    }
+    return this.cache.set(e, i), i;
+  }
+  /**
+   * Get or create a cached array handler
+   */
+  static getOrCreateArrayHandler(e) {
+    if (!this.arrayHandlerCache.has(e)) {
+      const s = {
+        get: (t, r, a) => {
+          const i = Reflect.get(t, r, a);
+          return typeof i == "function" && typeof r == "string" && [
+            "push",
+            "pop",
+            "shift",
+            "unshift",
+            "splice",
+            "sort",
+            "reverse",
+            "fill",
+            "copyWithin"
+          ].includes(r) ? function(...u) {
+            const d = i.apply(t, u);
+            return e.triggerUpdate(), d;
+          } : i;
+        },
+        set: (t, r, a) => (t[r] = e.makeReactiveValue(a), e.triggerUpdate(), !0),
+        deleteProperty: (t, r) => (delete t[r], e.triggerUpdate(), !0)
+      };
+      this.arrayHandlerCache.set(e, s);
+    }
+    return this.arrayHandlerCache.get(e);
+  }
+  /**
+   * Get or create a cached object handler
+   */
+  static getOrCreateObjectHandler(e) {
+    if (!this.objectHandlerCache.has(e)) {
+      const s = {
+        get: (t, r, a) => Reflect.get(t, r, a),
+        set: (t, r, a) => (t[r] = e.makeReactiveValue(a), e.triggerUpdate(), !0),
+        deleteProperty: (t, r) => (delete t[r], e.triggerUpdate(), !0)
+      };
+      this.objectHandlerCache.set(e, s);
+    }
+    return this.objectHandlerCache.get(e);
+  }
+  /**
+   * Check if an object already has a cached proxy
+   */
+  static hasProxy(e) {
+    return this.cache.has(e);
+  }
+  /**
+   * 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 A {
+  // 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(e, s, t) {
+    try {
+      if (w.has(e)) return e;
+    } catch {
+    }
+    const r = Array.isArray(e);
+    let a = this.contextCache.get(s);
+    a || (a = /* @__PURE__ */ new WeakMap(), this.contextCache.set(s, a));
+    let i = a.get(t);
+    return i || (i = {
+      triggerUpdate: s,
+      makeReactiveValue: t
+    }, a.set(t, i)), H.getOrCreateProxy(e, i, r);
+  }
+  /**
+   * Mark an object as a proxy (for optimization)
+   */
+  static markAsProxy(e) {
+    if (e)
+      try {
+        w.add(e);
+      } catch {
+      }
+  }
+}
+class P {
+  // 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(e, s) {
+    if (this.currentComponentStack.push(e), !this.componentData.has(e))
+      this.componentData.set(e, {
+        dependencies: /* @__PURE__ */ new Set(),
+        renderFn: s,
+        stateIndex: 0,
+        lastWarnTime: 0,
+        watchers: /* @__PURE__ */ new Map()
+      });
+    else {
+      const t = this.componentData.get(e);
+      if (t.watchers && t.watchers.size) {
+        for (const r of t.watchers.values())
+          try {
+            this.cleanup(r);
+          } catch {
+          }
+        t.watchers.clear();
+      }
+      t.renderFn = s, t.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(e, s) {
+    const t = this.componentData.get(e);
+    t && t.watchers.set(s, s);
+  }
+  /**
+   * 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 e = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!e) return !0;
+    const s = this.componentData.get(e);
+    if (!s) return !0;
+    const t = Date.now();
+    return t - s.lastWarnTime < 1e3 ? !1 : (s.lastWarnTime = t, !0);
+  }
+  /**
+   * Execute a function with tracking disabled
+   */
+  withoutTracking(e) {
+    const s = this.trackingDisabled;
+    this.trackingDisabled = !0;
+    try {
+      return e();
+    } finally {
+      this.trackingDisabled = s;
+    }
+  }
+  /**
+   * Get or create a state instance for the current component
+   */
+  getOrCreateState(e) {
+    const s = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!s)
+      return new g(e);
+    const t = this.componentData.get(s);
+    if (!t)
+      return new g(e);
+    const r = `${s}:${t.stateIndex++}`;
+    let a = this.stateStorage.get(r);
+    return a || (a = new g(e), this.stateStorage.set(r, a)), a;
+  }
+  /**
+   * Track a dependency for the current component
+   */
+  trackDependency(e) {
+    if (this.trackingDisabled) return;
+    const s = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!s) return;
+    const t = this.componentData.get(s);
+    t && (t.dependencies.add(e), e.addDependent(s));
+  }
+  /**
+   * Trigger updates for all components that depend on a state
+   */
+  triggerUpdate(e) {
+    const s = e.getDependents();
+    for (const t of s) {
+      const r = this.componentData.get(t);
+      r && D(r.renderFn, t);
+    }
+  }
+  /**
+   * Clean up component dependencies when component is destroyed
+   */
+  cleanup(e) {
+    const s = this.componentData.get(e);
+    if (s) {
+      for (const r of s.dependencies)
+        r.removeDependent(e);
+      this.componentData.delete(e);
+    }
+    const t = e + ":";
+    for (const r of this.stateStorage.keys())
+      r.startsWith(t) && this.stateStorage.delete(r);
+  }
+}
+const o = new P();
+class g {
+  _value;
+  dependents = /* @__PURE__ */ new Set();
+  constructor(e) {
+    this._value = this.makeReactive(e);
+    try {
+      const s = Symbol.for("@cer/ReactiveState");
+      Object.defineProperty(this, s, {
+        value: !0,
+        enumerable: !1,
+        configurable: !1
+      });
+    } catch {
+    }
+  }
+  get value() {
+    return o.trackDependency(this), this._value;
+  }
+  set value(e) {
+    o.isRenderingComponent() && o.shouldEmitRenderWarning() && m(
+      `🚨 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(e), o.triggerUpdate(this);
+  }
+  addDependent(e) {
+    this.dependents.add(e);
+  }
+  removeDependent(e) {
+    this.dependents.delete(e);
+  }
+  getDependents() {
+    return this.dependents;
+  }
+  makeReactive(e) {
+    return e === null || typeof e != "object" || e instanceof Node || e instanceof Element || e instanceof HTMLElement ? e : A.createReactiveProxy(
+      e,
+      () => o.triggerUpdate(this),
+      (s) => this.makeReactive(s)
+    );
+  }
+}
+function j(n) {
+  return o.getOrCreateState(
+    n === void 0 ? null : n
+  );
+}
+function y(n) {
+  if (!n || typeof n != "object") return !1;
+  try {
+    const e = Symbol.for("@cer/ReactiveState");
+    return Object.prototype.hasOwnProperty.call(n, e);
+  } catch {
+    return !1;
+  }
+}
+function z(n) {
+  const e = new g(n());
+  return {
+    get value() {
+      return o.trackDependency(e), n();
+    }
+  };
+}
+function V(n, e, s) {
+  let t;
+  const r = y(n) ? () => n.value : n, 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 = r();
+    o.clearCurrentComponent(), c !== t && (e(c, t), t = c);
+  };
+  return o.setCurrentComponent(a, i), t = r(), o.clearCurrentComponent(), s && s.immediate && e(t, void 0), () => {
+    o.cleanup(a);
+  };
+}
+const $ = (n) => {
+  try {
+    n();
+  } catch {
+  }
+}, h = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), C = 500;
+let E, k, S = !1, _ = !1, M;
+const R = !!globalThis.process?.versions?.node;
+function q(n) {
+  if (h.has(n))
+    return h.get(n);
+  const e = n.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return h.size < C && h.set(n, e), e;
+}
+function G(n) {
+  if (p.has(n))
+    return p.get(n);
+  const e = n.replace(/-([a-z])/g, (s, t) => t.toUpperCase());
+  return p.size < C && p.set(n, e), e;
+}
+function Z(n) {
+  if (typeof n == "string") {
+    if (f.has(n))
+      return f.get(n);
+    const e = n.replace(
+      /[&<>"']/g,
+      (s) => ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;"
+      })[s]
+    );
+    return e !== n && f.size < C && f.set(n, e), e;
+  }
+  return n;
+}
+function l(n) {
+  if (!n) return "";
+  const e = String(n);
+  if (typeof document < "u" && typeof document.createElement == "function") {
+    const c = e.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 s = {
+    lt: "<",
+    gt: ">",
+    amp: "&",
+    quot: '"',
+    apos: "'",
+    nbsp: " "
+  }, t = E ?? l._namedMap;
+  let r = t;
+  if (!r && 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") {
+              r = u;
+              break;
+            }
+          } catch {
+          }
+      }
+    } catch {
+    }
+  if (!r) {
+    r = s, S = !0;
+    try {
+      l._usedFallback = !0;
+    } catch {
+    }
+    const a = l._namedMapLoader ?? k;
+    a && a().then((i) => {
+      E = i;
+      try {
+        l._namedMap = i;
+      } catch {
+      }
+    }).catch(() => {
+    });
+  }
+  if ((S || l._usedFallback) && !(_ || l._warnedFallback)) {
+    _ = !0;
+    try {
+      l._warnedFallback = !0;
+    } catch {
+    }
+    try {
+      m(
+        "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 e.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 = r[i] ?? (t && t[i]);
+    return c !== void 0 ? c : `&${i};`;
+  });
+}
+async function T() {
+  const n = [
+    "@jasonshimmy",
+    "custom-elements-runtime",
+    "entities.json"
+  ].join("/");
+  try {
+    const e = await import(
+      /* @vite-ignore */
+      n
+    );
+    return e && (e.default || e);
+  } catch {
+    try {
+      const e = [
+        n,
+        // try package export via dynamic import too (best for installed packages)
+        "./entities.json",
+        "../../entities.json",
+        "../../../entities.json"
+      ];
+      for (const s of e)
+        try {
+          const t = await import(
+            /* @vite-ignore */
+            s
+          );
+          if (t)
+            return t && (t.default || t);
+        } catch {
+        }
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    } catch {
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    }
+  }
+}
+k = T;
+l._namedMapLoader = T;
+function B(n) {
+  const e = String(n);
+  return { __unsafeHTML: e, __rawHTML: e };
+}
+function K(n) {
+  return !!n && (typeof n.__unsafeHTML == "string" || typeof n.__rawHTML == "string");
+}
+function X(n, e) {
+  if (typeof e == "string") {
+    if (e === "") return;
+    const s = e.split(".");
+    let t = n;
+    for (const r of s) {
+      if (t == null || typeof t != "object") {
+        t = void 0;
+        break;
+      }
+      t = t[r];
+    }
+    return y(t) ? t.value : t;
+  }
+  return e;
+}
+function J(n, e, s) {
+  const t = String(e).split("."), r = t.pop();
+  if (!r) return;
+  const a = t.reduce(
+    (i, c) => (i[c] == null && (i[c] = {}), i[c]),
+    n
+  );
+  y(a[r]) ? a[r].value = s : a[r] = s;
+}
+function U(n) {
+  try {
+    if (n && typeof n == "object") {
+      if (y(n)) return n.value;
+      if ("value" in n) {
+        const e = n.value;
+        return e == null || typeof e == "string" || typeof e == "number" || typeof e == "boolean" ? e : n;
+      }
+    }
+  } catch {
+  }
+  return n;
+}
+function Q(n) {
+  const e = U(n);
+  if (e == null) return null;
+  const s = typeof e;
+  return s === "string" || s === "number" || s === "boolean" ? String(e) : null;
+}
+function Y(n) {
+  if (!n || typeof n != "string") return !1;
+  if (n === "class" || n.endsWith("Class")) return !0;
+  if (n.includes("-"))
+    try {
+      if (n.split("-").some((s) => s === "class")) return !0;
+    } catch {
+    }
+  return !1;
+}
+const v = {
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
+function ee(n, e, s) {
+  try {
+    if (!e || !e.includes(":")) {
+      n.setAttribute(e, s);
+      return;
+    }
+    const t = e.indexOf(":"), r = e.substring(0, t), a = e.substring(t + 1), i = v[r];
+    i ? n.setAttributeNS(i, a, s) : n.setAttribute(e, s);
+  } catch {
+    try {
+      n.setAttribute(e, s);
+    } catch {
+    }
+  }
+}
+function te(n, e) {
+  try {
+    if (!e || !e.includes(":")) {
+      n.removeAttribute(e);
+      return;
+    }
+    const s = e.indexOf(":"), t = e.substring(0, s), r = e.substring(s + 1), a = v[t];
+    a ? n.removeAttributeNS(a, r) : n.removeAttribute(e);
+  } catch {
+    try {
+      n.removeAttribute(e);
+    } catch {
+    }
+  }
+}
+const F = "http://www.w3.org/2000/svg", O = "http://www.w3.org/1998/Math/MathML", ne = {
+  svg: F,
+  math: O
+};
+export {
+  F as S,
+  ne as T,
+  $ as a,
+  Q as b,
+  z as c,
+  l as d,
+  Z as e,
+  I as f,
+  X as g,
+  ee as h,
+  y as i,
+  te as j,
+  G as k,
+  Y as l,
+  o as m,
+  D as n,
+  K as o,
+  j as r,
+  J as s,
+  q as t,
+  B as u,
+  V as w
+};
+//# sourceMappingURL=namespace-helpers-CF28TyaG.js.map