sibujs 4.4.0 → 4.6.0

package/dist/{chunk-M2F7TZHH.js → chunk-DKGBBKOF.js}

@@ -1,24 +1,23 @@
 import {
   sanitizeUrl
-} from "./chunk-IXKSNWV5.js";
+} from "./chunk-2INLLLMZ.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-7GIHSAWB.js";
-import {
-  dispose,
-  replaceChildrenSafely
-} from "./chunk-QKRPLZ2V.js";
+} from "./chunk-XC4MEKGA.js";
 import {
   signal
-} from "./chunk-NVNJH22U.js";
+} from "./chunk-D33YTSX5.js";
 import {
   DEV,
   devWarn,
+  dispose,
+  registerDisposer,
+  replaceChildrenSafely,
   reportError
-} from "./chunk-2WLZ6757.js";
+} from "./chunk-NYNYSPK7.js";
 
 // src/performance/scheduler.ts
 var Priority = {
@@ -44,28 +43,34 @@ function insertTask(task) {
   }
   taskQueue.splice(i, 0, task);
 }
+function runTask(callback) {
+  try {
+    callback();
+  } catch (err) {
+    reportError(err, { phase: "scheduler", name: "scheduleUpdate" });
+  }
+}
 function processQueue() {
   if (_sched.isProcessing || taskQueue.length === 0) return;
   _sched.isProcessing = true;
   const startTime = performance.now();
   const timeSlice = 5;
-  while (taskQueue.length > 0) {
-    const task = taskQueue[0];
-    if (task.cancelled) {
+  try {
+    while (taskQueue.length > 0) {
+      const task = taskQueue[0];
+      if (task.cancelled) {
+        taskQueue.shift();
+        continue;
+      }
+      if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
+        break;
+      }
       taskQueue.shift();
-      continue;
-    }
-    if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
-      break;
-    }
-    taskQueue.shift();
-    try {
-      task.callback();
-    } catch (e) {
-      console.error("[Scheduler] Task error:", e);
+      runTask(task.callback);
     }
+  } finally {
+    _sched.isProcessing = false;
   }
-  _sched.isProcessing = false;
   if (taskQueue.length > 0) {
     scheduleFrame();
   }
@@ -133,11 +138,7 @@ function scheduleUpdate(priority, callback) {
     cancelled: false
   };
   if (priority === Priority.IMMEDIATE) {
-    try {
-      callback();
-    } catch (e) {
-      console.error("[Scheduler] Immediate task error:", e);
-    }
+    runTask(callback);
     return () => {
     };
   }
@@ -157,14 +158,15 @@ function flushScheduler() {
   _sched.scheduledHandle = null;
   _sched.scheduledKind = null;
   _sched.microtaskScheduled = false;
-  while (taskQueue.length > 0) {
-    const task = taskQueue.shift();
-    if (!task) break;
-    if (!task.cancelled) {
-      task.callback();
+  try {
+    while (taskQueue.length > 0) {
+      const task = taskQueue.shift();
+      if (!task) break;
+      if (!task.cancelled) runTask(task.callback);
     }
+  } finally {
+    _sched.isProcessing = false;
   }
-  _sched.isProcessing = false;
 }
 function pendingTasks() {
   return taskQueue.filter((t) => !t.cancelled).length;
@@ -300,11 +302,16 @@ function getDOMPool() {
   return _defaultPool;
 }
 var preloadedResources = /* @__PURE__ */ new Set();
+function hintKey(rel, as, crossorigin, href) {
+  return `${rel}\0${as}\0${crossorigin}\0${href}`;
+}
 function preloadResource(url, type = "fetch") {
   const safe = sanitizeUrl(url);
   if (!safe) return;
-  if (preloadedResources.has(safe)) return;
-  preloadedResources.add(safe);
+  const as = type === "script" || type === "style" || type === "image" ? type : "fetch";
+  const key = hintKey("preload", as, as === "fetch" ? "anonymous" : "", safe);
+  if (preloadedResources.has(key)) return;
+  preloadedResources.add(key);
   const link = document.createElement("link");
   link.rel = "preload";
   link.href = safe;
@@ -327,8 +334,9 @@ function preloadResource(url, type = "fetch") {
 function prefetch(url) {
   const safe = sanitizeUrl(url);
   if (!safe) return;
-  if (preloadedResources.has(safe)) return;
-  preloadedResources.add(safe);
+  const key = hintKey("prefetch", "", "", safe);
+  if (preloadedResources.has(key)) return;
+  preloadedResources.add(key);
   const link = document.createElement("link");
   link.rel = "prefetch";
   link.href = safe;
@@ -391,65 +399,92 @@ function block(factory) {
 }
 
 // src/performance/normalize.ts
+function dict(source) {
+  const out = /* @__PURE__ */ Object.create(null);
+  if (source) {
+    for (const key of Object.keys(source)) defineOwn(out, key, source[key]);
+  }
+  return out;
+}
+function ownGet(obj, key) {
+  return obj !== void 0 && Object.hasOwn(obj, key) ? obj[key] : void 0;
+}
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function readEntityId(entity, idKey, typeName) {
+  const raw = entity !== null && typeof entity === "object" && Object.hasOwn(entity, idKey) ? entity[idKey] : void 0;
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  throw new TypeError(
+    `[normalize] "${typeName}" entity has no valid "${idKey}" (expected a string or finite number, got ${raw === null ? "null" : typeof raw})`
+  );
+}
 function normalizedStore(schema) {
   const idKey = schema.idKey || "id";
   const [getState, setState] = signal({
     ids: [],
-    entities: {}
+    entities: dict()
   });
-  const idOf = (entity) => String(entity[idKey]);
+  const idOf = (entity) => readEntityId(entity, idKey, schema.name);
   function add(entity) {
     const id = idOf(entity);
     setState((prev) => {
-      const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
-      return {
-        ids,
-        entities: { ...prev.entities, [id]: entity }
-      };
+      const ids = Object.hasOwn(prev.entities, id) ? prev.ids : [...prev.ids, id];
+      const entities = dict(prev.entities);
+      defineOwn(entities, id, entity);
+      return { ids, entities };
     });
   }
   function addMany(entities) {
+    const ids = entities.map(idOf);
     setState((prev) => {
       const nextIds = [...prev.ids];
-      const nextEntities = { ...prev.entities };
-      for (const entity of entities) {
-        const id = idOf(entity);
-        if (!nextIds.includes(id)) {
+      const nextEntities = dict(prev.entities);
+      entities.forEach((entity, i) => {
+        const id = ids[i];
+        if (!Object.hasOwn(nextEntities, id)) {
           nextIds.push(id);
         }
-        nextEntities[id] = entity;
-      }
+        defineOwn(nextEntities, id, entity);
+      });
       return { ids: nextIds, entities: nextEntities };
     });
   }
   function get(id) {
-    const state = getState();
-    return state.entities[id];
+    return ownGet(getState().entities, id);
   }
   function getAll() {
     const state = getState();
     return state.ids.map((id) => state.entities[id]);
   }
   function update(id, partial) {
-    setState((prev) => {
-      const existing = prev.entities[id];
-      if (!existing) return prev;
-      return {
-        ids: prev.ids,
-        entities: {
-          ...prev.entities,
-          [id]: { ...existing, ...partial }
-        }
-      };
+    const prev = getState();
+    if (!Object.hasOwn(prev.entities, id)) return;
+    if (partial !== null && typeof partial === "object" && Object.hasOwn(partial, idKey)) {
+      const nextId = readEntityId(partial, idKey, schema.name);
+      if (nextId !== id) {
+        throw new Error(
+          `[normalizedStore] update("${id}") cannot change "${idKey}" to "${nextId}"; remove and re-add the entity instead.`
+        );
+      }
+    }
+    setState((current) => {
+      const existing = ownGet(current.entities, id);
+      if (!existing) return current;
+      const entities = dict(current.entities);
+      defineOwn(entities, id, { ...existing, ...partial });
+      return { ids: current.ids, entities };
     });
   }
   function remove(id) {
     setState((prev) => {
-      if (!prev.entities[id]) return prev;
-      const { [id]: _, ...remainingEntities } = prev.entities;
+      if (!Object.hasOwn(prev.entities, id)) return prev;
+      const entities = dict(prev.entities);
+      delete entities[id];
       return {
         ids: prev.ids.filter((existingId) => existingId !== id),
-        entities: remainingEntities
+        entities
       };
     });
   }
@@ -460,31 +495,37 @@ function normalizedStore(schema) {
   return { add, addMany, get, getAll, update, remove, select, getState };
 }
 function normalize(data, schema) {
-  const entities = {};
+  const entities = dict();
   function ensureTable(name) {
-    if (!entities[name]) {
-      entities[name] = {};
+    let table = ownGet(entities, name);
+    if (!table) {
+      table = dict();
+      defineOwn(entities, name, table);
     }
-    return entities[name];
+    return table;
   }
   function normalizeEntity(entity, entitySchema) {
     const entityIdKey = entitySchema.idKey || "id";
-    const id = String(entity[entityIdKey]);
+    const id = readEntityId(entity, entityIdKey, entitySchema.name);
     const table = ensureTable(entitySchema.name);
     const flat = { ...entity };
     if (entitySchema.relations) {
       for (const [field, relationType] of Object.entries(entitySchema.relations)) {
-        const value = entity[field];
+        const value = Object.hasOwn(entity, field) ? entity[field] : void 0;
         if (value == null) continue;
         const relSchema = { name: relationType };
         if (Array.isArray(value)) {
-          flat[field] = value.map((item) => normalizeEntity(item, relSchema));
+          defineOwn(
+            flat,
+            field,
+            value.map((item) => normalizeEntity(item, relSchema))
+          );
         } else if (typeof value === "object") {
-          flat[field] = normalizeEntity(value, relSchema);
+          defineOwn(flat, field, normalizeEntity(value, relSchema));
         }
       }
     }
-    table[id] = flat;
+    defineOwn(table, id, flat);
     return id;
   }
   if (Array.isArray(data)) {
@@ -495,20 +536,24 @@ function normalize(data, schema) {
   return { result, entities };
 }
 function denormalize(id, entities, schema) {
-  const table = entities[schema.name];
+  const table = ownGet(entities, schema.name);
   if (!table) return void 0;
-  const entity = table[id];
+  const entity = ownGet(table, id);
   if (!entity) return void 0;
   const result = { ...entity };
   if (schema.relations) {
     for (const [field, relationType] of Object.entries(schema.relations)) {
-      const value = entity[field];
+      const value = ownGet(entity, field);
       if (value == null) continue;
       const relSchema = { name: relationType };
       if (Array.isArray(value)) {
-        result[field] = value.map((relId) => denormalize(relId, entities, relSchema));
+        defineOwn(
+          result,
+          field,
+          value.map((relId) => denormalize(relId, entities, relSchema))
+        );
       } else if (typeof value === "string") {
-        result[field] = denormalize(value, entities, relSchema);
+        defineOwn(result, field, denormalize(value, entities, relSchema));
       }
     }
   }
@@ -718,13 +763,24 @@ function lazyChunk(id, loader, registry, fallback) {
     if (fallback) {
       container.appendChild(fallback());
     }
+    let disposed = false;
+    registerDisposer(container, () => {
+      disposed = true;
+    });
     registry.load(id, async () => {
       const mod = await loader();
       return typeof mod === "function" ? mod : mod.default;
     }).then((component) => {
+      if (disposed) return;
+      const node = component();
+      if (disposed) {
+        dispose(node);
+        return;
+      }
       clearChildren(container);
-      container.appendChild(component());
+      container.appendChild(node);
     }).catch((err) => {
+      if (disposed) return;
       clearChildren(container);
       const errorEl = document.createElement("div");
       errorEl.textContent = `Failed to load chunk '${id}': ${err.message}`;

package/dist/{chunk-NIOYEGBQ.js → chunk-HURREPU2.js}

@@ -6,17 +6,15 @@ import {
   sanitizeAttributeString,
   sanitizeUrl,
   stripControlChars
-} from "./chunk-IXKSNWV5.js";
+} from "./chunk-2INLLLMZ.js";
 import {
   getSSRStore
-} from "./chunk-5DXA2J44.js";
+} from "./chunk-7XHATCIH.js";
 import {
+  DEV,
   dispose,
   replaceChildrenSafely
-} from "./chunk-QKRPLZ2V.js";
-import {
-  DEV
-} from "./chunk-2WLZ6757.js";
+} from "./chunk-NYNYSPK7.js";
 
 // src/utils/metaRefresh.ts
 function isAsciiWhitespace(ch) {
@@ -446,7 +444,7 @@ function renderToDocument(component, options = {}) {
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${options.title ? `<title>${escapeHtml(options.title)}</title>` : ""}
+    ${options.title != null ? `<title>${escapeHtml(options.title)}</title>` : ""}
     ${metaTags}
     ${linkTags}
     ${options.headExtra || ""}
@@ -621,16 +619,32 @@ function ssrSuspense(props) {
   const timeoutPromise = new Promise((_, reject) => {
     timer = setTimeout(() => reject(new Error(`[SibuJS SSR] ssrSuspense timed out after ${timeoutMs}ms`)), timeoutMs);
   });
-  const raced = Promise.race([props.content(), timeoutPromise]);
+  let contentPromise;
+  try {
+    contentPromise = Promise.resolve(props.content());
+  } catch (err) {
+    contentPromise = Promise.reject(err);
+  }
+  const toFallback = (err) => {
+    if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
+    return { id, html: fallbackHtml };
+  };
+  const clearTimer = () => {
+    if (timer !== void 0) clearTimeout(timer);
+  };
+  const raced = Promise.race([contentPromise, timeoutPromise]);
   const promise = raced.then(
     (resolvedEl) => {
-      if (timer) clearTimeout(timer);
-      return { id, html: renderToString(resolvedEl) };
+      clearTimer();
+      try {
+        return { id, html: renderToString(resolvedEl) };
+      } catch (err) {
+        return toFallback(err);
+      }
     },
     (err) => {
-      if (timer) clearTimeout(timer);
-      if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
-      return { id, html: fallbackHtml };
+      clearTimer();
+      return toFallback(err);
     }
   );
   promise.catch(noop);