sibujs 4.9.0 → 4.10.0

package/dist/plugins.js

@@ -19,7 +19,7 @@ import {
   preloadCritical,
   prerenderRoutes,
   satisfies
-} from "./chunk-CF2KCWRE.js";
+} from "./chunk-54F4TPHK.js";
 import {
   PluginInstallCancelledError,
   createPlugin,
@@ -35,7 +35,7 @@ import {
 } from "./chunk-J6FW5TV6.js";
 import {
   span
-} from "./chunk-QBKCK6MJ.js";
+} from "./chunk-N6U4GOIU.js";
 import {
   escapeScriptJson,
   renderToString,
@@ -48,17 +48,17 @@ import {
 import {
   appendChildren,
   resolveClassValue
-} from "./chunk-5MLWTIQE.js";
+} from "./chunk-EVI4ZQO3.js";
 import {
   setSafeAttribute
-} from "./chunk-MPWDSTYK.js";
+} from "./chunk-XUQUQJYE.js";
 import "./chunk-3ACAAQIN.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-SBTZEYNI.js";
+} from "./chunk-7WIHYHWD.js";
 import {
   sanitizeUrl,
   stripControlChars
@@ -69,11 +69,14 @@ import {
 import "./chunk-5HZXGZ6T.js";
 import {
   signal
-} from "./chunk-SYHGGDNW.js";
+} from "./chunk-FYUEL5IW.js";
 import {
+  bindOwnerScope,
+  getOwnerScope,
+  runWithOwnerScope,
   track,
   untracked
-} from "./chunk-G2WHYEL7.js";
+} from "./chunk-D6HYFOWR.js";
 import {
   devWarn,
   dispose,
@@ -652,12 +655,12 @@ var _ComponentLoader = class _ComponentLoader {
    * resolved, so the import happens once and later mounts call the module's
    * factory directly.
    */
-  async instantiate(plan, route2, routePath) {
+  async instantiate(plan, route2, routePath, scope) {
     if (plan.kind === "factory") {
-      return this.instantiateFactory(plan.component, route2, routePath);
+      return this.instantiateFactory(plan.component, route2, routePath, scope);
     }
     const factory = await this.resolveModuleFactory(plan, route2, routePath);
-    return this.instantiateFactory(factory, route2, routePath);
+    return this.instantiateFactory(factory, route2, routePath, scope);
   }
   /**
    * Resolve a deferred plan's module and cache the factory it exports —
@@ -702,14 +705,14 @@ var _ComponentLoader = class _ComponentLoader {
    * `depth` bounds that unwrapping; a module whose default is itself a module
    * is a configuration error, not something to chase.
    */
-  async instantiateFactory(component, route2, routePath, depth = 0) {
-    const result = component();
+  async instantiateFactory(component, route2, routePath, scope, depth = 0) {
+    const result = scope ? runWithOwnerScope(scope, component) : component();
     const value = this.isThenable(result) ? await result : result;
     if (this.isElement(value)) return value;
     if (depth === 0 && this.isFactoryLike(value)) {
       const factory = this.extractFactory(value, routePath);
       this.planCache.set(this.keyFor(route2), { kind: "factory", component: factory });
-      return this.instantiateFactory(factory, route2, routePath, depth + 1);
+      return this.instantiateFactory(factory, route2, routePath, scope, depth + 1);
     }
     throw new Error(`Component for route "${routePath}" must return Element, got ${typeof value}`);
   }
@@ -1114,9 +1117,12 @@ var _SibuRouter = class _SibuRouter {
   async loadPlan(route2, routePath) {
     return this.loader.loadPlan(route2, routePath);
   }
-  /** Create exactly one real instance from an already-resolved plan. */
-  async instantiateComponent(plan, route2, routePath) {
-    return this.loader.instantiate(plan, route2, routePath);
+  /**
+   * Create exactly one real instance from an already-resolved plan. With a
+   * `scope`, the factory runs in it (see `RouteScope`).
+   */
+  async instantiateComponent(plan, route2, routePath, scope) {
+    return this.loader.instantiate(plan, route2, routePath, scope);
   }
   /** Resolve a route's module/factory without creating any component instance. */
   async preloadPlan(route2, routePath) {
@@ -1272,14 +1278,72 @@ function setRoutes(routes) {
   if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
   _routerRef.current.updateRoutes(normalizeRoutes(routes));
 }
+var RouteScope = class {
+  constructor(route2) {
+    this.released = false;
+    const [get, set] = signal(route2);
+    this.get = get;
+    this.set = set;
+  }
+  /** The instance's route, or `null` once released. Reactive. */
+  read() {
+    return this.get();
+  }
+  /** Hand a kept instance the route of the navigation that kept it. */
+  update(route2) {
+    if (!this.released) this.set(route2);
+  }
+  /**
+   * Called when the instance is disposed. The switch to "no scope" is
+   * published a microtask later, once the whole dispose has finished: a
+   * teardown the instance registered after this one (an `onMount` effect, say)
+   * may still be alive at this point, and must not re-run against the
+   * router-global route on its way out.
+   */
+  release() {
+    if (this.released) return;
+    this.released = true;
+    queueMicrotask(() => this.set(null));
+  }
+};
+function activeRouteScope() {
+  const scope = getOwnerScope();
+  return scope instanceof RouteScope ? scope : null;
+}
+function scopedRoute(router2) {
+  const scope = activeRouteScope();
+  if (scope) {
+    const committed = scope.read();
+    if (committed !== null) return committed;
+  }
+  return router2.currentRoute;
+}
+var instanceScopes = /* @__PURE__ */ new WeakMap();
+async function instantiateScoped(router2, plan, routeDef, routePath, route2) {
+  const scope = new RouteScope(route2);
+  const node = await router2.instantiateComponent(plan, routeDef, routePath, scope);
+  if (node) {
+    instanceScopes.set(node, scope);
+    registerDisposer(node, () => scope.release());
+  }
+  return node;
+}
+function updateInstanceRoute(node, route2) {
+  if (node) instanceScopes.get(node)?.update(route2);
+}
+function disposeOwned(node) {
+  const scope = instanceScopes.get(node);
+  if (scope) runWithOwnerScope(scope, () => dispose(node));
+  else dispose(node);
+}
 function route() {
   if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.currentRoute;
+  return scopedRoute(_routerRef.current);
 }
 function router() {
   if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
   return {
-    currentRoute: _routerRef.current.currentRoute,
+    currentRoute: scopedRoute(_routerRef.current),
     isReady: _routerRef.current.isReady,
     isNavigating: _routerRef.current.isNavigating,
     push: (to) => _routerRef.current?.push(to),
@@ -1365,13 +1429,13 @@ function Route() {
   const commitTarget = (seq) => routeTorn || seq !== navSeq ? null : anchor.parentNode;
   const release = (node) => {
     if (!node) return;
-    dispose(node);
+    disposeOwned(node);
     node.parentNode?.removeChild(node);
   };
   const cleanupNodes = () => {
     [currentNode, loadingNode, errorNode].forEach((node) => {
       if (!node) return;
-      dispose(node);
+      disposeOwned(node);
       if (node.parentNode) {
         node.parentNode.removeChild(node);
       }
@@ -1447,7 +1511,7 @@ function Route() {
   const update = async () => {
     if (routeTorn || !_routerRef.current) return;
     const seq = ++navSeq;
-    const route2 = _routerRef.current.currentRoute;
+    const route2 = scopedRoute(_routerRef.current);
     try {
       const match = _routerRef.current["matcher"].match(route2.path);
       if (!match) {
@@ -1459,6 +1523,7 @@ function Route() {
       const routeDef = match.matched[0] || match.route;
       const key = instanceKey(routeDef, [routeDef], route2);
       if (routeDef === currentTopRoute && key === currentKey && currentNode) {
+        updateInstanceRoute(currentNode, route2);
         return;
       }
       if ("redirect" in routeDef) {
@@ -1478,7 +1543,7 @@ function Route() {
           }
           const plan = await _routerRef.current.loadPlan(routeDef, route2.path);
           if (!commitTarget(seq)) return;
-          const node = await _routerRef.current.instantiateComponent(plan, routeDef, route2.path);
+          const node = await instantiateScoped(_routerRef.current, plan, routeDef, route2.path, route2);
           const parent = commitTarget(seq);
           if (!parent) {
             release(node);
@@ -1513,9 +1578,11 @@ function Route() {
   };
   const routeTeardown = track(wrappedUpdate);
   if (!routeInitialized) {
-    queueMicrotask(() => {
-      if (!routeInitialized && anchor.parentNode) wrappedUpdate();
-    });
+    queueMicrotask(
+      bindOwnerScope(() => {
+        if (!routeInitialized && anchor.parentNode) wrappedUpdate();
+      })
+    );
   }
   const routeCleanup = () => {
     if (routeTorn) return;
@@ -1548,7 +1615,7 @@ function KeepAliveRoute(options) {
     if (kaTorn || !_routerRef.current) return;
     const seq = ++updateSeq;
     const router2 = _routerRef.current;
-    const route2 = router2.currentRoute;
+    const route2 = scopedRoute(router2);
     const match = router2["matcher"].match(route2.path);
     if (!match) return;
     const { route: routeDef } = match;
@@ -1564,7 +1631,10 @@ function KeepAliveRoute(options) {
     if (!("component" in routeDef)) return;
     const cacheKey = JSON.stringify([route2.path, queryIdentity(route2.query), route2.hash]);
     const shouldCache = !includeNames || routeDef.name != null && includeNames.includes(routeDef.name);
-    if (cacheKey === currentKey && currentNode) return;
+    if (cacheKey === currentKey && currentNode) {
+      updateInstanceRoute(currentNode, route2);
+      return;
+    }
     if (!anchor.parentNode) return;
     let node = null;
     let fromCache = false;
@@ -1575,7 +1645,7 @@ function KeepAliveRoute(options) {
       try {
         const plan = await router2.loadPlan(routeDef, route2.path);
         if (kaTorn || seq !== updateSeq) return;
-        node = await router2.instantiateComponent(plan, routeDef, route2.path);
+        node = await instantiateScoped(router2, plan, routeDef, route2.path, route2);
       } catch (error) {
         if (kaTorn || seq !== updateSeq) return;
         console.error("[KeepAliveRoute] Component error:", error);
@@ -1583,20 +1653,21 @@ function KeepAliveRoute(options) {
       }
       if (!node) return;
       if (kaTorn || seq !== updateSeq) {
-        dispose(node);
+        disposeOwned(node);
         return;
       }
     }
     const parent = anchor.parentNode;
     if (!parent) {
-      if (!fromCache) dispose(node);
+      if (!fromCache) disposeOwned(node);
       return;
     }
     if (currentNode && currentNode !== node) {
       if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
-      if (!currentCached) dispose(currentNode);
+      if (!currentCached) disposeOwned(currentNode);
     }
     if (fromCache) {
+      updateInstanceRoute(node, route2);
       const idx = lruOrder.indexOf(cacheKey);
       if (idx !== -1) lruOrder.splice(idx, 1);
       lruOrder.push(cacheKey);
@@ -1611,7 +1682,7 @@ function KeepAliveRoute(options) {
         }
         const evictNode = cache.get(evictKey);
         if (evictNode) {
-          dispose(evictNode);
+          disposeOwned(evictNode);
           if (evictNode.parentNode) evictNode.parentNode.removeChild(evictNode);
           cache.delete(evictKey);
         }
@@ -1629,9 +1700,11 @@ function KeepAliveRoute(options) {
   };
   const kaTeardown = track(wrappedUpdate);
   if (!initialized) {
-    queueMicrotask(() => {
-      if (!initialized && anchor.parentNode) wrappedUpdate();
-    });
+    queueMicrotask(
+      bindOwnerScope(() => {
+        if (!initialized && anchor.parentNode) wrappedUpdate();
+      })
+    );
   }
   const kaCleanup = () => {
     if (kaTorn) return;
@@ -1639,13 +1712,13 @@ function KeepAliveRoute(options) {
     updateSeq++;
     kaTeardown();
     for (const node of cache.values()) {
-      dispose(node);
+      disposeOwned(node);
       if (node.parentNode) node.parentNode.removeChild(node);
     }
     cache.clear();
     lruOrder.length = 0;
     if (currentNode?.parentNode) currentNode.parentNode.removeChild(currentNode);
-    if (currentNode && !currentCached) dispose(currentNode);
+    if (currentNode && !currentCached) disposeOwned(currentNode);
     currentNode = null;
     currentKey = "";
     currentCached = false;
@@ -1801,7 +1874,7 @@ function Suspense(props) {
     generation++;
     cleanupNodes();
   });
-  queueMicrotask(render);
+  queueMicrotask(bindOwnerScope(render));
   return anchor;
 }
 var LAZY_MARKER = /* @__PURE__ */ Symbol.for("sibujs:lazy");
@@ -1869,7 +1942,7 @@ function Outlet() {
   let outletTorn = false;
   const clearCurrent = () => {
     if (currentNode) {
-      dispose(currentNode);
+      disposeOwned(currentNode);
       if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
       currentNode = null;
     }
@@ -1879,13 +1952,13 @@ function Outlet() {
   const commitTarget = (seq) => outletTorn || seq !== navSeq ? null : anchor.parentNode;
   const release = (node) => {
     if (!node) return;
-    dispose(node);
+    disposeOwned(node);
     node.parentNode?.removeChild(node);
   };
   const update = async () => {
     if (outletTorn || !_routerRef.current) return;
     const seq = ++navSeq;
-    const route2 = _routerRef.current.currentRoute;
+    const route2 = scopedRoute(_routerRef.current);
     if (route2.matched.length < 2) {
       clearCurrent();
       return;
@@ -1896,12 +1969,15 @@ function Outlet() {
       return;
     }
     const key = instanceKey(childRoute, route2.matched.slice(1), route2);
-    if (childRoute === currentChild && key === currentKey && currentNode) return;
+    if (childRoute === currentChild && key === currentKey && currentNode) {
+      updateInstanceRoute(currentNode, route2);
+      return;
+    }
     try {
       const cacheKey = `${route2.path}\0${childRoute.path}`;
       const plan = await _routerRef.current.loadPlan(childRoute, cacheKey);
       if (!commitTarget(seq)) return;
-      const node = await _routerRef.current.instantiateComponent(plan, childRoute, cacheKey);
+      const node = await instantiateScoped(_routerRef.current, plan, childRoute, cacheKey, route2);
       const parent = commitTarget(seq);
       if (!parent) {
         release(node);
@@ -1920,9 +1996,11 @@ function Outlet() {
   };
   const outletTeardown = track(update);
   if (!anchor.parentNode) {
-    queueMicrotask(() => {
-      if (anchor.parentNode) update();
-    });
+    queueMicrotask(
+      bindOwnerScope(() => {
+        if (anchor.parentNode) update();
+      })
+    );
   }
   const outletCleanup = () => {
     if (outletTorn) return;
@@ -1930,7 +2008,7 @@ function Outlet() {
     navSeq++;
     outletTeardown();
     if (currentNode) {
-      dispose(currentNode);
+      disposeOwned(currentNode);
       if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
       currentNode = null;
     }
@@ -1953,11 +2031,11 @@ function routerState() {
   if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
   const router2 = _routerRef.current;
   return {
-    currentPath: () => router2.currentRoute.path,
-    params: () => router2.currentRoute.params,
-    query: () => router2.currentRoute.query,
-    hash: () => router2.currentRoute.hash,
-    meta: () => router2.currentRoute.meta,
+    currentPath: () => scopedRoute(router2).path,
+    params: () => scopedRoute(router2).params,
+    query: () => scopedRoute(router2).query,
+    hash: () => scopedRoute(router2).hash,
+    meta: () => scopedRoute(router2).meta,
     isNavigating: () => router2.isNavigating,
     isReady: () => router2.isReady
   };

package/dist/ssr.cjs

@@ -1650,6 +1650,24 @@ function untracked(fn) {
     resumeTracking();
   }
 }
+var currentOwnerScope = null;
+function getOwnerScope() {
+  return currentOwnerScope;
+}
+function runWithOwnerScope(scope, fn) {
+  const prev = currentOwnerScope;
+  currentOwnerScope = scope;
+  try {
+    return fn();
+  } finally {
+    currentOwnerScope = prev;
+  }
+}
+function bindOwnerScope(fn) {
+  const scope = currentOwnerScope;
+  if (scope === null) return fn;
+  return (...args) => runWithOwnerScope(scope, () => fn(...args));
+}
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
@@ -1665,6 +1683,10 @@ function retrack(effectFn, subscriber) {
   currentSubscriber = subscriber;
   const sub2 = subscriber;
   if (sub2._cap === void 0) sub2._cap = currentDisposerCapture();
+  const prevScope = currentOwnerScope;
+  if (prevScope !== null && !sub2._epoch && sub2._scope === void 0) sub2._scope = prevScope;
+  const scope = sub2._scope === void 0 ? null : sub2._scope;
+  if (scope !== prevScope) currentOwnerScope = scope;
   const epoch = ++subscriberEpochCounter;
   sub2._epoch = epoch;
   sub2._structDirty = false;
@@ -1677,6 +1699,7 @@ function retrack(effectFn, subscriber) {
     effectFn();
   } finally {
     currentSubscriber = prev;
+    currentOwnerScope = prevScope;
     if (savedDepth !== 0) {
       suspendDepth = savedDepth;
       suspendSavedSub = savedSuspendSub;
@@ -1711,23 +1734,26 @@ function track(effectFn, subscriber) {
     trackingSuspended = false;
   }
   currentSubscriber = subscriber;
+  const sub2 = subscriber;
+  if (sub2._scope === void 0) sub2._scope = currentOwnerScope;
+  const prevScope = currentOwnerScope;
+  currentOwnerScope = sub2._scope;
   try {
     effectFn();
   } finally {
     currentSubscriber = prev;
+    currentOwnerScope = prevScope;
     if (savedDepth !== 0) {
       suspendDepth = savedDepth;
       suspendSavedSub = savedSuspendSub;
       trackingSuspended = true;
     }
-    const sub3 = subscriber;
-    for (let n = sub3.depsHead ?? null; n !== null; n = n.subNext) {
+    for (let n = sub2.depsHead ?? null; n !== null; n = n.subNext) {
       const sig = n.sig;
       sig.__activeNode = n.prevActive;
       n.prevActive = null;
     }
   }
-  const sub2 = subscriber;
   return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
 function reactiveBinding(commit, ownerNode) {
@@ -1997,7 +2023,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.9.0" : "dev";
+var _runtimeVersion = true ? "4.10.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -2029,6 +2055,9 @@ function resolveReactiveApi() {
     getSubscriberCount,
     getSubscriberDeps,
     forEachSubscriber,
+    getOwnerScope,
+    runWithOwnerScope,
+    bindOwnerScope,
     version: _runtimeVersion
   };
   g2[REGISTRY_KEY] = local;
@@ -2052,6 +2081,9 @@ var notifySubscribers2 = API.notifySubscribers;
 var getSubscriberCount2 = API.getSubscriberCount;
 var getSubscriberDeps2 = API.getSubscriberDeps;
 var forEachSubscriber2 = API.forEachSubscriber;
+var getOwnerScope2 = API.getOwnerScope ?? getOwnerScope;
+var runWithOwnerScope2 = API.runWithOwnerScope ?? runWithOwnerScope;
+var bindOwnerScope2 = API.bindOwnerScope ?? bindOwnerScope;
 
 // src/core/devtoolsHook.ts
 function emitDevtools(hook, event, payload) {
@@ -2068,6 +2100,11 @@ function flushUserCleanups(ctx) {
   const list = ctx.userCleanups;
   if (list.length === 0) return;
   ctx.userCleanups = [];
+  const scope = ctx.subscriber._scope ?? null;
+  if (scope === getOwnerScope2()) runCleanups(list);
+  else runWithOwnerScope2(scope, () => runCleanups(list));
+}
+function runCleanups(list) {
   for (let i2 = list.length - 1; i2 >= 0; i2--) {
     try {
       list[i2]();
@@ -3623,11 +3660,15 @@ function defineRemoteComponent(name, loader) {
     registerDisposer(container, () => {
       disposed = true;
     });
-    loader().then((mod) => {
-      cached = mod.default;
-      if (disposed) return;
-      replaceChildrenSafely(container, cached());
-    }).catch((err) => {
+    loader().then(
+      // Instantiated after the module resolves, in the owner scope of the
+      // render that asked for it — as `lazy()` does.
+      bindOwnerScope2((mod) => {
+        cached = mod.default;
+        if (disposed) return;
+        replaceChildrenSafely(container, cached());
+      })
+    ).catch((err) => {
       if (disposed) return;
       const message = err instanceof Error ? err.message : String(err);
       replaceChildrenSafely(

package/dist/ssr.js

@@ -23,9 +23,9 @@ import {
   wasm,
   worker,
   workerFn
-} from "./chunk-KG25XMGP.js";
+} from "./chunk-4DCVJ4YA.js";
 import "./chunk-52XFPGSN.js";
-import "./chunk-QBKCK6MJ.js";
+import "./chunk-N6U4GOIU.js";
 import {
   collectStream,
   deserializeState,
@@ -47,15 +47,15 @@ import {
   trustHTML
 } from "./chunk-FC6KCJSA.js";
 import "./chunk-62BDYGAG.js";
-import "./chunk-5MLWTIQE.js";
-import "./chunk-MPWDSTYK.js";
+import "./chunk-EVI4ZQO3.js";
+import "./chunk-XUQUQJYE.js";
 import "./chunk-3ACAAQIN.js";
 import "./chunk-7ZHH77QA.js";
-import "./chunk-SBTZEYNI.js";
+import "./chunk-7WIHYHWD.js";
 import "./chunk-EXXSN3BW.js";
 import "./chunk-7XHATCIH.js";
-import "./chunk-SYHGGDNW.js";
-import "./chunk-G2WHYEL7.js";
+import "./chunk-FYUEL5IW.js";
+import "./chunk-D6HYFOWR.js";
 import "./chunk-NYNYSPK7.js";
 export {
   Head,