sibujs 4.13.1 → 4.14.1

package/dist/chunk-3HZOSMPX.js

@@ -0,0 +1,90 @@
+import {
+  isUnsafeKey,
+  readOwnGlobal
+} from "./chunk-62BDYGAG.js";
+import {
+  getRequestStore
+} from "./chunk-UYTYNCMZ.js";
+
+// src/utils/transfer.ts
+var TRANSFER_GLOBAL = "__SIBU_TRANSFER__";
+var TRANSFER_VERSION = 1;
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.transfer.v1");
+function registry() {
+  const g = globalThis;
+  let r = g[REGISTRY_KEY];
+  if (!r) {
+    r = { collectors: /* @__PURE__ */ new Map(), payload: void 0 };
+    g[REGISTRY_KEY] = r;
+  }
+  return r;
+}
+function registerTransferCollector(section, collect) {
+  registry().collectors.set(section, collect);
+}
+function collectTransfer() {
+  if (!getRequestStore()) return null;
+  const out = {};
+  let any = false;
+  for (const [section, collect] of registry().collectors) {
+    const entries = collect();
+    if (!entries) continue;
+    const safe = {};
+    for (const key of Object.keys(entries)) if (!isUnsafeKey(key)) safe[key] = entries[key];
+    if (Object.keys(safe).length > 0) {
+      out[section] = safe;
+      any = true;
+    }
+  }
+  if (!any) return null;
+  out.v = TRANSFER_VERSION;
+  return out;
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function readPayload() {
+  const r = registry();
+  if (r.payload !== void 0) return r.payload;
+  r.payload = null;
+  if (typeof window === "undefined" || getRequestStore()) return null;
+  const raw = readOwnGlobal(TRANSFER_GLOBAL);
+  if (!isPlainRecord(raw) || raw.v !== TRANSFER_VERSION) return null;
+  const sections = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(raw)) {
+    const section = raw[key];
+    if (key === "v" || isUnsafeKey(key) || !isPlainRecord(section)) continue;
+    const entries = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(section)) if (!isUnsafeKey(k)) entries[k] = section[k];
+    sections[key] = entries;
+  }
+  r.payload = sections;
+  return sections;
+}
+function takeTransferred(section, key) {
+  const entries = readPayload()?.[section];
+  if (!entries || !Object.hasOwn(entries, key)) return void 0;
+  const value = entries[key];
+  delete entries[key];
+  return value;
+}
+function takeTransferredSection(section) {
+  const payload = readPayload();
+  const entries = payload?.[section];
+  if (!payload || !entries) return {};
+  delete payload[section];
+  return entries;
+}
+function __resetTransfer() {
+  registry().payload = void 0;
+}
+
+export {
+  registerTransferCollector,
+  collectTransfer,
+  takeTransferred,
+  takeTransferredSection,
+  __resetTransfer
+};

package/dist/{chunk-K4LNUT5L.js → chunk-3T7TWMSD.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-4UTGDVSA.js";
+} from "./chunk-LAHX7XFG.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-ADZHPN2B.js → chunk-4XCWNGRY.js}

@@ -1,14 +1,14 @@
 import {
   isSSR
-} from "./chunk-7XHATCIH.js";
+} from "./chunk-UYTYNCMZ.js";
 import {
   resumeTracking,
   suspendTracking,
   track
-} from "./chunk-4UTGDVSA.js";
+} from "./chunk-LAHX7XFG.js";
 import {
   devAssert
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-NT3ZYB5S.js";
 
 // src/core/signals/watch.ts
 function watch(getter, callback) {

package/dist/{chunk-2NC56RGY.js → chunk-55TAOW5M.js}

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

package/dist/{chunk-G3Z2FEBR.js → chunk-B2NLNZ3E.js}

@@ -1,28 +1,36 @@
+import {
+  registerTransferCollector,
+  takeTransferred,
+  takeTransferredSection
+} from "./chunk-3HZOSMPX.js";
 import {
   derived
-} from "./chunk-YFTBCCVH.js";
+} from "./chunk-ZYK4NZZA.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-QC3NP47A.js";
+} from "./chunk-FFXZ6ELZ.js";
 import {
   sanitizeUrl
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
-  getRequestScopedCache
-} from "./chunk-7XHATCIH.js";
+  getRequestScopedCache,
+  isSSR,
+  requestSlot,
+  trackPending
+} from "./chunk-UYTYNCMZ.js";
 import {
   batch,
   signal
-} from "./chunk-QKFVMIAV.js";
+} from "./chunk-FCWOMATN.js";
 import {
   untracked
-} from "./chunk-4UTGDVSA.js";
+} from "./chunk-LAHX7XFG.js";
 import {
   reportError
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
 
 // src/data/abort.ts
 function isAbortError(error) {
@@ -218,8 +226,34 @@ function sharedView(entry) {
 }
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
-  return getRequestScopedCache("query") ?? globalQueryCache;
+  const requestCache = getRequestScopedCache("query");
+  if (requestCache) return requestCache;
+  primeFromTransfer();
+  return globalQueryCache;
+}
+var SERVER_EFFECT = { server: true };
+function primeFromTransfer() {
+  const entries = takeTransferredSection("q");
+  const now = Date.now();
+  for (const key of Object.keys(entries)) {
+    const record = entries[key];
+    if (!record || typeof record !== "object" || record.d === void 0) continue;
+    if (globalQueryCache.has(key)) continue;
+    const entry = getOrCreateEntry(globalQueryCache, key, record.d);
+    const t = typeof record.t === "number" && Number.isFinite(record.t) ? record.t : now;
+    entry.dataUpdatedAt = Math.min(t, now);
+  }
 }
+registerTransferCollector("q", () => {
+  const cache = getRequestScopedCache("query");
+  if (!cache) return void 0;
+  const out = {};
+  for (const [key, entry] of cache) {
+    if (entry.noTransfer || entry.data === void 0 || entry.error) continue;
+    out[key] = { d: entry.data, t: entry.dataUpdatedAt };
+  }
+  return out;
+});
 function abandonEntry(entry) {
   if (entry.gcTimer) clearTimeout(entry.gcTimer);
   entry.gcTimer = null;
@@ -265,11 +299,13 @@ function query(key, fetcher, options = {}) {
     onError,
     onSettled,
     select,
-    structuralSharing = true
+    structuralSharing = true,
+    ssr = true
   } = options;
+  const onServer = isSSR();
   const resolveKey = typeof key === "function" ? key : () => key;
   const enabledGate = typeof enabled === "function" ? derived(() => Boolean(enabled())) : null;
-  const isEnabled = enabledGate ?? (() => Boolean(enabled));
+  const isEnabled = onServer && !ssr ? () => false : enabledGate ?? (() => Boolean(enabled));
   const cache = getActiveQueryCache();
   const [data, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
@@ -343,7 +379,7 @@ function query(key, fetcher, options = {}) {
     selectedEntry = entry;
     selectedValue = value;
     setData(value);
-  }) : null;
+  }, SERVER_EFFECT) : null;
   function detachFromEntry() {
     const entry = attachedEntry;
     const key2 = attachedKey;
@@ -426,7 +462,7 @@ function query(key, fetcher, options = {}) {
       runCallback("query onSettled", () => onSettled?.());
       return;
     }
-    entry.promise = promise;
+    entry.promise = trackPending(promise, `query:${key2}`, false);
     try {
       const result = await promise;
       if (entry.generation !== generation) return;
@@ -498,6 +534,7 @@ function query(key, fetcher, options = {}) {
       return;
     }
     const entry = getOrCreateEntry(cache, key2, initialData);
+    if (!ssr) entry.noTransfer = true;
     const reattached = attachedEntry !== entry;
     attachToEntry(entry, key2);
     if (keyChanged) setIsFetching(entry.promise !== null);
@@ -519,15 +556,15 @@ function query(key, fetcher, options = {}) {
     if (on && (entry.data === void 0 || isDataStale)) {
       doFetch();
     }
-  });
-  if (refetchInterval && refetchInterval > 0) {
+  }, SERVER_EFFECT);
+  if (!onServer && refetchInterval && refetchInterval > 0) {
     intervalTimer = setInterval(() => {
       if (!disposed && currentKey) doFetch();
     }, refetchInterval);
   }
   let focusHandler = null;
   let onlineHandler = null;
-  if (typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
+  if (!onServer && typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
     if (refetchOnWindowFocus) {
       focusHandler = () => {
         if (!disposed && currentKey) doFetch();
@@ -956,6 +993,28 @@ function throttle(getter, interval) {
 }
 
 // src/data/resource.ts
+function transferSlot() {
+  return requestSlot("resource:transfer", () => /* @__PURE__ */ new Map());
+}
+function withheldSlot() {
+  return requestSlot("resource:transfer:withheld", () => /* @__PURE__ */ new Set());
+}
+registerTransferCollector("r", () => {
+  const slot = transferSlot();
+  if (!slot || slot.size === 0) return void 0;
+  const withheld = withheldSlot();
+  const out = {};
+  let any = false;
+  for (const [key, value] of slot) {
+    if (withheld?.has(key)) continue;
+    out[key] = value;
+    any = true;
+  }
+  return any ? out : void 0;
+});
+function withholdTransfer(key) {
+  withheldSlot()?.add(key);
+}
 function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
   let source = null;
   let fetcher;
@@ -969,10 +1028,14 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     fetcher = (_source, info) => rawFetcher(info);
     options = fetcherOrOptions ?? {};
   }
-  const [data, setData] = signal(options.initialValue);
+  const transferred = options.key !== void 0 ? takeTransferred("r", options.key) : void 0;
+  const hydrated = transferred !== void 0;
+  const initialValue = hydrated ? transferred : options.initialValue;
+  const onServer = isSSR();
+  const [data, setData] = signal(initialValue);
   const [loading, setLoading] = signal(false);
   const [error, setError] = signal(void 0);
-  let currentData = options.initialValue;
+  let currentData = initialValue;
   function commitData(next, explicit) {
     const sharing = options.structuralSharing ?? true;
     const shared = untracked(
@@ -980,6 +1043,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     );
     currentData = shared.ok ? shared.value : next;
     setData(currentData);
+    if (onServer && options.key !== void 0) transferSlot()?.set(options.key, currentData);
     return currentData;
   }
   let abortController = null;
@@ -1025,19 +1089,28 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       }
     }
   }
+  const run = (sourceValue) => trackPending(doFetch(sourceValue), "resource", false);
   if (source) {
-    effectCleanup = effect(() => {
-      const sourceValue = source();
-      doFetch(sourceValue);
-    });
-  } else if (options.immediate !== false) {
-    doFetch(void 0);
+    let skipFirst = hydrated;
+    effectCleanup = effect(
+      () => {
+        const sourceValue = source();
+        if (skipFirst) {
+          skipFirst = false;
+          return;
+        }
+        run(sourceValue);
+      },
+      { server: true }
+    );
+  } else if (options.immediate !== false && !hydrated) {
+    run(void 0);
   }
   return {
     data,
     loading,
     error,
-    refetch: () => doFetch(source ? source() : void 0),
+    refetch: () => run(source ? source() : void 0),
     mutate: (value) => {
       const newValue = typeof value === "function" ? value(currentData) : value;
       commitData(newValue, true);
@@ -1338,8 +1411,27 @@ function currentScope() {
   }
   return scope;
 }
+function automaticKey(loader, context) {
+  const key = `loader:${context.path}${loader.name ? `:${loader.name}` : ""}`;
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return key;
+  let owners = cache.get("owners");
+  if (!owners) {
+    owners = /* @__PURE__ */ new Map();
+    cache.set("owners", owners);
+  }
+  const owner = owners.get(key);
+  if (owner === void 0) {
+    owners.set(key, loader);
+    return key;
+  }
+  if (owner === loader) return key;
+  withholdTransfer(key);
+  return void 0;
+}
 function executeLoader(loader, context, options) {
-  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const key = options?.key ?? automaticKey(loader, context);
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), { ...options, key });
   const disposeResource = res.dispose;
   res.dispose = () => {
     _disposed.add(res);
@@ -1667,6 +1759,7 @@ export {
   previous,
   debounce,
   throttle,
+  withholdTransfer,
   resource,
   offlineStore,
   syncAdapter,

package/dist/{chunk-EXXSN3BW.js → chunk-B3HOT4TK.js}

@@ -1,6 +1,6 @@
 import {
   devWarnLazy
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-NT3ZYB5S.js";
 
 // src/utils/sanitize.ts
 function stripControlChars(value) {

package/dist/{chunk-QKFVMIAV.js → chunk-FCWOMATN.js}

@@ -1,13 +1,12 @@
 import {
   drainNotificationQueue,
-  emitDevtools,
   notifySubscribers,
   queueSignalNotification,
   recordDependency
-} from "./chunk-4UTGDVSA.js";
+} from "./chunk-LAHX7XFG.js";
 import {
   DEV
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-NT3ZYB5S.js";
 
 // src/reactivity/batch.ts
 var batchDepth = 0;
@@ -59,6 +58,14 @@ var batch = API.batch;
 var enqueueBatchedSignal = API.enqueueBatchedSignal;
 var isBatching = API.isBatching;
 
+// src/core/devtoolsHook.ts
+function emitDevtools(hook, event, payload) {
+  try {
+    hook.emit(event, payload);
+  } catch {
+  }
+}
+
 // src/core/signals/signal.ts
 var _g = globalThis;
 function signal(initial, options) {
@@ -145,6 +152,7 @@ export {
   batch,
   enqueueBatchedSignal,
   isBatching,
+  emitDevtools,
   signal,
   external
 };

package/dist/{chunk-QC3NP47A.js → chunk-FFXZ6ELZ.js}

@@ -1,18 +1,22 @@
 import {
   isSSR
-} from "./chunk-7XHATCIH.js";
+} from "./chunk-UYTYNCMZ.js";
+import {
+  emitDevtools
+} from "./chunk-FCWOMATN.js";
 import {
   cleanup,
-  emitDevtools,
   getOwnerScope,
   retrack,
   runWithOwnerScope,
   untracked
-} from "./chunk-4UTGDVSA.js";
+} from "./chunk-LAHX7XFG.js";
 import {
-  devAssert,
   reportError
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
+import {
+  devAssert
+} from "./chunk-NT3ZYB5S.js";
 
 // src/core/signals/effect.ts
 var _g = globalThis;
@@ -94,7 +98,7 @@ function disposeEffect(ctx) {
 }
 function effect(effectFn, options) {
   devAssert(typeof effectFn === "function", "effect: argument must be a function.");
-  if (isSSR()) return () => {
+  if (isSSR() && !options?.server) return () => {
   };
   const ctx = {
     fn: effectFn,

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) {