@real-router/core 0.45.0 → 0.45.1

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

@@ -1,221 +0,0 @@
-import { handleGuardError } from "./errorHandling";
-import { errorCodes } from "../../../constants";
-import { RouterError } from "../../../RouterError";
-
-import type { GuardFn, State } from "@real-router/types";
-
-async function resolveAsyncGuard(
-  promise: Promise<boolean>,
-  errorCode: string,
-  segment: string,
-): Promise<void> {
-  let result: boolean;
-
-  try {
-    result = await promise;
-  } catch (error: unknown) {
-    handleGuardError(error, errorCode, segment);
-
-    return; // unreachable — handleGuardError returns never
-  }
-
-  if (!result) {
-    throw new RouterError(errorCode, { segment });
-  }
-}
-
-async function resolveRemainingGuards( // NOSONAR -- params kept flat to avoid object allocation on hot path
-  guards: Map<string, GuardFn>,
-  segments: string[],
-  errorCode: string,
-  toState: State,
-  fromState: State | undefined,
-  signal: AbortSignal | undefined,
-  isActive: () => boolean,
-  startIndex: number,
-  firstResult: Promise<boolean>,
-  firstSegment: string,
-): Promise<void> {
-  await resolveAsyncGuard(firstResult, errorCode, firstSegment);
-
-  for (let i = startIndex; i < segments.length; i++) {
-    if (!isActive()) {
-      throw new RouterError(errorCodes.TRANSITION_CANCELLED);
-    }
-
-    const segment = segments[i];
-    const guardFn = guards.get(segment);
-
-    if (!guardFn) {
-      continue;
-    }
-
-    let guardResult: boolean | Promise<boolean> = false;
-
-    try {
-      guardResult = guardFn(toState, fromState, signal);
-    } catch (error: unknown) {
-      handleGuardError(error, errorCode, segment);
-    }
-
-    if (guardResult instanceof Promise) {
-      await resolveAsyncGuard(guardResult, errorCode, segment);
-      continue;
-    }
-
-    if (!guardResult) {
-      throw new RouterError(errorCode, { segment });
-    }
-  }
-}
-
-async function finishAsyncPipeline( // NOSONAR
-  deactivateCompletion: Promise<void>,
-  activateGuards: Map<string, GuardFn>,
-  toActivate: string[],
-  shouldActivate: boolean,
-  toState: State,
-  fromState: State | undefined,
-  signal: AbortSignal,
-  isActive: () => boolean,
-  emitLeaveApprove: () => void,
-): Promise<void> {
-  await deactivateCompletion;
-
-  if (!isActive()) {
-    throw new RouterError(errorCodes.TRANSITION_CANCELLED);
-  }
-
-  emitLeaveApprove();
-
-  if (shouldActivate) {
-    const pending = runGuards(
-      activateGuards,
-      toActivate,
-      errorCodes.CANNOT_ACTIVATE,
-      toState,
-      fromState,
-      signal,
-      isActive,
-    );
-
-    if (pending !== undefined) {
-      await pending;
-    }
-
-    if (!isActive()) {
-      throw new RouterError(errorCodes.TRANSITION_CANCELLED);
-    }
-  }
-}
-
-export function executeGuardPipeline( // NOSONAR
-  deactivateGuards: Map<string, GuardFn>,
-  activateGuards: Map<string, GuardFn>,
-  toDeactivate: string[],
-  toActivate: string[],
-  shouldDeactivate: boolean,
-  shouldActivate: boolean,
-  toState: State,
-  fromState: State | undefined,
-  signal: AbortSignal,
-  isActive: () => boolean,
-  emitLeaveApprove: () => void,
-): Promise<void> | undefined {
-  if (shouldDeactivate) {
-    const pending = runGuards(
-      deactivateGuards,
-      toDeactivate,
-      errorCodes.CANNOT_DEACTIVATE,
-      toState,
-      fromState,
-      signal,
-      isActive,
-    );
-
-    if (pending !== undefined) {
-      return finishAsyncPipeline(
-        pending,
-        activateGuards,
-        toActivate,
-        shouldActivate,
-        toState,
-        fromState,
-        signal,
-        isActive,
-        emitLeaveApprove,
-      );
-    }
-  }
-
-  if (!isActive()) {
-    throw new RouterError(errorCodes.TRANSITION_CANCELLED);
-  }
-
-  emitLeaveApprove();
-
-  if (shouldActivate) {
-    return runGuards(
-      activateGuards,
-      toActivate,
-      errorCodes.CANNOT_ACTIVATE,
-      toState,
-      fromState,
-      signal,
-      isActive,
-    );
-  }
-
-  return undefined;
-}
-
-function runGuards(
-  guards: Map<string, GuardFn>,
-  segments: string[],
-  errorCode: string,
-  toState: State,
-  fromState: State | undefined,
-  signal: AbortSignal | undefined,
-  isActive: () => boolean,
-): Promise<void> | undefined {
-  for (const [i, segment] of segments.entries()) {
-    if (!isActive()) {
-      throw new RouterError(errorCodes.TRANSITION_CANCELLED);
-    }
-
-    const guardFn = guards.get(segment);
-
-    if (!guardFn) {
-      continue;
-    }
-
-    let guardResult: boolean | Promise<boolean> = false;
-
-    try {
-      guardResult = guardFn(toState, fromState, signal);
-    } catch (error: unknown) {
-      handleGuardError(error, errorCode, segment);
-    }
-
-    if (guardResult instanceof Promise) {
-      return resolveRemainingGuards(
-        guards,
-        segments,
-        errorCode,
-        toState,
-        fromState,
-        signal,
-        isActive,
-        i + 1,
-        guardResult,
-        segment,
-      );
-    }
-
-    if (!guardResult) {
-      throw new RouterError(errorCode, { segment });
-    }
-  }
-
-  return undefined;
-}

package/src/namespaces/NavigationNamespace/types.ts

@@ -1,100 +0,0 @@
-// packages/core/src/namespaces/NavigationNamespace/types.ts
-
-import type {
-  GuardFn,
-  NavigationOptions,
-  Options,
-  Params,
-  State,
-} from "@real-router/types";
-
-export interface NavigationContext {
-  toState: State;
-  fromState: State | undefined;
-  opts: NavigationOptions;
-  toDeactivate: string[];
-  toActivate: string[];
-  intersection: string;
-  canDeactivateFunctions: Map<string, GuardFn>;
-}
-
-/**
- * Dependencies injected into NavigationNamespace.
- *
- * These are function references from other namespaces/facade,
- * avoiding the need to pass the entire Router object.
- **/
-export interface NavigationDependencies {
-  /** Get router options */
-  getOptions: () => Options;
-
-  /** Check if route exists */
-  hasRoute: (name: string) => boolean;
-
-  /** Get current state */
-  getState: () => State | undefined;
-
-  /** Set router state */
-  setState: (state: State) => void;
-
-  /** Build complete navigate state: forwardState + route check + buildPath + makeState in one step */
-  buildNavigateState: (
-    routeName: string,
-    routeParams: Params,
-  ) => State | undefined;
-
-  /** Resolve defaultRoute and defaultParams options (static value or callback) */
-  resolveDefault: () => { route: string; params: Params };
-
-  /** Start transition and send NAVIGATE event to routerFSM */
-  startTransition: (toState: State, fromState: State | undefined) => void;
-
-  /** Cancel navigation if transition is running */
-  cancelNavigation: () => void;
-
-  /** Send COMPLETE event to routerFSM */
-  sendTransitionDone: (
-    state: State,
-    fromState: State | undefined,
-    opts: NavigationOptions,
-  ) => void;
-
-  /** Send FAIL event to routerFSM */
-  sendTransitionFail: (
-    toState: State,
-    fromState: State | undefined,
-    error: unknown,
-  ) => void;
-
-  /** Emit TRANSITION_ERROR event to listeners */
-  emitTransitionError: (
-    toState: State | undefined,
-    fromState: State | undefined,
-    error: unknown,
-  ) => void;
-
-  /** Emit TRANSITION_SUCCESS event to listeners (without FSM transition) */
-  emitTransitionSuccess: (
-    toState: State,
-    fromState?: State,
-    opts?: NavigationOptions,
-  ) => void;
-
-  /** Send LEAVE_APPROVE event to routerFSM and emit to listeners */
-  sendLeaveApprove: (toState: State, fromState: State | undefined) => void;
-
-  /** Check if navigation can begin (router is started) */
-  canNavigate: () => boolean;
-
-  /** Get lifecycle functions (canDeactivate, canActivate maps) */
-  getLifecycleFunctions: () => [Map<string, GuardFn>, Map<string, GuardFn>];
-
-  /** Check if router is active (for cancellation check on stop()) */
-  isActive: () => boolean;
-
-  /** Check if a transition is currently in progress */
-  isTransitioning: () => boolean;
-
-  /** Clear canDeactivate guard for a route */
-  clearCanDeactivate: (name: string) => void;
-}

package/src/namespaces/OptionsNamespace/OptionsNamespace.ts

@@ -1,28 +0,0 @@
-// packages/core/src/namespaces/OptionsNamespace/OptionsNamespace.ts
-
-import { defaultOptions } from "./constants";
-import { deepFreeze } from "./helpers";
-import { validateOptionsIsObject } from "./validators";
-
-import type { Options } from "@real-router/types";
-
-export class OptionsNamespace {
-  readonly #options: Readonly<Options>;
-
-  constructor(initialOptions: Partial<Options> = {}) {
-    this.#options = deepFreeze({
-      ...defaultOptions,
-      ...initialOptions,
-    });
-  }
-
-  static validateOptionsIsObject(
-    options: unknown,
-  ): asserts options is Record<string, unknown> {
-    validateOptionsIsObject(options);
-  }
-
-  get(): Readonly<Options> {
-    return this.#options;
-  }
-}

package/src/namespaces/OptionsNamespace/constants.ts

@@ -1,19 +0,0 @@
-// packages/core/src/namespaces/OptionsNamespace/constants.ts
-
-import { DEFAULT_QUERY_PARAMS } from "route-tree";
-
-import type { Options } from "@real-router/types";
-
-/**
- * Default options for the router.
- */
-export const defaultOptions: Options = {
-  defaultRoute: "",
-  defaultParams: {},
-  trailingSlash: "preserve",
-  queryParamsMode: "loose",
-  queryParams: DEFAULT_QUERY_PARAMS,
-  urlParamsEncoding: "default",
-  allowNotFound: true,
-  rewritePathOnMatch: true,
-} satisfies Options;

package/src/namespaces/OptionsNamespace/helpers.ts

@@ -1,50 +0,0 @@
-// packages/core/src/namespaces/OptionsNamespace/helpers.ts
-
-import type { Options, Params } from "@real-router/types";
-
-/**
- * Recursively freezes an object and all nested objects.
- * Only freezes plain objects, not primitives or special objects.
- */
-export function deepFreeze<T extends object>(obj: T): Readonly<T> {
-  Object.freeze(obj);
-
-  for (const key of Object.keys(obj)) {
-    const value = (obj as Record<string, unknown>)[key];
-
-    if (value && typeof value === "object" && value.constructor === Object) {
-      deepFreeze(value);
-    }
-  }
-
-  return obj;
-}
-
-/**
- * Resolves an option value that can be static or a callback.
- * If the value is a function, calls it with getDependency and returns the result.
- * Otherwise, returns the value as-is.
- */
-export function resolveOption(
-  value: Options["defaultRoute"],
-  getDependency: (name: string) => unknown,
-): string;
-
-export function resolveOption(
-  value: Options["defaultParams"],
-  getDependency: (name: string) => unknown,
-): Params;
-
-export function resolveOption(
-  value: Options["defaultRoute"] | Options["defaultParams"],
-  getDependency: (name: string) => unknown,
-): string | Params {
-  if (typeof value === "function") {
-    // Runtime getDependency is (name: string) => unknown, but DefaultRouteCallback<object>
-    // expects <K extends keyof object>(name: K) => object[K] where keyof object = never.
-    // Cast needed to bridge generic constraint mismatch.
-    return value(getDependency as never);
-  }
-
-  return value;
-}

package/src/namespaces/OptionsNamespace/index.ts

@@ -1,7 +0,0 @@
-// packages/core/src/namespaces/OptionsNamespace/index.ts
-
-export { OptionsNamespace } from "./OptionsNamespace";
-
-export { defaultOptions } from "./constants";
-
-export { deepFreeze, resolveOption } from "./helpers";

package/src/namespaces/OptionsNamespace/validators.ts

@@ -1,13 +0,0 @@
-// packages/core/src/namespaces/OptionsNamespace/validators.ts
-
-/**
- * Minimal crash guard for options.
- * Full DX validation moved to @real-router/validation-plugin (retrospective pattern).
- */
-export function validateOptionsIsObject(
-  options: unknown,
-): asserts options is Record<string, unknown> {
-  if (!options || typeof options !== "object" || Array.isArray(options)) {
-    throw new TypeError("[router.constructor] options must be a plain object");
-  }
-}