sibujs 4.13.0 → 4.14.0

package/dist/{chunk-ENFRHCMK.js → chunk-F67F77IA.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-5HZXGZ6T.js";
 import {
   signal
-} from "./chunk-GNSRXK34.js";
+} from "./chunk-4FJSAUKB.js";
 import {
   registerDisposer,
   reportError
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
 
 // src/ui/transition.ts
 function transition(element, options = {}) {

package/dist/{chunk-TUCPL2HB.js → chunk-GIJ33UJZ.js}

@@ -1,7 +1,7 @@
 import {
   DEV,
   devWarn
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-NT3ZYB5S.js";
 
 // src/patterns/hoc.ts
 function withWrapper(WrappedComponent, wrapper) {

package/dist/chunk-GVAMIU6K.js

@@ -0,0 +1,195 @@
+import {
+  Route,
+  createRouter,
+  route
+} from "./chunk-VM2U5LEL.js";
+import {
+  DEFAULT_SETTLE_TIMEOUT,
+  assembleDocument,
+  collectServerHead,
+  renderToStringAsync
+} from "./chunk-BOYKGGVD.js";
+import {
+  assertRequestIsolation,
+  getRequestStore,
+  runInSSRContext
+} from "./chunk-UYTYNCMZ.js";
+import {
+  DEV
+} from "./chunk-NT3ZYB5S.js";
+
+// src/platform/renderRoute.ts
+function deepest(matched, key) {
+  for (let i = matched.length - 1; i >= 0; i--) {
+    const value = matched[i][key];
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function encodeUrlPart(part) {
+  return part.replace(/%(?![0-9A-Fa-f]{2})|[^A-Za-z0-9\-._~!$&'()*+,;=:@/?%]/gu, (c) => {
+    try {
+      return encodeURIComponent(c);
+    } catch {
+      return "%EF%BF%BD";
+    }
+  });
+}
+function before(work, deadline) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), Math.max(0, deadline - Date.now()));
+    const done = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    work.then(done, done);
+  });
+}
+function emptyDiagnostics() {
+  return {
+    timedOut: false,
+    pending: [],
+    browserApis: [],
+    stateBytes: 0,
+    largestState: [],
+    droppedState: [],
+    durationMs: 0
+  };
+}
+function renderRoute(routes, url, options = {}) {
+  try {
+    assertRequestIsolation("renderRoute()");
+  } catch (err) {
+    return Promise.reject(err);
+  }
+  return runInSSRContext(async () => {
+    const started = Date.now();
+    const deadline = started + (options.timeout ?? DEFAULT_SETTLE_TIMEOUT);
+    const router = createRouter(routes, { ...options.router, mode: "memory", url });
+    const wrap = (body, headHtml, state) => options.document ? assembleDocument(body, options.document, headHtml, state) : body;
+    const timedOut = (phase) => {
+      const now = Date.now();
+      const pending = [
+        `${phase} (${now - started} ms)`,
+        ...Array.from(getRequestStore()?.pending ?? [], (work) => `${work.label} (${now - work.since} ms)`)
+      ];
+      const diagnostics = { ...emptyDiagnostics(), timedOut: true, pending, durationMs: now - started };
+      if (DEV) {
+        console.warn(
+          `[SibuJS SSR] ${url}: the route did not render within ${options.timeout ?? DEFAULT_SETTLE_TIMEOUT} ms; pending: ${pending.join(", ")}`
+        );
+      }
+      return {
+        html: wrap("", "", ""),
+        head: "",
+        state: "",
+        stateData: null,
+        status: 503,
+        location: null,
+        route: null,
+        render: "default",
+        noindex: false,
+        failure: "timeout",
+        redirectBy: null,
+        diagnostics
+      };
+    };
+    try {
+      if (!await before(router.whenNavigated(), deadline)) return timedOut("route:navigation");
+      const { result, redirectStatus, redirectBy } = router.initialOutcome;
+      const committed = route();
+      const matched = committed.matched;
+      const base = options.router?.base ?? "";
+      const head = () => collectServerHead();
+      if (result && !result.success) {
+        const reason = result.reason ?? "error";
+        const status2 = reason === "guard" ? options.rejectStatus ?? 403 : 500;
+        const headHtml = head();
+        return {
+          html: wrap("", headHtml, ""),
+          head: headHtml,
+          state: "",
+          stateData: null,
+          status: status2,
+          location: null,
+          route: null,
+          render: "default",
+          noindex: false,
+          failure: reason,
+          redirectBy: null,
+          diagnostics: { ...emptyDiagnostics(), durationMs: Date.now() - started }
+        };
+      }
+      const search = new URLSearchParams();
+      for (const [key, values] of Object.entries(committed.queryAll)) for (const v of values) search.append(key, v);
+      const locationPath = encodeUrlPart(committed.path) + (search.size > 0 ? `?${search}` : "") + (committed.hash ? `#${encodeUrlPart(committed.hash)}` : "");
+      const routeInfo = {
+        path: committed.path,
+        params: { ...committed.params },
+        query: { ...committed.query },
+        hash: committed.hash,
+        name: matched.length > 0 ? matched[matched.length - 1].name ?? null : null
+      };
+      const headHtml0 = head();
+      const noindex = /<meta name="robots" content="[^"]*noindex/i.test(headHtml0);
+      if (redirectStatus !== null) {
+        return {
+          html: "",
+          head: headHtml0,
+          state: "",
+          stateData: null,
+          status: redirectStatus,
+          location: encodeUrlPart(base) + locationPath,
+          route: routeInfo,
+          render: "default",
+          noindex,
+          failure: null,
+          redirectBy,
+          diagnostics: { ...emptyDiagnostics(), durationMs: Date.now() - started }
+        };
+      }
+      const leaf = matched[matched.length - 1];
+      const status = deepest(matched, "status") ?? (!leaf || leaf.path === "*" ? 404 : 200);
+      const render = deepest(matched, "render") ?? "default";
+      if (render === "client" || options.headOnly?.includes(render)) {
+        return {
+          html: wrap("", headHtml0, ""),
+          head: headHtml0,
+          state: "",
+          stateData: null,
+          status,
+          location: null,
+          route: routeInfo,
+          render,
+          noindex,
+          failure: null,
+          redirectBy: null,
+          diagnostics: { ...emptyDiagnostics(), durationMs: Date.now() - started }
+        };
+      }
+      if (!await before(router.whenReady(), deadline)) return timedOut("route:components");
+      const rendered = await renderToStringAsync(options.app ?? (() => Route()), {
+        ...options,
+        timeout: Math.max(0, deadline - Date.now()),
+        log: options.log === true ? url : options.log
+      });
+      return {
+        ...rendered,
+        html: wrap(rendered.html, rendered.head, rendered.state),
+        status,
+        location: null,
+        route: routeInfo,
+        render,
+        noindex: /<meta name="robots" content="[^"]*noindex/i.test(rendered.head),
+        failure: null,
+        redirectBy: null
+      };
+    } finally {
+      router.destroy();
+    }
+  });
+}
+
+export {
+  renderRoute
+};

package/dist/{chunk-HDKDBC6V.js → chunk-HQIAL7F2.js}

@@ -2,21 +2,23 @@ import {
   ContextualRefusal,
   contextualAttributeRefusal,
   settleAttributeProvenance
-} from "./chunk-F2UWOZ6J.js";
+} from "./chunk-RVWJGWCL.js";
 import {
   isEventHandlerAttr,
   isHtmlContentAttribute,
   resolveAttributeValue
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
   reactiveBinding
-} from "./chunk-HVVRXRGO.js";
+} from "./chunk-MIRKTVH4.js";
+import {
+  reportError
+} from "./chunk-S37PZD6I.js";
 import {
   DEV,
   devWarn,
-  devWarnLazy,
-  reportError
-} from "./chunk-NYNYSPK7.js";
+  devWarnLazy
+} from "./chunk-NT3ZYB5S.js";
 
 // src/utils/setSafeAttribute.ts
 var HTML_NS = "http://www.w3.org/1999/xhtml";

package/dist/{chunk-ZE5LF44R.js → chunk-JTFQ7IL4.js}

@@ -3,34 +3,34 @@ import {
 } from "./chunk-N5TBYXHW.js";
 import {
   domBinding
-} from "./chunk-G6366I2A.js";
+} from "./chunk-CCKUNHVU.js";
 import {
   bindAttribute,
   setSafeAttribute
-} from "./chunk-HDKDBC6V.js";
+} from "./chunk-HQIAL7F2.js";
 import {
   isBlockedElement
-} from "./chunk-F2UWOZ6J.js";
+} from "./chunk-RVWJGWCL.js";
 import {
   derived
-} from "./chunk-YJ57VR6Y.js";
+} from "./chunk-N7A6FKWW.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   isEventHandlerAttr,
   sanitizeStylesheetText
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
   adoptThenable
 } from "./chunk-5HZXGZ6T.js";
 import {
   signal
-} from "./chunk-GNSRXK34.js";
+} from "./chunk-4FJSAUKB.js";
 import {
   reactiveBinding,
   track
-} from "./chunk-HVVRXRGO.js";
+} from "./chunk-MIRKTVH4.js";
 import {
   dispose,
   disposeNodeOwn,
@@ -39,7 +39,7 @@ import {
   reportError,
   unregisterDisposer,
   withDisposerRollback
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
 
 // src/ui/form.ts
 function required(message = "This field is required") {

package/dist/{chunk-AM6DZLBM.js → chunk-LJMX4SQ7.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-7ZHH77QA.js";
 import {
   sanitizeUrl
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
   getRequestStore
-} from "./chunk-7XHATCIH.js";
+} from "./chunk-UYTYNCMZ.js";
 
 // src/utils/embedPolicy.ts
 var state = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.embed.v2"), () => ({

package/dist/{chunk-HVVRXRGO.js → chunk-MIRKTVH4.js}

@@ -1,11 +1,13 @@
 import {
-  DEV,
   beginDisposerCapture,
   currentDisposerCapture,
-  devWarn,
   endDisposerCapture,
   reportError
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
+import {
+  DEV,
+  devWarn
+} from "./chunk-NT3ZYB5S.js";
 
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
@@ -575,7 +577,7 @@ function forEachSubscriber(signal, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.13.0" : "dev";
+var _runtimeVersion = true ? "4.14.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -639,14 +641,6 @@ var runWithOwnerScope2 = API.runWithOwnerScope ?? runWithOwnerScope;
 var bindOwnerScope2 = API.bindOwnerScope ?? bindOwnerScope;
 var structuralBinding2 = API.structuralBinding ?? ((commit, ownerNode) => ({ stop: API.reactiveBinding(commit, ownerNode), run: (fn) => fn() }));
 
-// src/core/devtoolsHook.ts
-function emitDevtools(hook, event, payload) {
-  try {
-    hook.emit(event, payload);
-  } catch {
-  }
-}
-
 export {
   suspendTracking2 as suspendTracking,
   resumeTracking2 as resumeTracking,
@@ -667,6 +661,5 @@ export {
   getOwnerScope2 as getOwnerScope,
   runWithOwnerScope2 as runWithOwnerScope,
   bindOwnerScope2 as bindOwnerScope,
-  structuralBinding2 as structuralBinding,
-  emitDevtools
+  structuralBinding2 as structuralBinding
 };

package/dist/{chunk-YJ57VR6Y.js → chunk-N7A6FKWW.js}

@@ -1,14 +1,16 @@
+import {
+  emitDevtools
+} from "./chunk-4FJSAUKB.js";
 import {
   cleanup,
-  emitDevtools,
   isTrackingSuspended,
   recordDependency,
   retrack,
   track
-} from "./chunk-HVVRXRGO.js";
+} from "./chunk-MIRKTVH4.js";
 import {
   devAssert
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-NT3ZYB5S.js";
 
 // src/core/signals/derived.ts
 function derived(getter, options) {

package/dist/chunk-NT3ZYB5S.js

@@ -0,0 +1,167 @@
+// 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/rendering/adoptScope.ts
+var current = null;
+function inAdoptScope() {
+  return current?.s.on === true;
+}
+function currentSink() {
+  return current?.s.on ? current.s : null;
+}
+function createScopedElement(tag, ns) {
+  const c = current;
+  if (c?.s.on) {
+    const el = c.s.el(tag, ns, c.p + (c.n++).toString(36));
+    if (el) return el;
+  }
+  return ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+}
+function captureScope() {
+  const c = current;
+  return c?.s.on ? { p: `${c.p}${(c.n++).toString(36)}.`, n: 0, s: c.s } : null;
+}
+function keyedScope(scope, key) {
+  if (!scope?.s.on) return null;
+  const type = typeof key;
+  if (type !== "string" && type !== "number") {
+    throw new TypeError(`[SibuJS] adopt: a key must be a string or a number, not ${type}`);
+  }
+  const text = String(key).replace(/[^\w-]/g, (c) => `~${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  return { p: `${scope.p}${type === "string" ? "_" : "-"}${text}.`, n: 0, s: scope.s };
+}
+function inScope(scope, fn) {
+  const prev = current;
+  if (!scope && !prev) return fn();
+  current = scope?.s.on ? { p: scope.p, n: 0, s: scope.s } : null;
+  try {
+    return fn();
+  } finally {
+    current = prev;
+  }
+}
+
+// src/core/rendering/hydrationHooks.ts
+var _a;
+var slot = globalThis[_a = /* @__PURE__ */ Symbol.for("sibujs.hydration.v2")] ?? (globalThis[_a] = { a: /* @__PURE__ */ new Set(), c: null });
+function isHydrating() {
+  return slot.a.size > 0;
+}
+function ownSession() {
+  return currentSink()?.h ?? slot.c;
+}
+function hydrationOwners() {
+  const own = ownSession();
+  return own ? own.open ? [own] : [] : Array.from(slot.a);
+}
+function afterHydration(fn) {
+  const owners = hydrationOwners();
+  let left = owners.length;
+  const once = () => {
+    if (--left < 1) fn();
+  };
+  if (left) for (const s of owners) s.done.push(once);
+  else fn();
+}
+function notify(session) {
+  for (const wake of Array.from(session.wake)) wake();
+}
+function holdHydration(sessions, entry) {
+  for (const s of sessions) s.pending.add(entry);
+  return () => {
+    for (const s of sessions) if (s.pending.delete(entry)) notify(s);
+  };
+}
+function inHydration(session, fn) {
+  const prev = slot.c;
+  slot.c = session;
+  try {
+    return fn();
+  } finally {
+    slot.c = prev;
+  }
+}
+function beginHydration() {
+  const own = ownSession();
+  const session = {
+    done: [],
+    pending: /* @__PURE__ */ new Set(),
+    wake: /* @__PURE__ */ new Set(),
+    up: own?.open ? own : null,
+    open: true,
+    end() {
+      if (!session.open) return;
+      session.open = false;
+      slot.a.delete(session);
+      session.pending.clear();
+      notify(session);
+      const up = session.up;
+      session.up = null;
+      const callbacks = session.done.splice(0);
+      if (up?.open) {
+        up.done.push(...callbacks);
+        if (up.pending.delete(session)) notify(up);
+        return;
+      }
+      let failed = false;
+      let error;
+      inHydration(session, () => {
+        for (const fn of callbacks) {
+          try {
+            fn();
+          } catch (err) {
+            if (!failed) error = err;
+            failed = true;
+          }
+        }
+      });
+      if (failed) throw error;
+    }
+  };
+  if (session.up) session.up.pending.add(session);
+  slot.a.add(session);
+  return session;
+}
+
+export {
+  DEV,
+  isDev,
+  devAssert,
+  devWarnLazy,
+  devWarn,
+  inAdoptScope,
+  createScopedElement,
+  captureScope,
+  keyedScope,
+  inScope,
+  isHydrating,
+  hydrationOwners,
+  afterHydration,
+  holdHydration,
+  inHydration,
+  beginHydration
+};