@real-router/core 0.78.0 → 0.79.1

package/dist/cjs/types/RouterValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterValidator.d.ts","names":[],"sources":["../../../src/types/RouterValidator.ts"],"mappings":";;;;;;;;;;UAUiB;;;;EAIf;IACE,wBAAwB;IACxB,wBAAwB;IACxB,4BACE,eACA,iBACA,iBACA;IAEF,+BAA+B;IAC/B,2BACE,eACA,iBACA;IAEF,uBAAuB;IACvB,iBACE,mBACA,eACA;IAEF,0BAA0B;IAC1B,+BAA+B,eAAe;IAC9C,mCAAmC,cAAc;IACjD,sBACE,cACA,kBACA;IAEF,uBAAuB,iBAAiB;IACxC,oBAAoB,eAAe;IACnC,uBAAuB,eAAe;IACtC,8BAA8B,mBAAmB;IACjD,0BAA0B;IAC1B,sBAAsB;IACtB,wBAAwB;;;;;EAM1B;IACE,kBAAkB,kBAAkB;IACpC,+BAA+B,oBAAoB;;;;;EAMrD;IACE,yBAAyB,eAAe;IACxC,4BACE,eACA,gBACA;IAEF,6BAA6B,eAAe;IAC5C,2BAA2B,cAAc;IACzC,0BAA0B,gBAAgB;IAC1C,oBAAoB;IACpB,gBAAgB,cAAc;IAC9B,qBAAqB,gBAAgB;IACrC,wBAAwB;;;;;EAM1B;IACE,sBAAsB,eAAe;IACrC,6BACE,kBACA;IAEF,qBAAqB;IACrB,0BAA0B;IAC1B,sBAAsB;IACtB,uBAAuB;IACvB,uBAAuB;IACvB,6BAA6B,iBAAiB;;;;;EAMhD;IACE,kBAAkB,kBAAkB;IACpC,uBAAuB,eAAe;IACtC,0BAA0B,eAAe;IACzC,gBAAgB,cAAc,cAAc;IAC5C,qBAAqB,cAAc;;;;;EAMrC;IACE,uBAAuB;IACvB,gCAAgC;IAChC,8BAA8B;IAC9B,4BAA4B,kBAAkB;IAC9C,iBAAiB,iBAAiB;IAClC,oBAAoB;;;;;EAMtB;IACE,wBACE,eACA,iBACA;IAEF,6BACE,aACA,aACA;;;;;EAOJ;IACE,uBAAuB,eAAe;IACtC,0BACE,eACA,mBACA"}

package/dist/cjs/types/api.d.ts

@@ -0,0 +1,184 @@
+import { RouteTreeState } from "./route-node-types.js";
+import { Params, SimpleState, State, StateMetaInput, Unsubscribe } from "./base.js";
+import { DefaultDependencies, GuardFnFactory, Options, Plugin, Route, RouteConfigUpdate } from "./router.js";
+import { EventMethodMap, EventName } from "./constants.js";
+import { TreeChangedEvent } from "./tree-changed.js";
+import { NavigationOptions, StateContext } from "../types.js";
+//#region src/types/api.d.ts
+/**
+ * Maps interceptable method names to their signatures.
+ * Used by {@link PluginApi.addInterceptor} to provide type-safe interceptor registration.
+ *
+ * To add a new interceptable method:
+ * 1. Add its signature here
+ * 2. Wrap it with `createInterceptable()` / `createBinaryInterceptable()` in
+ *    the `registerInternals` block of the Router constructor
+ *    (`packages/core/src/Router.ts`)
+ */
+interface InterceptableMethodMap {
+  start: (path?: string) => Promise<State>;
+  buildPath: (route: string, params?: Params) => string;
+  forwardState: (routeName: string, routeParams: Params) => SimpleState;
+}
+/**
+ * Type-safe interceptor callback.
+ * Receives `next` (the next function in the chain) followed by the method's original parameters.
+ */
+type InterceptorFn<M extends keyof InterceptableMethodMap> = (next: InterceptableMethodMap[M], ...args: Parameters<InterceptableMethodMap[M]>) => ReturnType<InterceptableMethodMap[M]>;
+/**
+ * Writer object returned by {@link PluginApi.claimContextNamespace}. Holds
+ * exclusive ownership of a single `state.context.<namespace>` key for the
+ * lifetime of the owning plugin.
+ *
+ * @description
+ * A plugin obtains a claim by calling `api.claimContextNamespace("ns")` at
+ * registration, then publishes per-navigation data via {@link write} from a
+ * lifecycle hook (typically `onTransitionSuccess`) or from an interceptor.
+ * The plugin must call {@link release} in its `teardown()` so another plugin
+ * can reclaim the same namespace.
+ *
+ * The core runtime enforces one invariant: a namespace can be held by at most
+ * one claim at a time. Double-claiming throws `CONTEXT_NAMESPACE_ALREADY_CLAIMED`.
+ *
+ * @example
+ * ```typescript
+ * const navigationPlugin: PluginFactory = (router) => {
+ *   const api = getPluginApi(router);
+ *   const claim = api.claimContextNamespace("navigation");
+ *
+ *   return {
+ *     onTransitionSuccess(toState, fromState) {
+ *       claim.write(toState, { direction: detectDirection(fromState, toState) });
+ *     },
+ *     teardown() {
+ *       claim.release();
+ *     },
+ *   };
+ * };
+ * ```
+ *
+ * @see {@link PluginApi.claimContextNamespace}
+ * @see {@link State.context}
+ */
+interface ContextNamespaceClaim<T = unknown> {
+  write: (state: State, value: T) => void;
+  release: () => void;
+}
+/**
+ * Plugin API — for plugins and infrastructure packages.
+ * Hides plugin-internal methods from public autocomplete.
+ */
+interface PluginApi {
+  makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: StateMetaInput) => State<P>;
+  buildState: (routeName: string, routeParams: Params) => RouteTreeState | undefined;
+  forwardState: <P extends Params = Params>(routeName: string, routeParams: P) => SimpleState<P>;
+  matchPath: <P extends Params = Params>(path: string) => State<P> | undefined;
+  /**
+   * Navigate to a fully-built `State`, skipping the redundant
+   * `forwardState`/`buildPath` round-trip in `buildNavigateState`.
+   *
+   * Plugin-only entry point for browser-initiated navigation: a plugin
+   * receives a URL event, resolves it via `api.matchPath(url)`, then commits
+   * the resulting `State` directly via `api.navigateToState(state, opts)`.
+   *
+   * Semantics vs `router.navigate(name, params, opts)`:
+   * - `forwardState` is NOT re-applied (matchPath already ran it).
+   * - `buildPath` is NOT re-run; `state.path` is used verbatim, preserving
+   *   `trailingSlash:"preserve"` source-URL output.
+   * - `forwardState`/`buildPath` interceptors do NOT run on this path; the
+   *   URL the user navigated to is the source of truth.
+   * - Pipeline: SAME_STATES check, FSM transition, guards, `subscribeLeave`,
+   *   `completeTransition`, plugin lifecycle hooks — all unchanged.
+   *
+   * Programmatic / userland navigation should keep using
+   * `router.navigate(name, params, opts)` so interceptors apply.
+   */
+  navigateToState: (state: State, options?: NavigationOptions) => Promise<State>;
+  setRootPath: (rootPath: string) => void;
+  getRootPath: () => string;
+  addEventListener: <E extends EventName>(eventName: E, cb: Plugin[EventMethodMap[E]]) => Unsubscribe;
+  buildNavigationState: (name: string, params?: Params) => State | undefined;
+  getOptions: () => Options;
+  getTree: () => unknown;
+  addInterceptor: <M extends keyof InterceptableMethodMap>(method: M, fn: InterceptorFn<M>) => Unsubscribe;
+  extendRouter: (extensions: Record<string, unknown>) => Unsubscribe;
+  /**
+   * Emits a `$$error` event without going through the navigation pipeline.
+   *
+   * Used by plugins that detect an error outside a running transition (e.g.,
+   * an unmatched URL on popstate in strict mode). The event reaches any
+   * `onTransitionError` plugin hook and any `$$error` listener so developers
+   * can observe errors raised by the plugin layer.
+   *
+   * The current router state is used as `fromState`; `toState` is `undefined`
+   * because no transition was attempted. Safe to call at any FSM state —
+   * delegates to `sendFailSafe` internally (direct emit when not READY).
+   */
+  emitTransitionError: (error: Error) => void;
+  claimContextNamespace: {
+    <K extends keyof StateContext & string>(namespace: K): ContextNamespaceClaim<StateContext[K]>;
+    (namespace: string): ContextNamespaceClaim;
+  };
+  getRouteConfig: (name: string) => Record<string, unknown> | undefined;
+}
+/**
+ * Routes API — for dynamic route mutation.
+ */
+interface RoutesApi<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  add: (routes: Route<Dependencies>[] | Route<Dependencies>, options?: {
+    parent?: string;
+  }) => void;
+  remove: (name: string) => void;
+  /**
+   * Patch an existing route's configuration in place (no tree rebuild).
+   *
+   * Applies the structural/guard fields and any plugin-defined custom fields
+   * (lifecycle hooks, `preload`, `searchSchema`, …) from the patch. Fields are
+   * shallow-merged by key; `null` removes a field, `undefined` is a no-op.
+   * `name`/`path`/`children` are immutable — use `remove` + `add` to
+   * restructure. See {@link RouteConfigUpdate} for the full semantics and the
+   * plugin augmentation pattern.
+   */
+  update: (name: string, updates: RouteConfigUpdate<Dependencies>) => void;
+  clear: () => void;
+  replace: (routes: Route<Dependencies>[] | Route<Dependencies>) => void;
+  has: (name: string) => boolean;
+  get: (name: string) => Route<Dependencies> | undefined;
+  /**
+   * Subscribe to structural route-tree mutations (`add` / `remove` / `update`
+   * with structural fields / `replace` / `clear`). Fire-and-forget: the handler
+   * cannot cancel the mutation, runs after the atomic commit, and sees the
+   * post-mutation tree via `get()` / `has()`.
+   *
+   * Duplicate-registration semantics are **lenient** (mirrors
+   * `router.subscribe`): each call registers an independent listener and
+   * returns its own unsubscribe.
+   *
+   * @returns Unsubscribe function for this specific registration.
+   */
+  subscribeChanges: (handler: (event: TreeChangedEvent<Dependencies>) => void) => Unsubscribe;
+}
+/**
+ * Dependencies API — CRUD for dependency injection.
+ */
+interface DependenciesApi<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  get: <K extends keyof Dependencies>(key: K) => Dependencies[K];
+  getAll: () => Partial<Dependencies>;
+  set: <K extends keyof Dependencies & string>(name: K, value: Dependencies[K]) => void;
+  setAll: (deps: Dependencies) => void;
+  remove: (name: keyof Dependencies) => void;
+  reset: () => void;
+  has: (name: keyof Dependencies) => boolean;
+}
+/**
+ * Lifecycle API — guard registration (addActivateGuard, addDeactivateGuard, etc.)
+ */
+interface LifecycleApi<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  addActivateGuard: (name: string, canActivateHandler: GuardFnFactory<Dependencies> | boolean) => void;
+  addDeactivateGuard: (name: string, canDeactivateHandler: GuardFnFactory<Dependencies> | boolean) => void;
+  removeActivateGuard: (name: string) => void;
+  removeDeactivateGuard: (name: string) => void;
+}
+//#endregion
+export { ContextNamespaceClaim, DependenciesApi, InterceptableMethodMap, InterceptorFn, LifecycleApi, PluginApi, RoutesApi };
+//# sourceMappingURL=api.d.ts.map

package/dist/cjs/types/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","names":[],"sources":["../../../src/types/api.ts"],"mappings":";;;;;;;;;;;;;;;;;UAqCiB;EACf,QAAQ,kBAAkB,QAAQ;EAClC,YAAY,eAAe,SAAS;EACpC,eAAe,mBAAmB,aAAa,WAAW;;;;;;KAOhD,cAAc,gBAAgB,2BACxC,MAAM,uBAAuB,OAC1B,MAAM,WAAW,uBAAuB,QACxC,WAAW,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCtB,sBAAsB;EACrC,QAAQ,OAAO,OAAO,OAAO;EAC7B;;;;;;UAOe;EACf,YAAY,UAAU,SAAS,QAC7B,cACA,SAAS,GACT,eACA,OAAO,mBACJ,MAAM;EAEX,aACE,mBACA,aAAa,WACV;EAEL,eAAe,UAAU,SAAS,QAChC,mBACA,aAAa,MACV,YAAY;EAEjB,YAAY,UAAU,SAAS,QAAQ,iBAAiB,MAAM;;;;;;;;;;;;;;;;;;;;;EAsB9D,kBACE,OAAO,OACP,UAAU,sBACP,QAAQ;EAEb,cAAc;EACd;EAEA,mBAAmB,UAAU,WAC3B,WAAW,GACX,IAAI,OAAO,eAAe,QACvB;EAEL,uBAAuB,cAAc,SAAS,WAAW;EAEzD,kBAAkB;EAElB;EAEA,iBAAiB,gBAAgB,wBAC/B,QAAQ,GACR,IAAI,cAAc,OACf;EAEL,eAAe,YAAY,4BAA4B;;;;;;;;;;;;;EAcvD,sBAAsB,OAAO;EAE7B;KAEG,gBAAgB,uBACf,WAAW,IACV,sBAAsB,aAAa;KACrC,oBAAoB;;EAGvB,iBAAiB,iBAAiB;;;;;UAMnB,UACf,qBAAqB,sBAAsB;EAE3C,MACE,QAAQ,MAAM,kBAAkB,MAAM,eACtC;IAAY;;EAGd,SAAS;;;;;;;;;;;EAYT,SAAS,cAAc,SAAS,kBAAkB;EAElD;EAEA,UAAU,QAAQ,MAAM,kBAAkB,MAAM;EAEhD,MAAM;EAEN,MAAM,iBAAiB,MAAM;;;;;;;;;;;;;EAc7B,mBACE,UAAU,OAAO,iBAAiB,2BAC/B;;;;;UAMU,gBACf,qBAAqB,sBAAsB;EAE3C,MAAM,gBAAgB,cAAc,KAAK,MAAM,aAAa;EAC5D,cAAc,QAAQ;EACtB,MAAM,gBAAgB,uBACpB,MAAM,GACN,OAAO,aAAa;EAEtB,SAAS,MAAM;EACf,SAAS,YAAY;EACrB;EACA,MAAM,YAAY;;;;;UAMH,aACf,qBAAqB,sBAAsB;EAE3C,mBACE,cACA,oBAAoB,eAAe;EAErC,qBACE,cACA,sBAAsB,eAAe;EAEvC,sBAAsB;EACtB,wBAAwB"}

package/dist/cjs/types/base.d.ts

@@ -0,0 +1,86 @@
+import { StateContext } from "../types.js";
+//#region src/types/base.d.ts
+/**
+ * Detach function returned by subscription APIs.
+ *
+ * @description
+ * Calling this function removes the associated listener. Returned by
+ * `router.subscribe()`, `router.addEventListener()`, `router.subscribeLeave()`,
+ * and plugin interceptors. Idempotent — calling more than once is safe and
+ * has no additional effect after the first call.
+ */
+type Unsubscribe = () => void;
+interface SimpleState<P extends Params = Params> {
+  name: string;
+  params: P;
+}
+type TransitionPhase = "deactivating" | "activating";
+type TransitionReason = "success" | "blocked" | "cancelled" | "error";
+interface TransitionMeta {
+  phase: TransitionPhase;
+  reason: TransitionReason;
+  reload?: boolean;
+  replace?: boolean;
+  redirected?: boolean;
+  from?: string;
+  blocker?: string;
+  segments: {
+    deactivated: string[];
+    activated: string[];
+    intersection: string;
+  };
+}
+interface State<P extends Params = Params> {
+  name: string;
+  params: P;
+  path: string;
+  transition: TransitionMeta;
+  /**
+   * Plugin-extensible per-route data, attached by plugins via
+   * `PluginApi.claimContextNamespace()` + `claim.write(state, value)`.
+   *
+   * @description
+   * Required field — always present as at least `{}` on every State created by
+   * the router (via `makeState`, `navigateToNotFound`, or `cloneRouter`).
+   *
+   * Typed extensions come from plugins augmenting {@link StateContext} through
+   * module augmentation. The intersection with `Record<string, unknown>` allows
+   * untyped namespaces (inline plugins, tests, or plugins that skip augmentation)
+   * to write without compile errors.
+   *
+   * The `context` object itself is **not frozen** — this is intentional, so
+   * plugins can attach data without cloning state. Core structural fields
+   * (`name`, `params`, `path`, `transition`) remain immutable via shallow
+   * `Object.freeze(state)`.
+   *
+   * @see {@link StateContext}
+   */
+  context: StateContext & Record<string, unknown>;
+}
+interface StateMetaInput<P extends Params = Params> {
+  params: P;
+}
+/**
+ * RouterError interface describing the public API of the RouterError class.
+ * The actual class implementation is in the real-router package.
+ * This interface enables structural typing compatibility between
+ * core-types and real-router packages.
+ */
+interface RouterError extends Error {
+  [key: string]: unknown;
+  readonly code: string;
+  readonly segment: string | undefined;
+  readonly path: string | undefined;
+  setCode: (code: string) => void;
+  setErrorInstance: (err: Error) => void;
+  setAdditionalFields: (fields: Record<string, unknown>) => void;
+  hasField: (key: string) => boolean;
+  getField: (key: string) => unknown;
+  toJSON: () => Record<string, unknown>;
+}
+interface Params {
+  [key: string]: string | string[] | number | number[] | boolean | boolean[] | Params | Params[] | Record<string, string | number | boolean> | null | undefined;
+}
+//#endregion
+export { Params, RouterError, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe };
+//# sourceMappingURL=base.d.ts.map

package/dist/cjs/types/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/types/base.ts"],"mappings":";;;;;;;;;;;KAmBY;UAEK,YAAY,UAAU,SAAS;EAC9C;EACA,QAAQ;;KAGE;KAEA;UAEK;EACf,OAAO;EACP,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa,MAAM,UAAU,SAAS;EACxC;EACA,QAAQ;EACR;EACA,YAAY;;;;;;;;;;;;;;;;;;;;;EAqBZ,SAAS,eAAe;;UAGT,eAAe,UAAU,SAAS;EACjD,QAAQ;;;;;;;;UASO,oBAAoB;GAClC;WACQ;WACA;WACA;EACT,UAAU;EACV,mBAAmB,KAAK;EACxB,sBAAsB,QAAQ;EAC9B,WAAW;EACX,WAAW;EACX,cAAc;;UAGC;GACd,4EAOG,SACA,WACA"}

package/dist/cjs/types/constants.d.ts

@@ -0,0 +1,72 @@
+//#region src/types/constants.d.ts
+/**
+ * Plugin lifecycle method names
+ */
+type PluginMethod = "onStart" | "onStop" | "onTransitionStart" | "onTransitionLeaveApprove" | "onTransitionCancel" | "onTransitionSuccess" | "onTransitionError";
+/**
+ * Router event names
+ */
+type EventName = "$start" | "$stop" | "$$start" | "$$leaveApprove" | "$$cancel" | "$$success" | "$$error";
+/**
+ * Event type keys
+ */
+type EventsKeys = "ROUTER_START" | "ROUTER_STOP" | "TRANSITION_START" | "TRANSITION_LEAVE_APPROVE" | "TRANSITION_CANCEL" | "TRANSITION_SUCCESS" | "TRANSITION_ERROR";
+/**
+ * Error code values
+ */
+type ErrorCodeValues = "NOT_STARTED" | "NO_START_PATH_OR_STATE" | "ALREADY_STARTED" | "ROUTE_NOT_FOUND" | "SAME_STATES" | "CANNOT_DEACTIVATE" | "CANNOT_ACTIVATE" | "TRANSITION_ERR" | "CANCELLED" | "DISPOSED" | "PLUGIN_CONFLICT" | "CONTEXT_NAMESPACE_ALREADY_CLAIMED";
+/**
+ * Error code keys
+ */
+type ErrorCodeKeys = "ROUTER_NOT_STARTED" | "NO_START_PATH_OR_STATE" | "ROUTER_ALREADY_STARTED" | "ROUTE_NOT_FOUND" | "SAME_STATES" | "CANNOT_DEACTIVATE" | "CANNOT_ACTIVATE" | "TRANSITION_ERR" | "TRANSITION_CANCELLED" | "ROUTER_DISPOSED" | "PLUGIN_CONFLICT" | "CONTEXT_NAMESPACE_ALREADY_CLAIMED" | "REENTRANT_NAVIGATION" | "REENTRANT_TREE_MUTATION";
+/**
+ * Mapping of event keys to plugin methods
+ */
+interface EventToPluginMap {
+  readonly ROUTER_START: "onStart";
+  readonly ROUTER_STOP: "onStop";
+  readonly TRANSITION_START: "onTransitionStart";
+  readonly TRANSITION_LEAVE_APPROVE: "onTransitionLeaveApprove";
+  readonly TRANSITION_CANCEL: "onTransitionCancel";
+  readonly TRANSITION_SUCCESS: "onTransitionSuccess";
+  readonly TRANSITION_ERROR: "onTransitionError";
+}
+/**
+ * Mapping of event keys to event names
+ */
+interface EventToNameMap {
+  ROUTER_START: "$start";
+  ROUTER_STOP: "$stop";
+  TRANSITION_START: "$$start";
+  TRANSITION_LEAVE_APPROVE: "$$leaveApprove";
+  TRANSITION_CANCEL: "$$cancel";
+  TRANSITION_SUCCESS: "$$success";
+  TRANSITION_ERROR: "$$error";
+}
+/**
+ * Mapping of event names to plugin method names.
+ * Type-level computation from EventToNameMap + EventToPluginMap.
+ */
+type EventMethodMap = { [K in EventsKeys as EventToNameMap[K]]: EventToPluginMap[K]; };
+/**
+ * Mapping of error code keys to their values
+ */
+interface ErrorCodeToValueMap {
+  ROUTER_NOT_STARTED: "NOT_STARTED";
+  NO_START_PATH_OR_STATE: "NO_START_PATH_OR_STATE";
+  ROUTER_ALREADY_STARTED: "ALREADY_STARTED";
+  ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND";
+  SAME_STATES: "SAME_STATES";
+  CANNOT_DEACTIVATE: "CANNOT_DEACTIVATE";
+  CANNOT_ACTIVATE: "CANNOT_ACTIVATE";
+  TRANSITION_ERR: "TRANSITION_ERR";
+  TRANSITION_CANCELLED: "CANCELLED";
+  ROUTER_DISPOSED: "DISPOSED";
+  PLUGIN_CONFLICT: "PLUGIN_CONFLICT";
+  CONTEXT_NAMESPACE_ALREADY_CLAIMED: "CONTEXT_NAMESPACE_ALREADY_CLAIMED";
+  REENTRANT_NAVIGATION: "REENTRANT_NAVIGATION";
+  REENTRANT_TREE_MUTATION: "REENTRANT_TREE_MUTATION";
+}
+//#endregion
+export { ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventMethodMap, EventName, EventToNameMap, EventToPluginMap, EventsKeys, PluginMethod };
+//# sourceMappingURL=constants.d.ts.map

package/dist/cjs/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/types/constants.ts"],"mappings":";;;;KAGY;;;;KAYA;;;;KAYA;;;;KAYA;;;;KAiBA;;;;UAmBK;WACN;WACA;WACA;WACA;WACA;WACA;WACA;;;;;UAMM;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;KAOU,oBACT,KAAK,cAAc,eAAe,KAAK,iBAAiB;;;;UAM1C;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA"}

package/dist/cjs/types/internal.d.ts

@@ -0,0 +1,9 @@
+import { LimitsConfig } from "./limits.js";
+//#region src/types/internal.d.ts
+/**
+ * Immutable limits configuration type.
+ */
+type Limits = Readonly<LimitsConfig>;
+//#endregion
+export { Limits };
+//# sourceMappingURL=internal.d.ts.map

package/dist/cjs/types/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","names":[],"sources":["../../../src/types/internal.ts"],"mappings":";;;;;KAwDY,SAAS,SAAS"}

package/dist/cjs/types/limits.d.ts

@@ -0,0 +1,45 @@
+//#region src/types/limits.d.ts
+/**
+ * Configuration for router resource limits.
+ * Controls maximum allowed values for various router operations to prevent resource exhaustion.
+ */
+interface LimitsConfig {
+  /**
+   * Maximum number of route dependencies allowed.
+   * Prevents circular dependency chains and excessive dependency graphs.
+   *
+   * @default 100
+   */
+  maxDependencies: number;
+  /**
+   * Maximum number of plugins that can be registered.
+   * Limits plugin stack depth to prevent performance degradation.
+   *
+   * @default 50
+   */
+  maxPlugins: number;
+  /**
+   * Maximum number of event listeners per event type.
+   * Prevents memory leaks from excessive listener registration.
+   *
+   * @default 10000
+   */
+  maxListeners: number;
+  /**
+   * Listener count at which a memory leak warning is logged per event type.
+   * Set to 0 to disable the warning.
+   *
+   * @default 1000
+   */
+  warnListeners: number;
+  /**
+   * Maximum number of lifecycle handlers (canActivate/canDeactivate) per route.
+   * Controls guard function stack to prevent excessive validation overhead.
+   *
+   * @default 200
+   */
+  maxLifecycleHandlers: number;
+}
+//#endregion
+export { LimitsConfig };
+//# sourceMappingURL=limits.d.ts.map

package/dist/cjs/types/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","names":[],"sources":["../../../src/types/limits.ts"],"mappings":";;;;;UAIiB;;;;;;;EAOf;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA"}

package/dist/cjs/types/route-node-types.d.ts

@@ -0,0 +1,46 @@
+//#region src/types/route-node-types.d.ts
+/**
+ * Route Node Type Definitions — Minimal Public API.
+ *
+ * This module exports ONLY the essential types used by real-router:
+ * - QueryParamsMode, QueryParamsOptions
+ * - RouteParams, RouteTreeState
+ *
+ * These types are copied from route-node to avoid circular dependencies.
+ *
+ * @module route-node-types
+ */
+type ArrayFormat = "none" | "brackets" | "index" | "comma";
+type BooleanFormat = "none" | "auto" | "empty-true";
+type NullFormat = "default" | "hidden";
+type NumberFormat = "none" | "auto";
+/**
+ * Options for query parameter parsing and building.
+ */
+interface QueryParamsOptions {
+  arrayFormat?: ArrayFormat;
+  booleanFormat?: BooleanFormat;
+  nullFormat?: NullFormat;
+  numberFormat?: NumberFormat;
+}
+/**
+ * Controls how query parameters are handled during matching.
+ */
+type QueryParamsMode = "default" | "strict" | "loose";
+type ParamSource = "url" | "query";
+type ParamTypeMap = Record<string, ParamSource>;
+type RouteTreeStateMeta = Record<string, ParamTypeMap>;
+interface RouteParams {
+  [key: string]: string | string[] | number | number[] | boolean | boolean[] | RouteParams | RouteParams[] | Record<string, string | number | boolean> | null | undefined;
+}
+/**
+ * Complete state representation of a matched route.
+ */
+interface RouteTreeState<P extends Record<string, unknown> = RouteParams> {
+  name: string;
+  params: P;
+  meta: RouteTreeStateMeta;
+}
+//#endregion
+export { QueryParamsMode, QueryParamsOptions, RouteParams, RouteTreeState };
+//# sourceMappingURL=route-node-types.d.ts.map

package/dist/cjs/types/route-node-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-node-types.d.ts","names":[],"sources":["../../../src/types/route-node-types.ts"],"mappings":";;;;;;;;;;;;KAgBK;KACA;KACA;KACA;;;;UAKY;EACf,cAAc;EACd,gBAAgB;EAChB,aAAa;EACb,eAAe;;;;;KAUL;KAMP;KACA,eAAe,eAAe;KAC9B,qBAAqB,eAAe;UAExB;GACd,4EAOG,cACA,gBACA;;;;;UAQW,eACf,UAAU,0BAA0B;EAEpC;EACA,QAAQ;EACR,MAAM"}