@sigmela/router 0.2.8 → 0.3.1

package/lib/module/Router.js

@@ -25,8 +25,10 @@ export class Router {
   stackById = new Map();
   routeById = new Map();
   stackActivators = new Map();
+  compiledRouteById = new Map();
   stackHistories = new Map();
   activeRoute = null;
+  activeRouteListeners = new Set();
   rootListeners = new Set();
   rootTransition = undefined;
   // Root swaps should behave like a fresh initial mount (no enter animation).
@@ -34,9 +36,16 @@ export class Router {
   suppressRootTransitionOnNextRead = false;
   lastBrowserIndex = 0;
   suppressHistorySyncCount = 0;
-
   // Used to prevent stale controller-driven navigations (controller calls present later).
   navigationToken = 0;
+  // parsePath one-slot cache
+  lastParsedPath = null;
+  lastParsedResult = null;
+
+  // matchBaseRoute one-slot cache
+  lastMatchedPathname = null;
+  lastMatchedQuery = null;
+  lastMatchedResult = null;
   constructor(config) {
     this.debugEnabled = config.debug ?? false;
     this.routerScreenOptions = config.screenOptions;
@@ -82,6 +91,11 @@ export class Router {
     }
   }
   navigate = path => {
+    if (!path || typeof path !== 'string') {
+      if (__DEV__) throw new Error('Router.navigate: path must be a non-empty string');
+      console.warn('[Router] navigate called with invalid path');
+      return;
+    }
     if (this.isWebEnv()) {
       const syncWithUrl = this.shouldSyncPathWithUrl(path);
       this.pushUrl(path, {
@@ -92,6 +106,11 @@ export class Router {
     this.performNavigation(path, 'push');
   };
   replace = (path, dedupe) => {
+    if (!path || typeof path !== 'string') {
+      if (__DEV__) throw new Error('Router.replace: path must be a non-empty string');
+      console.warn('[Router] replace called with invalid path');
+      return;
+    }
     if (this.isWebEnv()) {
       const syncWithUrl = this.shouldSyncPathWithUrl(path);
       this.replaceUrl(path, {
@@ -113,6 +132,11 @@ export class Router {
    * and browser URL can get out of sync).
    */
   reset = path => {
+    if (!path || typeof path !== 'string') {
+      if (__DEV__) throw new Error('Router.reset: path must be a non-empty string');
+      console.warn('[Router] reset called with invalid path');
+      return;
+    }
     if (this.isWebEnv()) {
       const prevHistory = this.state.history;
       // Important: clear current history before matching routes for the new URL.
@@ -190,7 +214,7 @@ export class Router {
     }
 
     // Check if modal has a childNode (NavigationStack added via addModal)
-    const compiled = this.registry.find(r => r.routeId === modalItem.routeId);
+    const compiled = this.getCompiledRoute(modalItem.routeId);
     const childNode = compiled?.childNode;
     if (childNode) {
       // Modal stack: remove all items from child stack AND the modal wrapper item
@@ -200,19 +224,23 @@ export class Router {
         modalKey: modalItem.key
       });
       this.markStackDismissed(childStackId);
+
+      // Clear child stack's history cache BEFORE setState so listeners see clean state
+      this.stackHistories.delete(childStackId);
       const newHistory = this.state.history.filter(item => item.stackId !== childStackId && item.key !== modalItem.key);
       this.setState({
         history: newHistory
       });
-
-      // Clear child stack's history cache
-      this.stackHistories.delete(childStackId);
     } else {
       // Simple modal: just pop the modal item
+      // applyHistoryChange already calls recomputeActiveRoute + emit(this.listeners)
       this.applyHistoryChange('pop', modalItem);
     }
-    this.recomputeActiveRoute();
-    this.emit(this.listeners);
+    if (childNode) {
+      // childNode branch uses setState directly, so we need to emit manually
+      this.recomputeActiveRoute();
+      this.emit(this.listeners);
+    }
 
     // Sync URL on web
     if (this.isWebEnv()) {
@@ -228,6 +256,12 @@ export class Router {
       this.listeners.delete(listener);
     };
   }
+  subscribeActiveRoute = listener => {
+    this.activeRouteListeners.add(listener);
+    return () => {
+      this.activeRouteListeners.delete(listener);
+    };
+  };
   getStackHistory = stackId => {
     if (!stackId) return EMPTY_ARRAY;
     if (!this.stackHistories.has(stackId)) {
@@ -268,7 +302,7 @@ export class Router {
     return () => this.rootListeners.delete(listener);
   }
   emitRootChange() {
-    this.rootListeners.forEach(l => l());
+    this.emit(this.rootListeners);
   }
   getRootTransition() {
     if (this.suppressRootTransitionOnNextRead) {
@@ -292,10 +326,18 @@ export class Router {
     this.registry.length = 0;
     this.stackById.clear();
     this.routeById.clear();
+    this.compiledRouteById.clear();
     this.stackActivators.clear();
+    this.lastMatchedPathname = null;
+    this.lastMatchedQuery = null;
+    this.lastMatchedResult = null;
     this.state = {
       history: []
     };
+    this.stackHistories.clear();
+    this.sheetDismissers.clear();
+    this.dismissedStackIds.clear();
+    this.stackListeners.clear();
     this.buildRegistry();
     this.seedInitialHistory();
     this.recomputeActiveRoute();
@@ -410,7 +452,7 @@ export class Router {
       const top = history[history.length - 1];
       if (top) {
         const meta = this.routeById.get(top.routeId);
-        this.activeRoute = meta ? {
+        const newRoute = meta ? {
           ...meta,
           routeId: top.routeId,
           params: top.params,
@@ -423,12 +465,23 @@ export class Router {
           query: top.query,
           path: top.path
         };
+
+        // Shallow compare to keep stable reference and avoid unnecessary re-renders
+        if (this.activeRoute && this.activeRoute.routeId === newRoute.routeId && this.activeRoute.stackId === newRoute.stackId && this.activeRoute.path === newRoute.path && this.activeRoute.params === newRoute.params && this.activeRoute.query === newRoute.query) {
+          return;
+        }
+        this.activeRoute = newRoute;
+        this.emit(this.activeRouteListeners);
         return;
       }
     }
-    this.activeRoute = null;
+    if (this.activeRoute !== null) {
+      this.activeRoute = null;
+      this.emit(this.activeRouteListeners);
+    }
   }
   performNavigation(path, action, opts) {
+    if (this.destroyed) return;
     const {
       pathname,
       query
@@ -453,6 +506,7 @@ export class Router {
       if (__DEV__) {
         throw new Error(`Route not found: "${pathname}"`);
       }
+      console.warn(`[Router] Route not found: "${pathname}"`);
       return;
     }
 
@@ -507,7 +561,7 @@ export class Router {
             ...existing,
             routeId: base.routeId,
             params: normalizedParams,
-            query: query,
+            query,
             path: pathname,
             component: base.component,
             options: this.mergeOptions(base.options, base.stackId),
@@ -544,7 +598,7 @@ export class Router {
         });
         if (sameIdentity && sameQuery) {
           this.log('dedupe: already at target, syncing state');
-          this.syncStateForSameRoute(base, pathname, params, query);
+          this.syncStateForSameRoute(base, pathname);
           return;
         }
         if (sameIdentity && !sameQuery) {
@@ -553,7 +607,7 @@ export class Router {
           const updatedTop = {
             ...top,
             params: normalizedParams,
-            query: query,
+            query,
             path: pathname
           };
           this.applyHistoryChange('replace', updatedTop);
@@ -567,7 +621,7 @@ export class Router {
           const updatedExisting = {
             ...existing,
             params: normalizedParams,
-            query: query,
+            query,
             path: pathname
           };
           this.log('dedupe: found existing item, calling popTo', {
@@ -622,7 +676,7 @@ export class Router {
       component: matched.component,
       options: this.mergeOptions(matched.options, matched.stackId),
       params: normalizedParams,
-      query: query,
+      query,
       passProps,
       stackId: matched.stackId,
       pattern: matched.path,
@@ -631,7 +685,12 @@ export class Router {
   }
   applyHistoryChange(action, item) {
     const stackId = item.stackId;
-    if (!stackId) return;
+    if (!stackId) {
+      if (__DEV__) {
+        console.warn(`[Router] Navigation dropped: item has no stackId (routeId: ${item.routeId}, path: ${item.path})`);
+      }
+      return;
+    }
     const prevHist = this.state.history;
     let nextHist = prevHist;
     this.log('applyHistoryChange', {
@@ -669,6 +728,7 @@ export class Router {
       const copy = [...prevHist];
       for (let i = copy.length - 1; i >= 0; i--) {
         const h = copy[i];
+        if (!h) continue;
         if (h.stackId === stackId) {
           copy.splice(i, 1);
           break;
@@ -682,6 +742,7 @@ export class Router {
       let foundItem = null;
       for (let i = prevHist.length - 1; i >= 0; i--) {
         const h = prevHist[i];
+        if (!h) continue;
         if (h.stackId !== stackId) {
           continue;
         }
@@ -705,27 +766,51 @@ export class Router {
       if (itemIndex >= 0) {
         copy.splice(itemIndex, 1);
       }
-      copy.push(updatedItem);
+      let insertPos = copy.length;
+      for (let i = copy.length - 1; i >= 0; i--) {
+        if (copy[i]?.stackId === stackId) {
+          insertPos = i + 1;
+          break;
+        }
+      }
+      copy.splice(insertPos, 0, updatedItem);
       nextHist = copy;
     }
     this.setState({
       history: nextHist
-    });
+    }, item.stackId);
     this.recomputeActiveRoute();
     this.emit(this.listeners);
   }
-  setState(next) {
+  setState(next, affectedStackId) {
     const prev = this.state;
     const nextState = {
       history: next.history ?? prev.history
     };
     this.state = nextState;
     if (nextState.history !== prev.history) {
-      this.updateStackHistories();
+      this.updateStackHistories(affectedStackId);
     }
     this.log('setState', nextState);
   }
-  updateStackHistories() {
+  updateStackHistories(affectedStackId) {
+    if (affectedStackId) {
+      // Fast path: only update the one affected stack — O(H) instead of O(S×H)
+      const newHist = this.state.history.filter(h => h.stackId === affectedStackId);
+      const oldHist = this.stackHistories.get(affectedStackId);
+      if (!this.areArraysEqual(oldHist, newHist)) {
+        if (newHist.length === 0) {
+          this.stackHistories.delete(affectedStackId);
+        } else {
+          this.stackHistories.set(affectedStackId, newHist);
+        }
+        const listeners = this.stackListeners.get(affectedStackId);
+        if (listeners) this.emit(listeners);
+      }
+      return;
+    }
+
+    // Slow path: full recompute — used by buildHistoryFromUrl, setRoot, etc.
     const stackIds = new Set();
     this.state.history.forEach(item => {
       if (item.stackId) stackIds.add(item.stackId);
@@ -745,20 +830,21 @@ export class Router {
       if (!currentStackIds.has(stackId) && history.length > 0) {
         this.stackHistories.delete(stackId);
         changedStackIds.add(stackId);
-      } else if (!currentStackIds.has(stackId) && history.length === 0) {}
+      }
     });
     changedStackIds.forEach(stackId => {
       this.emit(this.stackListeners.get(stackId));
     });
   }
   areArraysEqual(a, b) {
+    if (!a) return false;
     if (a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) {
       if (a[i] !== b[i]) return false;
     }
     return true;
   }
-  syncStateForSameRoute(base, pathname, _params, _query) {
+  syncStateForSameRoute(base, pathname) {
     if (!base.stackId) {
       this.recomputeActiveRoute();
       this.emit(this.listeners);
@@ -838,7 +924,7 @@ export class Router {
     for (let i = stackHistory.length - 1; i >= 0; i--) {
       const item = stackHistory[i];
       if (item) {
-        const compiled = this.registry.find(r => r.routeId === item.routeId);
+        const compiled = this.getCompiledRoute(item.routeId);
         if (compiled?.childNode && canSwitchToRoute(compiled.childNode)) {
           return compiled.childNode;
         }
@@ -860,7 +946,7 @@ export class Router {
     if (!stackNode) return;
     const seed = this.getAutoSeed(stackNode);
     if (!seed) return;
-    const compiled = this.registry.find(r => r.routeId === seed.routeId);
+    const compiled = this.getCompiledRoute(seed.routeId);
     const meta = this.routeById.get(seed.routeId);
     const path = compiled?.path ?? meta?.path ?? seed.path;
     const seedStackId = seed.stackId ?? stackNode.getId();
@@ -878,8 +964,9 @@ export class Router {
     const nextHist = [...prevHist, item];
     this.setState({
       history: nextHist
-    });
-    this.emit(this.stackListeners.get(seedStackId));
+    }, seedStackId);
+    // setState with affectedStackId already emits to the stack's listeners
+
     if (seedStackId !== stackId && rootStackId) {
       this.activateContainerForRoute(seed.routeId, rootStackId);
     }
@@ -903,6 +990,7 @@ export class Router {
           query: topOfStack.query,
           path: topOfStack.path
         };
+        this.emit(this.activeRouteListeners);
         return;
       }
     }
@@ -922,19 +1010,29 @@ export class Router {
         query: {},
         path: targetRoute.path
       };
+      this.emit(this.activeRouteListeners);
     }
   }
+  emitDepth = 0;
   emit(set) {
     if (!set) return;
-    // Do not allow one listener to break all others.
-    for (const l of Array.from(set)) {
-      try {
-        l();
-      } catch (e) {
-        if (this.debugEnabled) {
-          console.error('[Router] listener error', e);
+    if (this.emitDepth > 5) {
+      if (this.debugEnabled) console.warn('[Router] emit recursion limit reached');
+      return;
+    }
+    this.emitDepth++;
+    try {
+      for (const l of Array.from(set)) {
+        try {
+          l();
+        } catch (e) {
+          if (this.debugEnabled) {
+            console.error('[Router] listener error', e);
+          }
         }
       }
+    } finally {
+      this.emitDepth--;
     }
   }
   getTopOfStack(stackId) {
@@ -1004,6 +1102,7 @@ export class Router {
           childNode: r.childNode
         };
         this.registry.push(compiled);
+        this.compiledRouteById.set(compiled.routeId, compiled);
         if (stackId) {
           this.routeById.set(r.routeId, {
             path: compiled.path,
@@ -1128,7 +1227,7 @@ export class Router {
     if (this.root) {
       const seed = this.getAutoSeed(this.root);
       if (seed) {
-        const compiled = this.registry.find(r => r.routeId === seed.routeId);
+        const compiled = this.getCompiledRoute(seed.routeId);
         const meta = this.routeById.get(seed.routeId);
         const path = compiled?.path ?? meta?.path ?? seed.path;
         const stackId = seed.stackId ?? this.root.getId();
@@ -1148,7 +1247,9 @@ export class Router {
       return;
     }
   }
-  addChildNodeSeedsToItems(routeId, items, finalRouteId) {
+  addChildNodeSeedsToItems(routeId, items, finalRouteId, visited = new Set()) {
+    if (visited.has(routeId) || visited.size > 50) return;
+    visited.add(routeId);
     this.log('addChildNodeSeeds: called', {
       routeId,
       finalRouteId,
@@ -1159,7 +1260,7 @@ export class Router {
         path: i.path
       }))
     });
-    const compiled = this.registry.find(r => r.routeId === routeId);
+    const compiled = this.getCompiledRoute(routeId);
     if (!compiled || !compiled.childNode) {
       this.log('addChildNodeSeeds: no childNode', {
         routeId
@@ -1185,7 +1286,7 @@ export class Router {
       stackId: childSeed.stackId,
       path: childSeed.path
     });
-    const childCompiled = this.registry.find(r => r.routeId === childSeed.routeId);
+    const childCompiled = this.getCompiledRoute(childSeed.routeId);
     const childMeta = this.routeById.get(childSeed.routeId);
     const childPath = childCompiled?.path ?? childMeta?.path ?? childSeed.path;
     const childStackId = childSeed.stackId ?? childNode.getId();
@@ -1233,16 +1334,18 @@ export class Router {
     const insertIndex = parentIndex >= 0 ? parentIndex + 1 : items.length;
     items.splice(insertIndex, 0, childItem);
     if (childSeed.routeId) {
-      this.addChildNodeSeedsToItems(childSeed.routeId, items, finalRouteId);
+      this.addChildNodeSeedsToItems(childSeed.routeId, items, finalRouteId, visited);
     }
   }
-  addChildNodeSeedsToHistory(routeId) {
-    const compiled = this.registry.find(r => r.routeId === routeId);
+  addChildNodeSeedsToHistory(routeId, visited = new Set()) {
+    if (visited.has(routeId) || visited.size > 50) return;
+    visited.add(routeId);
+    const compiled = this.getCompiledRoute(routeId);
     if (!compiled || !compiled.childNode) return;
     const childNode = compiled.childNode;
     const childSeed = this.getAutoSeed(childNode);
     if (!childSeed) return;
-    const childCompiled = this.registry.find(r => r.routeId === childSeed.routeId);
+    const childCompiled = this.getCompiledRoute(childSeed.routeId);
     const childMeta = this.routeById.get(childSeed.routeId);
     const childPath = childCompiled?.path ?? childMeta?.path ?? childSeed.path;
     const childStackId = childSeed.stackId ?? childNode.getId();
@@ -1258,10 +1361,14 @@ export class Router {
     };
     this.applyHistoryChange('push', childItem);
     if (childSeed.routeId) {
-      this.addChildNodeSeedsToHistory(childSeed.routeId);
+      this.addChildNodeSeedsToHistory(childSeed.routeId, visited);
     }
   }
   matchBaseRoute(pathname, query) {
+    // One-slot cache: uses reference equality for query object
+    if (this.lastMatchedPathname !== null && pathname === this.lastMatchedPathname && query === this.lastMatchedQuery) {
+      return this.lastMatchedResult ?? undefined;
+    }
     this.log('matchBaseRoute', {
       pathname,
       query
@@ -1405,17 +1512,26 @@ export class Router {
     } else {
       this.log('matchBaseRoute no match');
     }
-    return best?.route;
+    const result = best?.route;
+    this.lastMatchedPathname = pathname;
+    this.lastMatchedQuery = query;
+    this.lastMatchedResult = result ?? null;
+    return result;
   }
   generateKey() {
     return `route-${nanoid()}`;
   }
   parsePath(path) {
+    if (path === this.lastParsedPath && this.lastParsedResult) {
+      return this.lastParsedResult;
+    }
     const parsed = qs.parseUrl(path);
     const result = {
       pathname: parsed.url,
       query: parsed.query
     };
+    this.lastParsedPath = path;
+    this.lastParsedResult = result;
     this.log('parsePath', {
       input: path,
       output: result
@@ -1428,9 +1544,9 @@ export class Router {
     const routerDefaults = this.routerScreenOptions;
     if (!routerDefaults && !stackDefaults && !routeOptions) return undefined;
     const merged = {
+      ...(routerDefaults ?? {}),
       ...(stackDefaults ?? {}),
-      ...(routeOptions ?? {}),
-      ...(routerDefaults ?? {})
+      ...(routeOptions ?? {})
     };
     if (merged.stackPresentation === 'modal' && merged.convertModalToSheetForAndroid && Platform.OS === 'android') {
       merged.stackPresentation = 'sheet';
@@ -1440,16 +1556,20 @@ export class Router {
   findStackById(stackId) {
     return this.stackById.get(stackId);
   }
+  getCompiledRoute(routeId) {
+    return this.compiledRouteById.get(routeId);
+  }
   areShallowEqual(a, b) {
     if (a === b) return true;
-    if (!a || !b) return false;
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
+    const na = a ?? {};
+    const nb = b ?? {};
+    const aKeys = Object.keys(na);
+    const bKeys = Object.keys(nb);
     if (aKeys.length !== bKeys.length) return false;
     for (const k of aKeys) {
-      if (!(k in b)) return false;
-      const av = a[k];
-      const bv = b[k];
+      if (!(k in nb)) return false;
+      const av = na[k];
+      const bv = nb[k];
       if (av === bv) continue;
       const aArr = Array.isArray(av);
       const bArr = Array.isArray(bv);
@@ -1560,7 +1680,9 @@ export class Router {
     if (changed) {
       try {
         g.history?.replaceState(next, '', g.location?.href);
-      } catch {}
+      } catch (e) {
+        if (this.debugEnabled) console.warn('[Router] ensureHistoryIndex replaceState failed', e);
+      }
     }
   }
   getRouterPathFromHistory() {
@@ -1628,6 +1750,10 @@ export class Router {
   }
   replaceUrlSilently(to) {
     if (!this.isWebEnv()) return;
+    if (this.suppressHistorySyncCount > 10) {
+      console.warn('[Router] suppressHistorySyncCount reset from', this.suppressHistorySyncCount);
+      this.suppressHistorySyncCount = 0;
+    }
     this.suppressHistorySyncCount += 1;
     this.replaceUrl(to, {
       syncWithUrl: true
@@ -1672,6 +1798,12 @@ export class Router {
     g[key] = true;
   }
   setupBrowserHistory() {
+    // Abort previous listeners in case setupBrowserHistory is called twice
+    this.abortController?.abort();
+    this.abortController = new AbortController();
+    const {
+      signal
+    } = this.abortController;
     const g = globalThis;
     const gAny = g;
     const activeKey = Symbol.for('sigmela_router_active_instance');
@@ -1747,13 +1879,28 @@ export class Router {
         this.lastBrowserIndex = idx;
       }
     };
-    g.addEventListener?.('pushState', onHistory);
-    g.addEventListener?.('replaceState', onHistory);
-    g.addEventListener?.('popstate', onHistory);
+    g.addEventListener?.('pushState', onHistory, {
+      signal
+    });
+    g.addEventListener?.('replaceState', onHistory, {
+      signal
+    });
+    g.addEventListener?.('popstate', onHistory, {
+      signal
+    });
+  }
+  destroyed = false;
+  destroy() {
+    this.destroyed = true;
+    this.abortController?.abort();
+    this.listeners.clear();
+    this.stackListeners.clear();
+    this.activeRouteListeners.clear();
+    this.rootListeners.clear();
   }
   syncUrlAfterInternalPop(popped) {
     if (!this.isWebEnv()) return;
-    const compiled = this.registry.find(r => r.routeId === popped.routeId);
+    const compiled = this.getCompiledRoute(popped.routeId);
     const isQueryRoute = compiled && compiled.queryPattern && Object.keys(compiled.queryPattern).length > 0;
     if (isQueryRoute) {
       const currentUrl = this.getCurrentUrl();
@@ -1803,6 +1950,7 @@ export class Router {
           const stackHistory = this.getStackHistory(sid);
           if (stackHistory.length > 0) {
             const top = stackHistory[stackHistory.length - 1];
+            if (!top) return null;
             const isModalOrSheet = top.options?.stackPresentation === 'modal' || top.options?.stackPresentation === 'sheet';
             if (stackHistory.length > 1 || isModalOrSheet) {
               if (top.options?.stackPresentation === 'sheet') {
@@ -1845,6 +1993,7 @@ export class Router {
       }
     }
     const top = stackHistory[stackHistory.length - 1];
+    if (!top) return null;
     this.applyHistoryChange('pop', top);
     return top;
   }
@@ -1865,6 +2014,8 @@ export class Router {
     if (!deepest || isDeepestOverlay && !baseRoute) {
       if (__DEV__) {
         console.warn(`[Router] parse: no base route found for "${pathname}", seeding initial history`);
+      } else {
+        console.warn(`[Router] No base route found for "${pathname}"`);
       }
       this.seedInitialHistory();
       this.recomputeActiveRoute();
@@ -1941,14 +2092,14 @@ export class Router {
     }
     if (items.length > 0) {
       const lastItem = items[items.length - 1];
-      const lastItemCompiled = lastItem ? this.registry.find(r => r.routeId === lastItem.routeId) : undefined;
+      const lastItemCompiled = lastItem ? this.getCompiledRoute(lastItem.routeId) : undefined;
       const isLastItemOverlay = lastItem && lastItemCompiled && lastItemCompiled.queryPattern && Object.keys(lastItemCompiled.queryPattern).length > 0;
       const finalRouteId = isLastItemOverlay && items.length > 1 ? items[items.length - 2]?.routeId : lastItem?.routeId;
       const searchStartIndex = isLastItemOverlay ? items.length - 2 : items.length - 1;
       for (let i = searchStartIndex; i >= 0; i--) {
         const item = items[i];
         if (item && item.routeId) {
-          const compiled = this.registry.find(r => r.routeId === item.routeId);
+          const compiled = this.getCompiledRoute(item.routeId);
           if (compiled && compiled.childNode) {
             this.addChildNodeSeedsToItems(item.routeId, items, finalRouteId);
             // Don't break: we may have multiple nested containers (e.g. TabBar -> SplitView).
@@ -1967,6 +2118,8 @@ export class Router {
     if (!items.length) {
       if (__DEV__) {
         console.warn('[Router] parse: no items built for URL, seeding initial history');
+      } else {
+        console.warn('[Router] No items built for URL, seeding initial history');
       }
       this.seedInitialHistory();
       this.recomputeActiveRoute();
@@ -1980,7 +2133,8 @@ export class Router {
     this.setState({
       history: items
     });
-    this.stackListeners.forEach(set => this.emit(set));
+    // setState -> updateStackHistories already emits to changed stacks
+
     this.recomputeActiveRoute();
     this.emit(this.listeners);
   }

package/lib/module/RouterContext.js

@@ -12,7 +12,7 @@ export const useRouter = () => {
 };
 export const useCurrentRoute = () => {
   const router = useRouter();
-  const subscribe = React.useCallback(cb => router.subscribe(cb), [router]);
+  const subscribe = React.useCallback(cb => router.subscribeActiveRoute(cb), [router]);
   const get = React.useCallback(() => router.getActiveRoute(), [router]);
   return React.useSyncExternalStore(subscribe, get, get);
 };