@real-router/core 0.24.0 → 0.25.1

package/src/namespaces/NavigationNamespace/transition/index.ts

@@ -1,10 +1,9 @@
-// packages/real-router/modules/transition/index.ts
+// packages/core/src/namespaces/NavigationNamespace/transition/index.ts
 
 import { executeLifecycleHooks } from "./executeLifecycleHooks";
-import { executeMiddleware } from "./executeMiddleware";
 import { constants, errorCodes } from "../../../constants";
 import { RouterError } from "../../../RouterError";
-import { getTransitionPath, nameToIDs } from "../../../transitionPath";
+import { getTransitionPath } from "../../../transitionPath";
 
 import type { TransitionDependencies, TransitionOutput } from "../types";
 import type { NavigationOptions, State } from "@real-router/types";
@@ -18,7 +17,6 @@ export async function transition(
   // We're caching the necessary data
   const [canDeactivateFunctions, canActivateFunctions] =
     deps.getLifecycleFunctions();
-  const middlewareFunctions = deps.getMiddlewareFunctions();
   const isUnknownRoute = toState.name === constants.UNKNOWN_ROUTE;
 
   // State management functions
@@ -34,9 +32,6 @@ export async function transition(
   const shouldDeactivate =
     fromState && !opts.forceDeactivate && toDeactivate.length > 0;
   const shouldActivate = !isUnknownRoute && toActivate.length > 0;
-  const shouldRunMiddleware = middlewareFunctions.length > 0;
-
-  let currentState = toState;
 
   if (shouldDeactivate) {
     await executeLifecycleHooks(
@@ -68,35 +63,19 @@ export async function transition(
     throw new RouterError(errorCodes.TRANSITION_CANCELLED);
   }
 
-  if (shouldRunMiddleware) {
-    currentState = await executeMiddleware(
-      middlewareFunctions,
-      currentState,
-      fromState,
-      isCancelled,
-    );
-  }
-
-  if (isCancelled()) {
-    throw new RouterError(errorCodes.TRANSITION_CANCELLED);
-  }
-
   // Automatic cleaning of inactive segments
   if (fromState) {
-    const activeSegments = nameToIDs(toState.name);
-    const previousActiveSegments = nameToIDs(fromState.name);
-
-    for (const name of previousActiveSegments) {
-      if (!activeSegments.includes(name) && canDeactivateFunctions.has(name)) {
+    for (const name of toDeactivate) {
+      if (!toActivate.includes(name) && canDeactivateFunctions.has(name)) {
         deps.clearCanDeactivate(name);
       }
     }
   }
 
   return {
-    state: currentState,
+    state: toState,
     meta: {
-      phase: "middleware",
+      phase: "activating",
       segments: {
         deactivated: toDeactivate,
         activated: toActivate,

package/src/namespaces/NavigationNamespace/types.ts

@@ -3,7 +3,6 @@
 import type { BuildStateResultWithSegments } from "../../types";
 import type {
   GuardFn,
-  Middleware,
   NavigationOptions,
   Options,
   Params,
@@ -112,9 +111,6 @@ export interface TransitionDependencies {
   /** Get lifecycle functions (canDeactivate, canActivate maps) */
   getLifecycleFunctions: () => [Map<string, GuardFn>, Map<string, GuardFn>];
 
-  /** Get middleware functions array */
-  getMiddlewareFunctions: () => Middleware[];
-
   /** Check if router is active (for cancellation check on stop()) */
   isActive: () => boolean;
 

package/src/namespaces/PluginsNamespace/PluginsNamespace.ts

@@ -222,8 +222,8 @@ export class PluginsNamespace<
   /**
    * Disposes all registered plugins by running their teardown callbacks
    * and removing event listener subscriptions.
-   * Unlike {@link MiddlewareNamespace.clearAll}, active disposal is required —
-   * plugins have an active lifecycle (event subscriptions, teardown hooks).
+   * Active disposal is required because plugins have an active lifecycle
+   * (event subscriptions, teardown hooks).
    * Named "dispose" (not "clear") because there is active cleanup to perform.
    */
   disposeAll(): void {

package/src/namespaces/RouteLifecycleNamespace/validators.ts

@@ -59,7 +59,7 @@ export function validateHandlerLimit(
     throw new Error(
       `[router.${methodName}] Lifecycle handler limit exceeded (${maxLifecycleHandlers}). ` +
         `This indicates too many routes with individual handlers. ` +
-        `Consider using middleware for cross-cutting concerns.`,
+        `Consider using plugins for cross-cutting concerns.`,
     );
   }
 }

package/src/namespaces/RoutesNamespace/RoutesNamespace.ts

@@ -77,9 +77,14 @@ export class RoutesNamespace<
 
   readonly #definitions: RouteDefinition[] = [];
   readonly #config: RouteConfig = createEmptyConfig();
-  readonly #resolvedForwardMap: Record<string, string> = Object.create(
+  #resolvedForwardMap: Record<string, string> = Object.create(null) as Record<
+    string,
+    string
+  >;
+
+  #routeCustomFields: Record<string, Record<string, unknown>> = Object.create(
     null,
-  ) as Record<string, string>;
+  ) as Record<string, Record<string, unknown>>;
 
   // Pending canActivate handlers that need to be registered after router is set
   // Key: route name, Value: canActivate factory
@@ -346,6 +351,18 @@ export class RoutesNamespace<
     return this.#enrichRoute(definition, name);
   }
 
+  getRouteConfig(name: string): Record<string, unknown> | undefined {
+    if (!this.#matcher.hasRoute(name)) {
+      return undefined;
+    }
+
+    return this.#routeCustomFields[name];
+  }
+
+  getRouteCustomFields(): Record<string, Record<string, unknown>> {
+    return this.#routeCustomFields;
+  }
+
   /**
    * Adds one or more routes to the router.
    * Input already validated by facade (properties and state-dependent checks).
@@ -473,31 +490,15 @@ export class RoutesNamespace<
   clearRoutes(): void {
     this.#definitions.length = 0;
 
-    // Clear all config entries
-    for (const key in this.#config.decoders) {
-      delete this.#config.decoders[key];
-    }
-
-    for (const key in this.#config.encoders) {
-      delete this.#config.encoders[key];
-    }
-
-    for (const key in this.#config.defaultParams) {
-      delete this.#config.defaultParams[key];
-    }
-
-    for (const key in this.#config.forwardMap) {
-      delete this.#config.forwardMap[key];
-    }
-
-    for (const key in this.#config.forwardFnMap) {
-      delete this.#config.forwardFnMap[key];
-    }
+    // Reset config to empty null-prototype objects
+    Object.assign(this.#config, createEmptyConfig());
 
     // Clear forward cache
-    for (const key in this.#resolvedForwardMap) {
-      delete this.#resolvedForwardMap[key];
-    }
+    this.#resolvedForwardMap = Object.create(null) as Record<string, string>;
+    this.#routeCustomFields = Object.create(null) as Record<
+      string,
+      Record<string, unknown>
+    >;
 
     // Rebuild empty tree
     this.#rebuildTree();
@@ -872,6 +873,7 @@ export class RoutesNamespace<
   applyClonedConfig(
     config: RouteConfig,
     resolvedForwardMap: Record<string, string>,
+    routeCustomFields: Record<string, Record<string, unknown>>,
   ): void {
     Object.assign(this.#config.decoders, config.decoders);
     Object.assign(this.#config.encoders, config.encoders);
@@ -879,6 +881,7 @@ export class RoutesNamespace<
     Object.assign(this.#config.forwardMap, config.forwardMap);
     Object.assign(this.#config.forwardFnMap, config.forwardFnMap);
     this.setResolvedForwardMap({ ...resolvedForwardMap });
+    Object.assign(this.#routeCustomFields, routeCustomFields);
   }
 
   /**
@@ -1219,9 +1222,7 @@ export class RoutesNamespace<
 
   #validateAndCacheForwardMap(): void {
     // Clear existing cache
-    for (const key in this.#resolvedForwardMap) {
-      delete this.#resolvedForwardMap[key];
-    }
+    this.#resolvedForwardMap = Object.create(null) as Record<string, string>;
 
     // Resolve all chains
     for (const fromRoute of Object.keys(this.#config.forwardMap)) {
@@ -1238,9 +1239,7 @@ export class RoutesNamespace<
    */
   #cacheForwardMap(): void {
     // Clear existing cache
-    for (const key in this.#resolvedForwardMap) {
-      delete this.#resolvedForwardMap[key];
-    }
+    this.#resolvedForwardMap = Object.create(null) as Record<string, string>;
 
     // Resolve chains without validation
     for (const fromRoute of Object.keys(this.#config.forwardMap)) {
@@ -1263,6 +1262,7 @@ export class RoutesNamespace<
     clearConfigEntries(this.#config.defaultParams, shouldClear);
     clearConfigEntries(this.#config.forwardMap, shouldClear);
     clearConfigEntries(this.#config.forwardFnMap, shouldClear);
+    clearConfigEntries(this.#routeCustomFields, shouldClear);
 
     // Clear forwardMap entries pointing TO deleted route
     clearConfigEntries(this.#config.forwardMap, (key) =>
@@ -1305,6 +1305,25 @@ export class RoutesNamespace<
     route: Route<Dependencies>,
     fullName: string,
   ): void {
+    const standardKeys = new Set([
+      "name",
+      "path",
+      "children",
+      "canActivate",
+      "canDeactivate",
+      "forwardTo",
+      "encodeParams",
+      "decodeParams",
+      "defaultParams",
+    ]);
+    const customFields = Object.fromEntries(
+      Object.entries(route).filter(([k]) => !standardKeys.has(k)),
+    );
+
+    if (Object.keys(customFields).length > 0) {
+      this.#routeCustomFields[fullName] = customFields;
+    }
+
     // Register canActivate via deps.canActivate (allows tests to spy on router.canActivate)
     if (route.canActivate) {
       // Note: Uses #depsStore directly because this method is called from constructor

package/src/namespaces/RoutesNamespace/stateBuilder.ts

@@ -1,4 +1,4 @@
-// packages/real-router/modules/core/stateBuilder.ts
+// packages/core/src/namespaces/RoutesNamespace/stateBuilder.ts
 
 /**
  * State Builder Utilities.

package/src/namespaces/index.ts

@@ -12,8 +12,6 @@ export {
 
 export { StateNamespace } from "./StateNamespace";
 
-export { MiddlewareNamespace } from "./MiddlewareNamespace";
-
 export {
   PluginsNamespace,
   EVENTS_MAP,

package/src/transitionPath.ts

@@ -1,6 +1,6 @@
-// packages/real-router/modules/transitionPath.ts
+// packages/core/src/transitionPath.ts
 
-import type { Params, State } from "@real-router/types";
+import type { State } from "@real-router/types";
 
 /**
  * Parameters extracted from a route segment.
@@ -99,19 +99,7 @@ function extractSegmentParams(name: string, state: State): SegmentParams {
 
   const result: SegmentParams = {};
 
-  for (const key in keys as Params) {
-    // Skip inherited properties
-    if (!Object.hasOwn(keys, key)) {
-      continue;
-    }
-
-    // Skip undefined values for consistent behavior (treat { key: undefined } same as missing key)
-    // Edge case: can appear from manual State creation or object merging
-    // @ts-expect-error Params type doesn't allow undefined, but it can appear at runtime
-    if (keys[key] === undefined) {
-      continue;
-    }
-
+  for (const key of Object.keys(keys)) {
     const value = state.params[key];
 
     // Skip null/undefined values
@@ -166,15 +154,9 @@ function pointOfDifference(
     const toParams = extractSegmentParams(toSegment, toState);
     const fromParams = extractSegmentParams(fromSegment, fromState);
 
-    // Fast check: different number of parameters
+    // Compare parameter values
     const toKeys = Object.keys(toParams);
-    const fromKeys = Object.keys(fromParams);
 
-    if (toKeys.length !== fromKeys.length) {
-      return i;
-    }
-
-    // Detailed check: compare parameter values
     for (const key of toKeys) {
       if (toParams[key] !== fromParams[key]) {
         return i;
@@ -384,24 +366,6 @@ export function getTransitionPath(
     };
   }
 
-  // ===== FAST PATH 4: Same routes with empty meta.params =====
-  // If both have empty meta.params {}, no parameter checking needed
-  if (toState.name === fromState.name && toHasMeta && fromHasMeta) {
-    const toParamsEmpty =
-      toState.meta && Object.keys(toState.meta.params).length === 0;
-    const fromParamsEmpty =
-      fromState.meta && Object.keys(fromState.meta.params).length === 0;
-
-    if (toParamsEmpty && fromParamsEmpty) {
-      // Both have empty params - no transition needed
-      return {
-        intersection: toState.name,
-        toActivate: [],
-        toDeactivate: [],
-      };
-    }
-  }
-
   // ===== STANDARD PATH: Routes with parameters =====
   // Use original algorithm for complex cases with parameters
   const toStateIds = nameToIDs(toState.name);

package/src/typeGuards.ts

@@ -1,4 +1,4 @@
-// packages/real-router/modules/typeGuards.ts
+// packages/core/src/typeGuards.ts
 
 /**
  * Re-export common type guards from centralized type-guards package

package/src/types.ts

@@ -16,7 +16,6 @@ import type {
   ForwardToCallback,
   GuardFn,
   LimitsConfig,
-  Middleware,
   NavigationOptions,
   Params,
   Plugin,
@@ -183,17 +182,6 @@ export type GuardFnFactory<
   getDependency: <K extends keyof Dependencies>(key: K) => Dependencies[K],
 ) => GuardFn;
 
-/**
- * Factory function for creating middleware.
- * Receives the router instance and a dependency getter.
- */
-export type MiddlewareFactory<
-  Dependencies extends DefaultDependencies = DefaultDependencies,
-> = (
-  router: Router<Dependencies>,
-  getDependency: <K extends keyof Dependencies>(key: K) => Dependencies[K],
-) => Middleware;
-
 /**
  * Factory function for creating plugins.
  * Receives the router instance and a dependency getter.

package/src/wiring/RouterWiringBuilder.ts

@@ -2,7 +2,6 @@
 
 import type { EventBusNamespace } from "../namespaces";
 import type { WiringOptions } from "./types";
-import type { MiddlewareDependencies } from "../namespaces/MiddlewareNamespace";
 import type {
   NavigationDependencies,
   TransitionDependencies,
@@ -23,7 +22,6 @@ export class RouterWiringBuilder<
   private readonly state: WiringOptions<Dependencies>["state"];
   private readonly routes: WiringOptions<Dependencies>["routes"];
   private readonly routeLifecycle: WiringOptions<Dependencies>["routeLifecycle"];
-  private readonly middleware: WiringOptions<Dependencies>["middleware"];
   private readonly plugins: WiringOptions<Dependencies>["plugins"];
   private readonly navigation: WiringOptions<Dependencies>["navigation"];
   private readonly lifecycle: WiringOptions<Dependencies>["lifecycle"];
@@ -38,7 +36,6 @@ export class RouterWiringBuilder<
     this.state = wiringOptions.state;
     this.routes = wiringOptions.routes;
     this.routeLifecycle = wiringOptions.routeLifecycle;
-    this.middleware = wiringOptions.middleware;
     this.plugins = wiringOptions.plugins;
     this.navigation = wiringOptions.navigation;
     this.lifecycle = wiringOptions.lifecycle;
@@ -49,7 +46,6 @@ export class RouterWiringBuilder<
   wireLimits(): void {
     this.dependencies.setLimits(this.limits);
     this.plugins.setLimits(this.limits);
-    this.middleware.setLimits(this.limits);
     this.eventBus.setLimits({
       maxListeners: this.limits.maxListeners,
       warnListeners: this.limits.warnListeners,
@@ -90,17 +86,6 @@ export class RouterWiringBuilder<
     this.routes.setLifecycleNamespace(this.routeLifecycle);
   }
 
-  wireMiddlewareDeps(): void {
-    this.middleware.setRouter(this.router);
-
-    const middlewareDeps: MiddlewareDependencies<Dependencies> = {
-      getDependency: <K extends keyof Dependencies>(dependencyName: K) =>
-        this.dependencies.get(dependencyName),
-    };
-
-    this.middleware.setDependencies(middlewareDeps);
-  }
-
   wirePluginsDeps(): void {
     this.plugins.setRouter(this.router);
 
@@ -166,7 +151,6 @@ export class RouterWiringBuilder<
 
     const transitionDeps: TransitionDependencies = {
       getLifecycleFunctions: () => this.routeLifecycle.getFunctions(),
-      getMiddlewareFunctions: () => this.middleware.getFunctions(),
       isActive: () => this.router.isActive(),
       isTransitioning: () => this.eventBus.isTransitioning(),
       clearCanDeactivate: (name) => {
@@ -217,10 +201,10 @@ export class RouterWiringBuilder<
         dependencies: this.dependencies.getAll(),
         canDeactivateFactories,
         canActivateFactories,
-        middlewareFactories: this.middleware.getFactories(),
         pluginFactories: this.plugins.getAll(),
         routeConfig: this.routes.getConfig(),
         resolvedForwardMap: this.routes.getResolvedForwardMap(),
+        routeCustomFields: this.routes.getRouteCustomFields(),
       };
     });
   }

package/src/wiring/types.ts

@@ -4,7 +4,6 @@ import type {
   CloneNamespace,
   DependenciesNamespace,
   EventBusNamespace,
-  MiddlewareNamespace,
   NavigationNamespace,
   OptionsNamespace,
   PluginsNamespace,
@@ -38,8 +37,6 @@ export interface WiringOptions<Dependencies extends DefaultDependencies> {
   routes: RoutesNamespace<Dependencies>;
   /** Route lifecycle namespace (canActivate/canDeactivate guards) */
   routeLifecycle: RouteLifecycleNamespace<Dependencies>;
-  /** Middleware namespace */
-  middleware: MiddlewareNamespace<Dependencies>;
   /** Plugins namespace */
   plugins: PluginsNamespace<Dependencies>;
   /** Navigation namespace */

package/src/wiring/wireRouter.ts

@@ -19,7 +19,6 @@ export function wireRouter<Dependencies extends DefaultDependencies>(
   builder.wireLimits();
   builder.wireRouteLifecycleDeps();
   builder.wireRoutesDeps();
-  builder.wireMiddlewareDeps();
   builder.wirePluginsDeps();
   builder.wireNavigationDeps();
   builder.wireLifecycleDeps();