sibujs 1.5.0 → 2.1.0

package/dist/{chunk-BMPL52BF.js → chunk-3DZP6OIT.js}

@@ -1,9 +1,13 @@
 import {
   effect
-} from "./chunk-VQNQZCWJ.js";
+} from "./chunk-WZA53FXU.js";
 import {
   signal
-} from "./chunk-NZIIMDWI.js";
+} from "./chunk-RDTDJCAB.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-LMLD24FC.js";
 
 // src/performance/scheduler.ts
 var Priority = {
@@ -16,7 +20,9 @@ var Priority = {
 var taskIdCounter = 0;
 var taskQueue = [];
 var isProcessing = false;
-var frameId = null;
+var scheduledKind = null;
+var scheduledHandle = null;
+var microtaskScheduled = false;
 function insertTask(task) {
   let i = taskQueue.length;
   while (i > 0 && taskQueue[i - 1].priority > task.priority) {
@@ -51,30 +57,38 @@ function processQueue() {
   }
 }
 function scheduleFrame() {
-  if (frameId !== null) return;
+  if (scheduledKind !== null || microtaskScheduled) return;
   const nextTask = taskQueue.find((t) => !t.cancelled);
   if (!nextTask) return;
   if (nextTask.priority <= Priority.USER_BLOCKING) {
+    microtaskScheduled = true;
+    scheduledKind = "microtask";
     queueMicrotask(() => {
-      frameId = null;
+      microtaskScheduled = false;
+      scheduledKind = null;
       processQueue();
     });
-    frameId = -1;
   } else if (nextTask.priority === Priority.IDLE) {
     if (typeof requestIdleCallback !== "undefined") {
-      frameId = requestIdleCallback(() => {
-        frameId = null;
+      scheduledKind = "idle";
+      scheduledHandle = requestIdleCallback(() => {
+        scheduledKind = null;
+        scheduledHandle = null;
         processQueue();
       });
     } else {
-      frameId = setTimeout(() => {
-        frameId = null;
+      scheduledKind = "timeout";
+      scheduledHandle = setTimeout(() => {
+        scheduledKind = null;
+        scheduledHandle = null;
         processQueue();
       }, 50);
     }
   } else {
-    frameId = requestAnimationFrame(() => {
-      frameId = null;
+    scheduledKind = "frame";
+    scheduledHandle = requestAnimationFrame(() => {
+      scheduledKind = null;
+      scheduledHandle = null;
       processQueue();
     });
   }
@@ -102,6 +116,15 @@ function scheduleUpdate(priority, callback) {
   };
 }
 function flushScheduler() {
+  if (scheduledHandle !== null) {
+    if (scheduledKind === "frame") cancelAnimationFrame(scheduledHandle);
+    else if (scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined") {
+      cancelIdleCallback(scheduledHandle);
+    } else if (scheduledKind === "timeout") clearTimeout(scheduledHandle);
+  }
+  scheduledHandle = null;
+  scheduledKind = null;
+  microtaskScheduled = false;
   while (taskQueue.length > 0) {
     const task = taskQueue.shift();
     if (!task) break;
@@ -110,7 +133,6 @@ function flushScheduler() {
     }
   }
   isProcessing = false;
-  frameId = null;
 }
 function pendingTasks() {
   return taskQueue.filter((t) => !t.cancelled).length;
@@ -172,6 +194,7 @@ function uniqueId(suffix) {
 }
 
 // src/performance/domRecycler.ts
+var _isDev = isDev();
 var DOMPool = class {
   constructor(maxSize = 50) {
     this.pools = /* @__PURE__ */ new Map();
@@ -191,8 +214,18 @@ var DOMPool = class {
   /**
    * Return an element to the pool for reuse.
    * Clears attributes, children, and event listeners.
+   *
+   * Contract: the caller MUST detach the element from the DOM (and run any
+   * `dispose()` on bound reactive subscriptions) BEFORE calling `release()`.
+   * Releasing a connected element leaves it visible while it is mutated and
+   * is almost certainly a bug.
    */
   release(element) {
+    if (_isDev && element.isConnected) {
+      devWarn(
+        "DOMPool.release() called on a still-connected element. Detach it from the DOM first (remove() / dispose())."
+      );
+    }
     const tag = element.tagName.toLowerCase();
     let pool = this.pools.get(tag);
     if (!pool) {
@@ -228,7 +261,11 @@ var DOMPool = class {
     return result;
   }
 };
-var domPool = new DOMPool();
+var _defaultPool = null;
+function getDOMPool() {
+  if (_defaultPool === null) _defaultPool = new DOMPool();
+  return _defaultPool;
+}
 var preloadedResources = /* @__PURE__ */ new Set();
 function preloadResource(url, type = "fetch") {
   if (preloadedResources.has(url)) return;
@@ -458,31 +495,45 @@ function createChunkRegistry(config = {}) {
   const pending = /* @__PURE__ */ new Map();
   const preloaded = /* @__PURE__ */ new Set();
   function evict() {
-    if (cache.size < maxCacheSize) return;
-    let oldest = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldest = key;
+    while (cache.size >= maxCacheSize) {
+      let lru = null;
+      let lruTime = Infinity;
+      for (const [key, entry] of cache) {
+        if (entry.lastAccess < lruTime) {
+          lruTime = entry.lastAccess;
+          lru = key;
+        }
       }
+      if (!lru) return;
+      cache.delete(lru);
     }
-    if (oldest) cache.delete(oldest);
   }
   function isValid(entry) {
     if (cacheTTL === 0) return true;
     return Date.now() - entry.timestamp < cacheTTL;
   }
   async function loadWithRetry(id, loader, attempt = 0) {
+    let timeoutHandle = null;
     try {
-      const result = await (timeout > 0 ? Promise.race([
-        loader(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Chunk '${id}' loading timed out after ${timeout}ms`)), timeout)
-        )
-      ]) : loader());
+      const result = await (timeout > 0 ? new Promise((resolve, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new Error(`Chunk '${id}' loading timed out after ${timeout}ms`)),
+          timeout
+        );
+        loader().then(
+          (v) => {
+            if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+            resolve(v);
+          },
+          (e) => {
+            if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+            reject(e);
+          }
+        );
+      }) : loader());
       return result;
     } catch (err) {
+      if (timeoutHandle !== null) clearTimeout(timeoutHandle);
       if (attempt < retries) {
         await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
         return loadWithRetry(id, loader, attempt + 1);
@@ -490,49 +541,48 @@ function createChunkRegistry(config = {}) {
       throw err;
     }
   }
+  async function loadFn(id, loader) {
+    const cached = cache.get(id);
+    if (cached && isValid(cached)) {
+      cached.accessCount++;
+      cached.lastAccess = Date.now();
+      return cached.value;
+    }
+    const pendingLoad = pending.get(id);
+    if (pendingLoad) return pendingLoad;
+    onLoadStart?.(id);
+    const loadPromise = loadWithRetry(id, loader).then((value) => {
+      evict();
+      const now = Date.now();
+      cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
+      pending.delete(id);
+      onLoadEnd?.(id);
+      return value;
+    }).catch((err) => {
+      pending.delete(id);
+      const error = err instanceof Error ? err : new Error(String(err));
+      onLoadError?.(id, error);
+      throw error;
+    });
+    pending.set(id, loadPromise);
+    return loadPromise;
+  }
+  function preloadFn(id, loader) {
+    if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
+    preloaded.add(id);
+    loadFn(id, loader).catch(() => {
+      preloaded.delete(id);
+    });
+  }
   return {
-    /**
-     * Load a chunk by ID. Uses cache if available, otherwise loads via the provided loader.
-     */
-    async load(id, loader) {
-      const cached = cache.get(id);
-      if (cached && isValid(cached)) {
-        cached.accessCount++;
-        return cached.value;
-      }
-      const pendingLoad = pending.get(id);
-      if (pendingLoad) return pendingLoad;
-      onLoadStart?.(id);
-      const loadPromise = loadWithRetry(id, loader).then((value) => {
-        evict();
-        cache.set(id, { value, timestamp: Date.now(), accessCount: 1 });
-        pending.delete(id);
-        onLoadEnd?.(id);
-        return value;
-      }).catch((err) => {
-        pending.delete(id);
-        const error = err instanceof Error ? err : new Error(String(err));
-        onLoadError?.(id, error);
-        throw error;
-      });
-      pending.set(id, loadPromise);
-      return loadPromise;
-    },
-    /**
-     * Preload a chunk without blocking. Silently caches for later use.
-     */
-    preload(id, loader) {
-      if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
-      preloaded.add(id);
-      this.load(id, loader).catch(() => {
-      });
-    },
+    load: loadFn,
+    preload: preloadFn,
     /**
      * Preload multiple chunks in parallel.
      */
     preloadAll(entries) {
       for (const entry of entries) {
-        this.preload(entry.id, entry.loader);
+        preloadFn(entry.id, entry.loader);
       }
     },
     /**
@@ -549,6 +599,7 @@ function createChunkRegistry(config = {}) {
       const entry = cache.get(id);
       if (entry && isValid(entry)) {
         entry.accessCount++;
+        entry.lastAccess = Date.now();
         return entry.value;
       }
       return void 0;
@@ -558,6 +609,7 @@ function createChunkRegistry(config = {}) {
      */
     invalidate(id) {
       cache.delete(id);
+      preloaded.delete(id);
     },
     /**
      * Clear all cached chunks.
@@ -630,7 +682,7 @@ export {
   setIdPrefix,
   uniqueId,
   DOMPool,
-  domPool,
+  getDOMPool,
   preloadResource,
   prefetch,
   preloadImage,

package/dist/chunk-3JHCYHWN.js

@@ -0,0 +1,125 @@
+// src/plugins/plugin.ts
+function createPluginRegistry() {
+  const installedPlugins = /* @__PURE__ */ new Set();
+  const hooks = { init: [], mount: [], unmount: [], error: [] };
+  const provided = /* @__PURE__ */ new Map();
+  const registry = {
+    installedPlugins,
+    hooks,
+    provided,
+    plugin(p, options) {
+      if (installedPlugins.has(p.name)) {
+        console.warn(`[Plugin] "${p.name}" is already installed.`);
+        return;
+      }
+      const ctx = {
+        onInit: (cb) => hooks.init.push(cb),
+        onMount: (cb) => hooks.mount.push(cb),
+        onUnmount: (cb) => hooks.unmount.push(cb),
+        onError: (cb) => hooks.error.push(cb),
+        provide: (key, value) => provided.set(key, value)
+      };
+      const initHooksBefore = hooks.init.length;
+      p.install(ctx, options);
+      installedPlugins.add(p.name);
+      const justAdded = hooks.init.slice(initHooksBefore);
+      for (const cb of justAdded) {
+        try {
+          cb();
+        } catch (e) {
+          console.error(`[Plugin] "${p.name}" init error:`, e);
+        }
+      }
+    },
+    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() {
+      installedPlugins.clear();
+      hooks.init.length = 0;
+      hooks.mount.length = 0;
+      hooks.unmount.length = 0;
+      hooks.error.length = 0;
+      provided.clear();
+    }
+  };
+  return registry;
+}
+var defaultRegistry = createPluginRegistry();
+var defaultRegistryTouched = false;
+function createPlugin(name, install) {
+  return { name, install };
+}
+function plugin(plugin2, options) {
+  defaultRegistryTouched = true;
+  defaultRegistry.plugin(plugin2, options);
+}
+function inject(key, defaultValue) {
+  return defaultRegistry.inject(key, defaultValue);
+}
+function triggerPluginMount(element) {
+  defaultRegistry.triggerMount(element);
+}
+function triggerPluginUnmount(element) {
+  defaultRegistry.triggerUnmount(element);
+}
+function triggerPluginError(error) {
+  defaultRegistry.triggerError(error);
+}
+function resetPlugins() {
+  defaultRegistry.reset();
+  defaultRegistryTouched = false;
+}
+function setDefaultPluginRegistry(registry) {
+  if (defaultRegistryTouched && defaultRegistry.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."
+    );
+  }
+  defaultRegistry = registry;
+  defaultRegistryTouched = true;
+}
+
+export {
+  createPluginRegistry,
+  createPlugin,
+  plugin,
+  inject,
+  triggerPluginMount,
+  triggerPluginUnmount,
+  triggerPluginError,
+  resetPlugins,
+  setDefaultPluginRegistry
+};

package/dist/{chunk-CZUGLNJS.js → chunk-45YP72ZQ.js}

@@ -1,12 +1,12 @@
 import {
   isSSR
-} from "./chunk-CHJ27IGK.js";
+} from "./chunk-2RA7SHDA.js";
 import {
   track
-} from "./chunk-YECR7UIA.js";
+} from "./chunk-QO3WC6FS.js";
 import {
   devAssert
-} from "./chunk-4MYMUBRS.js";
+} from "./chunk-LMLD24FC.js";
 
 // src/core/signals/watch.ts
 function watch(getter, callback) {