@real-router/core 0.26.0 → 0.28.0

package/src/namespaces/RouteLifecycleNamespace/RouteLifecycleNamespace.ts

@@ -45,6 +45,8 @@ export class RouteLifecycleNamespace<
   readonly #canActivateFunctions = new Map<string, GuardFn>();
 
   readonly #registering = new Set<string>();
+  readonly #definitionActivateGuardNames = new Set<string>();
+  readonly #definitionDeactivateGuardNames = new Set<string>();
 
   #router!: Router<Dependencies>;
   #deps!: RouteLifecycleDependencies<Dependencies>;
@@ -73,12 +75,19 @@ export class RouteLifecycleNamespace<
    * @param name - Route name (input-validated by facade)
    * @param handler - Guard function or boolean (input-validated by facade)
    * @param skipValidation - True when called during route config building (#noValidate)
+   * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
    */
   addCanActivate(
     name: string,
     handler: GuardFnFactory<Dependencies> | boolean,
     skipValidation: boolean,
+    isFromDefinition = false,
   ): void {
+    if (isFromDefinition) {
+      this.#definitionActivateGuardNames.add(name);
+    } else {
+      this.#definitionActivateGuardNames.delete(name);
+    }
     if (!skipValidation) {
       validateNotRegistering(
         this.#registering.has(name),
@@ -115,12 +124,19 @@ export class RouteLifecycleNamespace<
    * @param name - Route name (input-validated by facade)
    * @param handler - Guard function or boolean (input-validated by facade)
    * @param skipValidation - True when called during route config building (#noValidate)
+   * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
    */
   addCanDeactivate(
     name: string,
     handler: GuardFnFactory<Dependencies> | boolean,
     skipValidation: boolean,
+    isFromDefinition = false,
   ): void {
+    if (isFromDefinition) {
+      this.#definitionDeactivateGuardNames.add(name);
+    } else {
+      this.#definitionDeactivateGuardNames.delete(name);
+    }
     if (!skipValidation) {
       validateNotRegistering(
         this.#registering.has(name),
@@ -159,6 +175,7 @@ export class RouteLifecycleNamespace<
   clearCanActivate(name: string): void {
     this.#canActivateFactories.delete(name);
     this.#canActivateFunctions.delete(name);
+    this.#definitionActivateGuardNames.delete(name);
   }
 
   /**
@@ -170,6 +187,7 @@ export class RouteLifecycleNamespace<
   clearCanDeactivate(name: string): void {
     this.#canDeactivateFactories.delete(name);
     this.#canDeactivateFunctions.delete(name);
+    this.#definitionDeactivateGuardNames.delete(name);
   }
 
   /**
@@ -181,6 +199,26 @@ export class RouteLifecycleNamespace<
     this.#canActivateFunctions.clear();
     this.#canDeactivateFactories.clear();
     this.#canDeactivateFunctions.clear();
+    this.#definitionActivateGuardNames.clear();
+    this.#definitionDeactivateGuardNames.clear();
+  }
+
+  /**
+   * Clears only lifecycle handlers that were registered from route definitions.
+   * Used by HMR to remove definition-sourced guards without touching externally-added guards.
+   */
+  clearDefinitionGuards(): void {
+    for (const name of this.#definitionActivateGuardNames) {
+      this.#canActivateFactories.delete(name);
+      this.#canActivateFunctions.delete(name);
+    }
+    for (const name of this.#definitionDeactivateGuardNames) {
+      this.#canDeactivateFactories.delete(name);
+      this.#canDeactivateFunctions.delete(name);
+    }
+
+    this.#definitionActivateGuardNames.clear();
+    this.#definitionDeactivateGuardNames.clear();
   }
 
   /**

package/src/namespaces/RouterLifecycleNamespace/RouterLifecycleNamespace.ts

@@ -135,6 +135,6 @@ export class RouterLifecycleNamespace {
    * Called only for READY/TRANSITIONING states (facade handles STARTING/IDLE/DISPOSED).
    */
   stop(): void {
-    this.#deps.setState();
+    this.#deps.clearState();
   }
 }

package/src/namespaces/RouterLifecycleNamespace/types.ts

@@ -10,7 +10,7 @@ import type {
 export interface RouterLifecycleDependencies {
   getOptions: () => Options;
   makeNotFoundState: (path: string, options: NavigationOptions) => State;
-  setState: (state?: State) => void;
+  clearState: () => void;
   matchPath: <P extends Params = Params, MP extends Params = Params>(
     path: string,
   ) => State<P, MP> | undefined;

package/src/namespaces/RoutesNamespace/routesStore.ts

@@ -108,6 +108,17 @@ export function rebuildTreeInPlace<
  */
 export function resetStore<
   Dependencies extends DefaultDependencies = DefaultDependencies,
+>(store: RoutesStore<Dependencies>): void {
+  clearRouteData(store);
+  rebuildTreeInPlace(store);
+}
+
+/**
+ * Clears route data without rebuilding the tree.
+ * Used by replace() to avoid double rebuild (clearRouteData + commitTreeChanges).
+ */
+export function clearRouteData<
+  Dependencies extends DefaultDependencies = DefaultDependencies,
 >(store: RoutesStore<Dependencies>): void {
   store.definitions.length = 0;
 
@@ -118,8 +129,6 @@ export function resetStore<
     string,
     Record<string, unknown>
   >;
-
-  rebuildTreeInPlace(store);
 }
 
 // =============================================================================

package/src/wiring/RouterWiringBuilder.ts

@@ -69,10 +69,10 @@ export class RouterWiringBuilder<
   wireRoutesDeps(): void {
     const routesDeps: RoutesDependencies<Dependencies> = {
       addActivateGuard: (name, handler) => {
-        this.routeLifecycle.addCanActivate(name, handler, true);
+        this.routeLifecycle.addCanActivate(name, handler, true, true);
       },
       addDeactivateGuard: (name, handler) => {
-        this.routeLifecycle.addCanDeactivate(name, handler, true);
+        this.routeLifecycle.addCanDeactivate(name, handler, true, true);
       },
       makeState: (name, params, path, meta) =>
         this.state.makeState(name, params, path, meta),
@@ -179,8 +179,8 @@ export class RouterWiringBuilder<
       getOptions: () => this.options.get(),
       makeNotFoundState: (path, options) =>
         this.state.makeNotFoundState(path, options),
-      setState: (state) => {
-        this.state.set(state);
+      clearState: () => {
+        this.state.set(undefined);
       },
       matchPath: (path) => this.routes.matchPath(path, this.options.get()),
       completeStart: () => {