sibujs 4.4.0 → 4.6.0

package/dist/chunk-J6FW5TV6.js

@@ -0,0 +1,233 @@
+import {
+  globalSingleton
+} from "./chunk-7ZHH77QA.js";
+import {
+  adoptThenable
+} from "./chunk-5HZXGZ6T.js";
+import {
+  DEV,
+  devWarn,
+  reportError
+} from "./chunk-NYNYSPK7.js";
+
+// src/plugins/plugin.ts
+var CANCELLED_BRAND = /* @__PURE__ */ Symbol.for("sibujs.plugins.installCancelled.v1");
+var _a;
+var PluginInstallCancelledError = class extends Error {
+  constructor(pluginName) {
+    super(`[Plugin] Installation of "${pluginName}" was cancelled before it was committed (registry reset).`);
+    /**
+     * Brand, not identity: the default registry is shared across duplicate copies
+     * of this module, so the error a caller receives may come from another copy's
+     * constructor. `instanceof` is taught to recognise the brand instead.
+     */
+    this[_a] = true;
+    this.name = "PluginInstallCancelledError";
+    this.pluginName = pluginName;
+  }
+  static [(_a = CANCELLED_BRAND, Symbol.hasInstance)](value) {
+    return isPluginInstallCancelledError(value);
+  }
+};
+function isPluginInstallCancelledError(value) {
+  return typeof value === "object" && value !== null && value[CANCELLED_BRAND] === true;
+}
+function createPluginRegistry() {
+  const installedPlugins = /* @__PURE__ */ new Set();
+  const hooks = { init: [], mount: [], unmount: [], error: [] };
+  const provided = /* @__PURE__ */ new Map();
+  const installStack = /* @__PURE__ */ new Set();
+  const pendingInstalls = /* @__PURE__ */ new Map();
+  let generation = 0;
+  const registry = {
+    installedPlugins,
+    hooks,
+    provided,
+    /**
+     * Install a plugin as a transaction.
+     *
+     * Hooks and providers registered through `ctx` are staged and committed
+     * only if `install()` returns; a throwing install leaves the registry
+     * exactly as it found it (and can simply be retried). The plugin is marked
+     * installed at commit, before its init hooks run.
+     *
+     * Each `plugin()` call is its own transaction: a dependency installed by a
+     * nested `plugin()` call commits on its own and stays installed even if the
+     * outer installation later fails.
+     */
+    plugin(p, options) {
+      if (installedPlugins.has(p.name)) {
+        console.warn(`[Plugin] "${p.name}" is already installed.`);
+        return;
+      }
+      if (installStack.has(p.name)) {
+        throw new Error(`[Plugin] "${p.name}" is already being installed (recursive installation).`);
+      }
+      if (pendingInstalls.has(p.name)) {
+        throw new Error(`[Plugin] "${p.name}" is already being installed (asynchronous installation in flight).`);
+      }
+      const staged = { init: [], mount: [], unmount: [], error: [] };
+      const stagedProvided = /* @__PURE__ */ new Map();
+      let committed = false;
+      const myGeneration = generation;
+      const stale = () => {
+        if (myGeneration === generation) return false;
+        if (DEV) devWarn(`plugin: "${p.name}" registered after the registry was reset; the registration was ignored.`);
+        return true;
+      };
+      const target = () => stale() ? null : committed ? hooks : staged;
+      const ctx = {
+        onInit: (cb) => void target()?.init.push(cb),
+        onMount: (cb) => void target()?.mount.push(cb),
+        onUnmount: (cb) => void target()?.unmount.push(cb),
+        onError: (cb) => void target()?.error.push(cb),
+        provide: (key, value) => {
+          if (stale()) return;
+          (committed ? provided : stagedProvided).set(key, value);
+        }
+      };
+      const commit = () => {
+        if (myGeneration !== generation) return false;
+        hooks.init.push(...staged.init);
+        hooks.mount.push(...staged.mount);
+        hooks.unmount.push(...staged.unmount);
+        hooks.error.push(...staged.error);
+        for (const [key, value] of stagedProvided) provided.set(key, value);
+        installedPlugins.add(p.name);
+        committed = true;
+        if (pendingInstalls.get(p.name) === myGeneration) pendingInstalls.delete(p.name);
+        for (const cb of staged.init.slice()) {
+          try {
+            cb();
+          } catch (e) {
+            console.error(`[Plugin] "${p.name}" init error:`, e);
+          }
+        }
+        return true;
+      };
+      installStack.add(p.name);
+      let pending;
+      try {
+        pending = adoptThenable(p.install(ctx, options));
+      } finally {
+        installStack.delete(p.name);
+      }
+      if (!pending) {
+        if (!commit()) throw new PluginInstallCancelledError(p.name);
+        return;
+      }
+      if (myGeneration === generation) pendingInstalls.set(p.name, myGeneration);
+      const settled = pending.then(
+        () => {
+          if (commit()) return;
+          if (pendingInstalls.get(p.name) === myGeneration) pendingInstalls.delete(p.name);
+          throw new PluginInstallCancelledError(p.name);
+        },
+        (err) => {
+          if (pendingInstalls.get(p.name) === myGeneration) pendingInstalls.delete(p.name);
+          reportError(err, { phase: "async", name: `plugin(${p.name})` });
+          throw err;
+        }
+      );
+      settled.catch(() => {
+      });
+      return settled;
+    },
+    inject(key, defaultValue) {
+      if (provided.has(key)) return provided.get(key);
+      if (defaultValue !== void 0) return defaultValue;
+      throw new Error(`[Plugin] No provider found for key "${key}"`);
+    },
+    triggerMount(element) {
+      const snapshot = hooks.mount.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(element);
+        } catch (e) {
+          console.error("[Plugin] Mount hook error:", e);
+        }
+      }
+    },
+    triggerUnmount(element) {
+      const snapshot = hooks.unmount.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(element);
+        } catch (e) {
+          console.error("[Plugin] Unmount hook error:", e);
+        }
+      }
+    },
+    triggerError(error) {
+      const snapshot = hooks.error.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(error);
+        } catch (e) {
+          console.error("[Plugin] Error hook error:", e);
+        }
+      }
+    },
+    reset() {
+      generation++;
+      pendingInstalls.clear();
+      installedPlugins.clear();
+      hooks.init.length = 0;
+      hooks.mount.length = 0;
+      hooks.unmount.length = 0;
+      hooks.error.length = 0;
+      provided.clear();
+    }
+  };
+  return registry;
+}
+var _defaults = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.plugins.defaultRegistry.v1"), () => ({
+  registry: createPluginRegistry(),
+  touched: false
+}));
+function createPlugin(name, install) {
+  return { name, install };
+}
+function plugin(plugin2, options) {
+  _defaults.touched = true;
+  return _defaults.registry.plugin(plugin2, options);
+}
+function inject(key, defaultValue) {
+  return _defaults.registry.inject(key, defaultValue);
+}
+function triggerPluginMount(element) {
+  _defaults.registry.triggerMount(element);
+}
+function triggerPluginUnmount(element) {
+  _defaults.registry.triggerUnmount(element);
+}
+function triggerPluginError(error) {
+  _defaults.registry.triggerError(error);
+}
+function resetPlugins() {
+  _defaults.registry.reset();
+  _defaults.touched = false;
+}
+function setDefaultPluginRegistry(registry) {
+  if (_defaults.touched && _defaults.registry.installedPlugins.size > 0) {
+    console.warn(
+      "[Plugin] Replacing default plugin registry while plugins are already installed on the singleton. This may indicate mixed singleton/registry usage."
+    );
+  }
+  _defaults.registry = registry;
+  _defaults.touched = true;
+}
+
+export {
+  PluginInstallCancelledError,
+  isPluginInstallCancelledError,
+  createPluginRegistry,
+  createPlugin,
+  plugin,
+  inject,
+  triggerPluginMount,
+  triggerPluginUnmount,
+  triggerPluginError,
+  resetPlugins,
+  setDefaultPluginRegistry
+};

package/dist/{chunk-36S2YPP4.js → chunk-JSXPZCET.js}

@@ -1,7 +1,7 @@
 import {
   SVG_NS,
   tagFactory
-} from "./chunk-PNIRUQ4C.js";
+} from "./chunk-VVWPJ543.js";
 
 // src/core/rendering/html.ts
 var html = tagFactory("html");

package/dist/chunk-NYNYSPK7.js

@@ -0,0 +1,318 @@
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/dev.ts
+var DEV = typeof __SIBU_DEV__ !== "undefined" ? !!__SIBU_DEV__ : typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
+  // safe default: off in browser, on in test/dev Node
+  typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+);
+function isDev() {
+  if (typeof globalThis.__SIBU_DEV__ !== "undefined") return !!globalThis.__SIBU_DEV__;
+  if (typeof __SIBU_DEV__ !== "undefined") return !!__SIBU_DEV__;
+  return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+}
+function devAssert(condition, message) {
+  if ((typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) && !condition) {
+    throw new Error(`[SibuJS] ${message}`);
+  }
+}
+function devWarnLazy(build) {
+  if (typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) {
+    const message = build();
+    if (message) console.warn(`[SibuJS] ${message}`);
+  }
+}
+function devWarn(message) {
+  if (typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) {
+    console.warn(`[SibuJS] ${message}`);
+  }
+}
+
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g = globalThis;
+  const existing = g[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g[ERROR_STATE_KEY] = created;
+  return created;
+}
+function setRuntimeErrorHandler(handler) {
+  const s = state();
+  const prev = s.handler;
+  s.handler = handler;
+  return prev;
+}
+function getRuntimeErrorHandler() {
+  return state().handler;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context) {
+  const raw = context.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self = node;
+  return typeof self.dispatchEvent === "function" ? self : null;
+}
+function defaultReport(error, context) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
+}
+function reportError(error, context) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context)) return;
+    const s = state();
+    const handler = s.handler;
+    if (handler && s.handlerDepth === 0) {
+      s.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s.handlerDepth--;
+      }
+    }
+    defaultReport(err, context);
+  });
+}
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var MAX_DRAIN_TEARDOWNS = 1e4;
+function reportDrainRunaway(label, executed, remaining) {
+  if (typeof console === "undefined") return;
+  console.error(
+    `[SibuJS ${label}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
+    { executed, remaining }
+  );
+}
+var activeBindingCount = 0;
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  if (DEV) activeBindingCount++;
+  const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (capture) capture.entries.push([node, teardown]);
+}
+function withDisposerRollback(build) {
+  const frame = { entries: [], closed: false };
+  const captured = frame.entries;
+  registrationCaptures.push(frame);
+  let result;
+  try {
+    result = build();
+  } catch (err) {
+    let executed = 0;
+    try {
+      while (captured.length > 0) {
+        if (executed >= MAX_DRAIN_TEARDOWNS) {
+          reportDrainRunaway("rollback", executed, captured.length);
+          break;
+        }
+        const [node, teardown] = captured.pop();
+        if (!unregisterDisposer(node, teardown)) continue;
+        executed++;
+        try {
+          teardown();
+        } catch (cleanupErr) {
+          reportError(cleanupErr, { phase: "cleanup", name: "disposer" });
+        }
+      }
+    } finally {
+      frame.closed = true;
+      captured.length = 0;
+      registrationCaptures.pop();
+    }
+    throw err;
+  }
+  frame.closed = true;
+  registrationCaptures.pop();
+  const parent = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (parent) {
+    for (const entry of captured) {
+      if (elementDisposers.get(entry[0])?.includes(entry[1])) parent.entries.push(entry);
+    }
+    frame.forwardTo = parent;
+  }
+  captured.length = 0;
+  return result;
+}
+function unregisterDisposer(node, teardown) {
+  const disposers = elementDisposers.get(node);
+  if (!disposers) return false;
+  const index = disposers.indexOf(teardown);
+  if (index === -1) return false;
+  disposers.splice(index, 1);
+  if (DEV) activeBindingCount--;
+  if (disposers.length === 0) elementDisposers.delete(node);
+  return true;
+}
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i = 0; i < children.length; i++) {
+      stack.push(children[i]);
+    }
+  }
+  for (let i = order.length - 1; i >= 0; i--) {
+    disposeNodeOwn(order[i]);
+  }
+}
+function disposeNodeOwn(node) {
+  if (!elementDisposers.has(node)) return;
+  let executed = 0;
+  let runaway = false;
+  while (!runaway) {
+    const pending = elementDisposers.get(node);
+    if (!pending || pending.length === 0) break;
+    const snapshot = pending.slice();
+    elementDisposers.delete(node);
+    if (DEV) activeBindingCount -= snapshot.length;
+    for (let i = 0; i < snapshot.length; i++) {
+      if (executed >= MAX_DRAIN_TEARDOWNS) {
+        const rest = snapshot.slice(i);
+        const added = elementDisposers.get(node);
+        elementDisposers.set(node, added ? rest.concat(added) : rest);
+        if (DEV) activeBindingCount += rest.length;
+        reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+        runaway = true;
+        break;
+      }
+      executed++;
+      try {
+        snapshot[i]();
+      } catch (err) {
+        reportError(err, { phase: "cleanup", name: "disposer" });
+      }
+    }
+  }
+}
+function replaceChildrenSafely(parent, ...next) {
+  for (let i = 0; i < next.length; i++) {
+    const node = next[i];
+    node.parentNode?.removeChild(node);
+  }
+  const current = Array.from(parent.childNodes);
+  for (let i = 0; i < current.length; i++) {
+    dispose(current[i]);
+  }
+  parent.replaceChildren(...next);
+}
+function checkLeaks(warnThreshold = 0) {
+  if (!DEV) return 0;
+  if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
+    devWarn(
+      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
+    );
+  }
+  return activeBindingCount;
+}
+
+export {
+  __require,
+  __export,
+  DEV,
+  isDev,
+  devAssert,
+  devWarnLazy,
+  devWarn,
+  setRuntimeErrorHandler,
+  getRuntimeErrorHandler,
+  normalizeError,
+  reportError,
+  MAX_DRAIN_TEARDOWNS,
+  reportDrainRunaway,
+  currentDisposerCapture,
+  beginDisposerCapture,
+  endDisposerCapture,
+  registerDisposer,
+  withDisposerRollback,
+  unregisterDisposer,
+  dispose,
+  disposeNodeOwn,
+  replaceChildrenSafely,
+  checkLeaks
+};