@real-router/core 0.56.0 → 0.57.1

package/src/wiring/RouterWiringBuilder.ts

@@ -1,275 +0,0 @@
-// packages/core/src/wiring/RouterWiringBuilder.ts
-
-import { normalizeParams } from "../helpers";
-import { getInternals } from "../internals";
-import { resolveOption } from "../namespaces/OptionsNamespace";
-
-import type { EventBusNamespace } from "../namespaces";
-import type { WiringOptions } from "./types";
-import type { NavigationDependencies } from "../namespaces/NavigationNamespace";
-import type { PluginsDependencies } from "../namespaces/PluginsNamespace";
-import type { RouteLifecycleDependencies } from "../namespaces/RouteLifecycleNamespace";
-import type { RouterLifecycleDependencies } from "../namespaces/RouterLifecycleNamespace";
-import type { RoutesDependencies } from "../namespaces/RoutesNamespace";
-import type { DefaultDependencies, Params } from "@real-router/types";
-
-export class RouterWiringBuilder<
-  Dependencies extends DefaultDependencies = DefaultDependencies,
-> {
-  private readonly router: WiringOptions<Dependencies>["router"];
-  private readonly options: WiringOptions<Dependencies>["options"];
-  private readonly limits: WiringOptions<Dependencies>["limits"];
-  private readonly dependenciesStore: WiringOptions<Dependencies>["dependenciesStore"];
-  private readonly state: WiringOptions<Dependencies>["state"];
-  private readonly routes: WiringOptions<Dependencies>["routes"];
-  private readonly routeLifecycle: WiringOptions<Dependencies>["routeLifecycle"];
-  private readonly plugins: WiringOptions<Dependencies>["plugins"];
-  private readonly navigation: WiringOptions<Dependencies>["navigation"];
-  private readonly lifecycle: WiringOptions<Dependencies>["lifecycle"];
-  private readonly eventBus: EventBusNamespace;
-
-  constructor(wiringOptions: WiringOptions<Dependencies>) {
-    this.router = wiringOptions.router;
-    this.options = wiringOptions.options;
-    this.limits = wiringOptions.limits;
-    this.dependenciesStore = wiringOptions.dependenciesStore;
-    this.state = wiringOptions.state;
-    this.routes = wiringOptions.routes;
-    this.routeLifecycle = wiringOptions.routeLifecycle;
-    this.plugins = wiringOptions.plugins;
-    this.navigation = wiringOptions.navigation;
-    this.lifecycle = wiringOptions.lifecycle;
-    this.eventBus = wiringOptions.eventBus;
-  }
-
-  wireLimits(): void {
-    this.dependenciesStore.limits = this.limits;
-    this.plugins.setLimits(this.limits);
-    this.eventBus.setLimits({
-      maxListeners: this.limits.maxListeners,
-      warnListeners: this.limits.warnListeners,
-      maxEventDepth: this.limits.maxEventDepth,
-    });
-    this.routeLifecycle.setLimits(this.limits);
-  }
-
-  wireRouteLifecycleDeps(): void {
-    const routeLifecycleDeps: RouteLifecycleDependencies<Dependencies> = {
-      compileFactory: this.createCompileFactory(),
-    };
-
-    this.routeLifecycle.setDependencies(routeLifecycleDeps);
-    this.routeLifecycle.setValidatorGetter(
-      /* v8 ignore next 3 -- @preserve: returns null during construction (before registerInternals) */
-      () => {
-        try {
-          return getInternals(this.router).validator;
-        } catch {
-          return null;
-        }
-      },
-    );
-  }
-
-  wireRoutesDeps(): void {
-    const routesDeps: RoutesDependencies<Dependencies> = {
-      addActivateGuard: (name, handler) => {
-        this.routeLifecycle.addCanActivate(name, handler, true);
-      },
-      addDeactivateGuard: (name, handler) => {
-        this.routeLifecycle.addCanDeactivate(name, handler, true);
-      },
-      makeState: (name, params, path, meta) =>
-        this.state.makeState(name, params, path, meta),
-      getState: () => this.state.get(),
-      areStatesEqual: (state1, state2, ignoreQueryParams) =>
-        this.state.areStatesEqual(state1, state2, ignoreQueryParams),
-      getDependency: (name) =>
-        this.dependenciesStore.dependencies[name] as Dependencies[typeof name],
-      forwardState: <P extends Params = Params>(name: string, params: P) => {
-        const ctx = getInternals(this.router);
-
-        ctx.validator?.routes.validateStateBuilderArgs(
-          name,
-          params,
-          "forwardState",
-        );
-
-        return ctx.forwardState(name, params);
-      },
-    };
-
-    this.routes.setDependencies(routesDeps);
-    this.routes.setLifecycleNamespace(this.routeLifecycle);
-  }
-
-  wirePluginsDeps(): void {
-    const pluginsDeps: PluginsDependencies<Dependencies> = {
-      addEventListener: (eventName, cb) =>
-        this.eventBus.addEventListener(eventName, cb),
-      canNavigate: () => this.eventBus.canBeginTransition(),
-      compileFactory: this.createCompileFactory(),
-    };
-
-    this.plugins.setDependencies(pluginsDeps);
-    this.plugins.setValidatorGetter(
-      /* v8 ignore next 3 -- @preserve: returns null during construction (before registerInternals) */
-      () => {
-        try {
-          return getInternals(this.router).validator;
-        } catch {
-          return null;
-        }
-      },
-    );
-  }
-
-  wireNavigationDeps(): void {
-    const navigationDeps: NavigationDependencies = {
-      getOptions: () => this.options.get(),
-      hasRoute: (name) => this.routes.hasRoute(name),
-      getState: () => this.state.get(),
-      setState: (state) => {
-        this.state.set(state);
-      },
-      buildNavigateState: (routeName, routeParams) => {
-        const ctx = getInternals(this.router);
-
-        ctx.validator?.routes.validateStateBuilderArgs(
-          routeName,
-          routeParams,
-          "navigate",
-        );
-
-        const forwarded = ctx.forwardState(routeName, routeParams);
-        const name = forwarded.name;
-        const params = normalizeParams(forwarded.params);
-        const meta = this.routes.getMetaForState(name);
-
-        if (meta === undefined) {
-          return;
-        }
-
-        const path = ctx.buildPath(name, params);
-
-        return this.state.makeState(name, params, path, meta, true);
-      },
-      resolveDefault: () => {
-        const options = this.options.get();
-        const ctx = getInternals(this.router);
-
-        const route = resolveOption(
-          options.defaultRoute,
-          (name: string) =>
-            this.dependenciesStore.dependencies[name as keyof Dependencies],
-        );
-        const params = resolveOption(
-          options.defaultParams,
-          /* v8 ignore next -- @preserve: unreachable unless defaultParams is a callback that calls getDependency */
-          (name: string) =>
-            this.dependenciesStore.dependencies[name as keyof Dependencies],
-        );
-
-        if (typeof options.defaultRoute === "function") {
-          ctx.validator?.options.validateResolvedDefaultRoute(
-            route,
-            ctx.routeGetStore(),
-          );
-        }
-
-        return { route, params };
-      },
-      startTransition: (toState, fromState) => {
-        this.eventBus.sendNavigate(toState, fromState);
-      },
-      cancelNavigation: () => {
-        const toState = this.eventBus.getCurrentToState();
-
-        /* v8 ignore next -- @preserve: getCurrentToState() guaranteed set before TRANSITION_STARTED */
-        if (toState === undefined) {
-          return;
-        }
-
-        this.eventBus.sendCancel(toState, this.state.get());
-      },
-      sendTransitionDone: (state, fromState, opts) => {
-        this.eventBus.sendComplete(state, fromState, opts);
-      },
-      sendTransitionFail: (toState, fromState, error) => {
-        this.eventBus.sendFail(toState, fromState, error);
-      },
-      emitTransitionError: (toState, fromState, error) => {
-        this.eventBus.sendFailSafe(toState, fromState, error);
-      },
-      emitTransitionSuccess: (toState, fromState, opts) => {
-        this.eventBus.emitTransitionSuccess(toState, fromState, opts);
-      },
-      sendLeaveApprove: (toState, fromState) => {
-        this.eventBus.sendLeaveApprove(toState, fromState);
-      },
-      canNavigate: () => this.eventBus.canBeginTransition(),
-      getLifecycleFunctions: () => this.routeLifecycle.getFunctions(),
-      isActive: () => this.router.isActive(),
-      isTransitioning: () => this.eventBus.isTransitioning(),
-      clearCanDeactivate: (name: string) => {
-        this.routeLifecycle.clearCanDeactivate(name);
-      },
-      hasLeaveListeners: () => this.eventBus.hasLeaveListeners(),
-      awaitLeaveListeners: (toState, fromState, signal) =>
-        this.eventBus.awaitLeaveListeners(toState, fromState, signal),
-    };
-
-    this.navigation.setDependencies(navigationDeps);
-  }
-
-  wireLifecycleDeps(): void {
-    const lifecycleDeps: RouterLifecycleDependencies = {
-      getOptions: () => this.options.get(),
-      navigateToState: (state, opts) =>
-        this.navigation.navigateToState(state, opts),
-      navigateToNotFound: (path) => this.navigation.navigateToNotFound(path),
-      clearState: () => {
-        this.state.set(undefined);
-      },
-      matchPath: (path) => this.routes.matchPath(path, this.options.get()),
-      completeStart: () => {
-        this.eventBus.sendStarted();
-      },
-      emitTransitionError: (toState, fromState, error) => {
-        this.eventBus.sendFail(toState, fromState, error);
-      },
-    };
-
-    this.lifecycle.setDependencies(lifecycleDeps);
-  }
-
-  wireStateDeps(): void {
-    this.state.setDependencies({
-      getDefaultParams: () => this.routes.getStore().config.defaultParams,
-      buildPath: (name, params) => {
-        const ctx = getInternals(this.router);
-
-        return ctx.buildPath(name, params);
-      },
-      getUrlParams: (name) => this.routes.getUrlParams(name),
-    });
-  }
-
-  private createCompileFactory() {
-    const { router, dependenciesStore } = this;
-
-    return <T>(
-      factory: (
-        router: WiringOptions<Dependencies>["router"],
-        getDependency: <K extends keyof Dependencies>(
-          name: K,
-        ) => Dependencies[K],
-      ) => T,
-    ): T =>
-      factory(
-        router,
-        <K extends keyof Dependencies>(name: K) =>
-          dependenciesStore.dependencies[name] as Dependencies[K],
-      );
-  }
-}

package/src/wiring/index.ts

@@ -1,7 +0,0 @@
-// packages/core/src/wiring/index.ts
-
-export { RouterWiringBuilder } from "./RouterWiringBuilder";
-
-export { wireRouter } from "./wireRouter";
-
-export type { WiringOptions } from "./types";

package/src/wiring/types.ts

@@ -1,47 +0,0 @@
-// packages/core/src/wiring/types.ts
-
-import type {
-  EventBusNamespace,
-  NavigationNamespace,
-  OptionsNamespace,
-  PluginsNamespace,
-  RouteLifecycleNamespace,
-  RouterLifecycleNamespace,
-  RoutesNamespace,
-  StateNamespace,
-} from "../namespaces";
-import type { DependenciesStore } from "../namespaces/DependenciesNamespace/dependenciesStore";
-import type { Router } from "../Router";
-import type { Limits } from "../types";
-import type { DefaultDependencies } from "@real-router/types";
-
-/**
- * Constructor options bag for RouterWiringBuilder.
- *
- * Contains all namespaces, FSM, emitter, and accessors needed to wire
- * inter-namespace dependencies.
- */
-export interface WiringOptions<Dependencies extends DefaultDependencies> {
-  /** Router instance — passed to namespaces for factory initialization */
-  router: Router<Dependencies>;
-  /** Options namespace */
-  options: OptionsNamespace;
-  /** Immutable limits configuration */
-  limits: Limits;
-  /** Dependencies store */
-  dependenciesStore: DependenciesStore<Dependencies>;
-  /** State namespace */
-  state: StateNamespace;
-  /** Routes namespace */
-  routes: RoutesNamespace<Dependencies>;
-  /** Route lifecycle namespace (canActivate/canDeactivate guards) */
-  routeLifecycle: RouteLifecycleNamespace<Dependencies>;
-  /** Plugins namespace */
-  plugins: PluginsNamespace<Dependencies>;
-  /** Navigation namespace */
-  navigation: NavigationNamespace;
-  /** Router lifecycle namespace (start/stop) */
-  lifecycle: RouterLifecycleNamespace;
-  /** EventBus namespace — unified FSM + EventEmitter abstraction */
-  eventBus: EventBusNamespace;
-}

package/src/wiring/wireRouter.ts

@@ -1,26 +0,0 @@
-// packages/core/src/wiring/wireRouter.ts
-
-import type { RouterWiringBuilder } from "./RouterWiringBuilder";
-import type { DefaultDependencies } from "@real-router/types";
-
-/**
- * Director function — calls RouterWiringBuilder methods in the correct dependency order.
- *
- * ORDER MATTERS:
- * - `wireLimits()` first: all namespaces must have limits before any other setup
- * - `wireRouteLifecycleDeps()` BEFORE `wireRoutesDeps()`: RoutesNamespace.setDependencies()
- *   registers pending canActivate handlers which require RouteLifecycleNamespace to be ready
- * - `wireNavigationDeps()` BEFORE `wireLifecycleDeps()`: lifecycle deps reference
- *   NavigationNamespace.navigate() which requires navigation deps to be set
- */
-export function wireRouter<Dependencies extends DefaultDependencies>(
-  builder: RouterWiringBuilder<Dependencies>,
-): void {
-  builder.wireLimits();
-  builder.wireRouteLifecycleDeps();
-  builder.wireRoutesDeps();
-  builder.wirePluginsDeps();
-  builder.wireNavigationDeps();
-  builder.wireLifecycleDeps();
-  builder.wireStateDeps();
-}