react-router 0.0.0-experimental-bcda00aaf → 0.0.0-experimental-3278f3ca6

package/dist/lib/router/utils.d.ts

@@ -0,0 +1,505 @@
+import type { Location, Path, To } from "./history";
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+export interface RouteData {
+    [routeId: string]: any;
+}
+export declare enum ResultType {
+    data = "data",
+    redirect = "redirect",
+    error = "error"
+}
+/**
+ * Successful result from a loader or action
+ */
+export interface SuccessResult {
+    type: ResultType.data;
+    data: unknown;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Redirect result from a loader or action
+ */
+export interface RedirectResult {
+    type: ResultType.redirect;
+    response: Response;
+}
+/**
+ * Unsuccessful result from a loader or action
+ */
+export interface ErrorResult {
+    type: ResultType.error;
+    error: unknown;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+export type DataResult = SuccessResult | RedirectResult | ErrorResult;
+export type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
+export type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+export type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
+/**
+ * Active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState. This is to align with the normalization done via fetch().
+ */
+export type FormMethod = UpperCaseFormMethod;
+export type MutationFormMethod = Exclude<FormMethod, "GET">;
+export type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
+type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+export type Submission = {
+    formMethod: FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: FormData;
+    json: undefined;
+    text: undefined;
+} | {
+    formMethod: FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: JsonValue;
+    text: undefined;
+} | {
+    formMethod: FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: undefined;
+    text: string;
+};
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs<Context> {
+    request: Request;
+    params: Params;
+    context?: Context;
+}
+/**
+ * Arguments passed to loader functions
+ */
+export interface LoaderFunctionArgs<Context = any> extends DataFunctionArgs<Context> {
+}
+/**
+ * Arguments passed to action functions
+ */
+export interface ActionFunctionArgs<Context = any> extends DataFunctionArgs<Context> {
+}
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+type DataFunctionValue = Response | NonNullable<unknown> | null;
+type DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;
+/**
+ * Route loader function signature
+ */
+export type LoaderFunction<Context = any> = {
+    (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+} & {
+    hydrate?: boolean;
+};
+/**
+ * Route action function signature
+ */
+export interface ActionFunction<Context = any> {
+    (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+}
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+export interface ShouldRevalidateFunctionArgs {
+    currentUrl: URL;
+    currentParams: AgnosticDataRouteMatch["params"];
+    nextUrl: URL;
+    nextParams: AgnosticDataRouteMatch["params"];
+    formMethod?: Submission["formMethod"];
+    formAction?: Submission["formAction"];
+    formEncType?: Submission["formEncType"];
+    text?: Submission["text"];
+    formData?: Submission["formData"];
+    json?: Submission["json"];
+    actionStatus?: number;
+    actionResult?: any;
+    defaultShouldRevalidate: boolean;
+}
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+export interface ShouldRevalidateFunction {
+    (args: ShouldRevalidateFunctionArgs): boolean;
+}
+export interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+    shouldLoad: boolean;
+    resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
+}
+export interface DataStrategyFunctionArgs<Context = any> extends DataFunctionArgs<Context> {
+    matches: DataStrategyMatch[];
+    fetcherKey: string | null;
+}
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+export interface DataStrategyResult {
+    type: "data" | "error";
+    result: unknown;
+}
+export interface DataStrategyFunction {
+    (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;
+}
+export type AgnosticPatchRoutesOnNavigationFunctionArgs<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = {
+    path: string;
+    matches: M[];
+    patch: (routeId: string | null, children: O[]) => void;
+};
+export type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = (opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>) => void | Promise<void>;
+/**
+ * Function provided by the framework-aware layers to set any framework-specific
+ * properties from framework-agnostic properties
+ */
+export interface MapRoutePropertiesFunction {
+    (route: AgnosticRouteObject): {
+        hasErrorBoundary: boolean;
+    } & Record<string, any>;
+}
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+export type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+export declare const immutableRouteKeys: Set<ImmutableRouteKey>;
+type RequireOne<T, Key = keyof T> = Exclude<{
+    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
+}[keyof T], undefined>;
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+export interface LazyRouteFunction<R extends AgnosticRouteObject> {
+    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+}
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    loader?: LoaderFunction | boolean;
+    action?: ActionFunction | boolean;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction;
+    handle?: any;
+    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;
+};
+/**
+ * Index routes must not have children
+ */
+export type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: undefined;
+    index: true;
+};
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+export type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: AgnosticRouteObject[];
+    index?: false;
+};
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+export type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
+export type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+    id: string;
+};
+export type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+    children?: AgnosticDataRouteObject[];
+    id: string;
+};
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+export type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
+export type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;
+type _PathParam<Path extends string> = Path extends `${infer L}/${infer R}` ? _PathParam<L> | _PathParam<R> : Path extends `:${infer Param}` ? Param extends `${infer Optional}?` ? Optional : Param : never;
+/**
+ * Examples:
+ * "/a/b/*" -> "*"
+ * ":a" -> "a"
+ * "/a/:b" -> "b"
+ * "/a/blahblahblah:b" -> "b"
+ * "/:a/:b" -> "a" | "b"
+ * "/:a/b/:c/*" -> "a" | "c" | "*"
+ */
+export type PathParam<Path extends string> = Path extends "*" | "/*" ? "*" : Path extends `${infer Rest}/*` ? "*" | _PathParam<Rest> : _PathParam<Path>;
+export type ParamParseKey<Segment extends string> = [
+    PathParam<Segment>
+] extends [never] ? string : PathParam<Segment>;
+/**
+ * The parameters that were parsed from the URL path.
+ */
+export type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+export interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObjectType;
+}
+export interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+}
+export declare function convertRoutesToDataRoutes(routes: AgnosticRouteObject[], mapRouteProperties: MapRoutePropertiesFunction, parentPath?: string[], manifest?: RouteManifest): AgnosticDataRouteObject[];
+/**
+ * Matches the given routes to a location and returns the match data.
+ *
+ * @category Utils
+ */
+export declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
+export declare function matchRoutesImpl<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename: string, allowPartial: boolean): AgnosticRouteMatch<string, RouteObjectType>[] | null;
+export interface UIMatch<Data = unknown, Handle = unknown> {
+    id: string;
+    pathname: string;
+    params: AgnosticRouteMatch["params"];
+    data: Data;
+    handle: Handle;
+}
+export declare function convertRouteMatchToUiMatch(match: AgnosticDataRouteMatch, loaderData: RouteData): UIMatch;
+/**
+ * Returns a path with params interpolated.
+ *
+ * @category Utils
+ */
+export declare function generatePath<Path extends string>(originalPath: Path, params?: {
+    [key in PathParam<Path>]: string | null;
+}): string;
+/**
+ * A PathPattern is used to match on some portion of a URL pathname.
+ */
+export interface PathPattern<Path extends string = string> {
+    /**
+     * A string to match against a URL pathname. May contain `:id`-style segments
+     * to indicate placeholders for dynamic parameters. May also end with `/*` to
+     * indicate matching the rest of the URL pathname.
+     */
+    path: Path;
+    /**
+     * Should be `true` if the static portions of the `path` should be matched in
+     * the same case.
+     */
+    caseSensitive?: boolean;
+    /**
+     * Should be `true` if this pattern should match the entire URL pathname.
+     */
+    end?: boolean;
+}
+/**
+ * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ */
+export interface PathMatch<ParamKey extends string = string> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The pattern that was used to match.
+     */
+    pattern: PathPattern;
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @category Utils
+ */
+export declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
+export declare function decodePath(value: string): string;
+/**
+ * @private
+ */
+export declare function stripBasename(pathname: string, basename: string): string | null;
+/**
+ * Returns a resolved path object relative to the given pathname.
+ *
+ * @category Utils
+ */
+export declare function resolvePath(to: To, fromPathname?: string): Path;
+/**
+ * @private
+ *
+ * When processing relative navigation we want to ignore ancestor routes that
+ * do not contribute to the path, such that index/pathless layout routes don't
+ * interfere.
+ *
+ * For example, when moving a route element into an index route and/or a
+ * pathless layout route, relative link behavior contained within should stay
+ * the same.  Both of the following examples should link back to the root:
+ *
+ *   <Route path="/">
+ *     <Route path="accounts" element={<Link to=".."}>
+ *   </Route>
+ *
+ *   <Route path="/">
+ *     <Route path="accounts">
+ *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+ *         <Route index element={<Link to=".."} />  // <-- Does not contribute
+ *       </Route
+ *     </Route>
+ *   </Route>
+ */
+export declare function getPathContributingMatches<T extends AgnosticRouteMatch = AgnosticRouteMatch>(matches: T[]): T[];
+export declare function getResolveToMatches<T extends AgnosticRouteMatch = AgnosticRouteMatch>(matches: T[]): string[];
+/**
+ * @private
+ */
+export declare function resolveTo(toArg: To, routePathnames: string[], locationPathname: string, isPathRelative?: boolean): Path;
+/**
+ * @private
+ */
+export declare const joinPaths: (paths: string[]) => string;
+/**
+ * @private
+ */
+export declare const normalizePathname: (pathname: string) => string;
+/**
+ * @private
+ */
+export declare const normalizeSearch: (search: string) => string;
+/**
+ * @private
+ */
+export declare const normalizeHash: (hash: string) => string;
+export type JsonFunction = <Data>(data: Data, init?: number | ResponseInit) => Response;
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @category Utils
+ */
+export declare const json: JsonFunction;
+export declare class DataWithResponseInit<D> {
+    type: string;
+    data: D;
+    init: ResponseInit | null;
+    constructor(data: D, init?: ResponseInit);
+}
+/**
+ * Create "responses" that contain `status`/`headers` without forcing
+ * serialization into an actual `Response` - used by Remix single fetch
+ *
+ * @category Utils
+ */
+export declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
+export interface TrackedPromise extends Promise<any> {
+    _tracked?: boolean;
+    _data?: any;
+    _error?: any;
+}
+export type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @category Utils
+ */
+export declare const redirect: RedirectFunction;
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @category Utils
+ */
+export declare const redirectDocument: RedirectFunction;
+/**
+ * A redirect response that will perform a `history.replaceState` instead of a
+ * `history.pushState` for client-side navigation redirects.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @category Utils
+ */
+export declare const replace: RedirectFunction;
+export type ErrorResponse = {
+    status: number;
+    statusText: string;
+    data: any;
+};
+/**
+ * @private
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+export declare class ErrorResponseImpl implements ErrorResponse {
+    status: number;
+    statusText: string;
+    data: any;
+    private error?;
+    private internal;
+    constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
+}
+/**
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ *
+ * @category Utils
+ */
+export declare function isRouteErrorResponse(error: any): error is ErrorResponse;
+export {};

package/dist/lib/server-runtime/build.d.ts

@@ -0,0 +1,38 @@
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "./routeModules";
+import type { AssetsManifest, EntryContext, FutureConfig } from "../dom/ssr/entry";
+import type { ServerRouteManifest } from "./routes";
+import type { AppLoadContext } from "./data";
+/**
+ * The output of the compiler for the server build.
+ */
+export interface ServerBuild {
+    entry: {
+        module: ServerEntryModule;
+    };
+    routes: ServerRouteManifest;
+    assets: AssetsManifest;
+    basename?: string;
+    publicPath: string;
+    assetsBuildDirectory: string;
+    future: FutureConfig;
+    isSpaMode: boolean;
+}
+export interface HandleDocumentRequestFunction {
+    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: AppLoadContext): Promise<Response> | Response;
+}
+export interface HandleDataRequestFunction {
+    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
+}
+export interface HandleErrorFunction {
+    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
+}
+/**
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
+ */
+export interface ServerEntryModule {
+    default: HandleDocumentRequestFunction;
+    handleDataRequest?: HandleDataRequestFunction;
+    handleError?: HandleErrorFunction;
+    streamTimeout?: number;
+}

package/dist/lib/server-runtime/cookies.d.ts

@@ -0,0 +1,62 @@
+import type { CookieParseOptions, CookieSerializeOptions } from "cookie";
+export type { CookieParseOptions, CookieSerializeOptions };
+export interface CookieSignatureOptions {
+    /**
+     * An array of secrets that may be used to sign/unsign the value of a cookie.
+     *
+     * The array makes it easy to rotate secrets. New secrets should be added to
+     * the beginning of the array. `cookie.serialize()` will always use the first
+     * value in the array, but `cookie.parse()` may use any of them so that
+     * cookies that were signed with older secrets still work.
+     */
+    secrets?: string[];
+}
+export type CookieOptions = CookieParseOptions & CookieSerializeOptions & CookieSignatureOptions;
+/**
+ * A HTTP cookie.
+ *
+ * A Cookie is a logical container for metadata about a HTTP cookie; its name
+ * and options. But it doesn't contain a value. Instead, it has `parse()` and
+ * `serialize()` methods that allow a single instance to be reused for
+ * parsing/encoding multiple different values.
+ *
+ * @see https://remix.run/utils/cookies#cookie-api
+ */
+export interface Cookie {
+    /**
+     * The name of the cookie, used in the `Cookie` and `Set-Cookie` headers.
+     */
+    readonly name: string;
+    /**
+     * True if this cookie uses one or more secrets for verification.
+     */
+    readonly isSigned: boolean;
+    /**
+     * The Date this cookie expires.
+     *
+     * Note: This is calculated at access time using `maxAge` when no `expires`
+     * option is provided to `createCookie()`.
+     */
+    readonly expires?: Date;
+    /**
+     * Parses a raw `Cookie` header and returns the value of this cookie or
+     * `null` if it's not present.
+     */
+    parse(cookieHeader: string | null, options?: CookieParseOptions): Promise<any>;
+    /**
+     * Serializes the given value to a string and returns the `Set-Cookie`
+     * header.
+     */
+    serialize(value: any, options?: CookieSerializeOptions): Promise<string>;
+}
+/**
+ * Creates a logical container for managing a browser cookie from the server.
+ */
+export declare const createCookie: (name: string, cookieOptions?: CookieOptions) => Cookie;
+export type IsCookieFunction = (object: any) => object is Cookie;
+/**
+ * Returns true if an object is a Remix cookie container.
+ *
+ * @see https://remix.run/utils/cookies#iscookie
+ */
+export declare const isCookie: IsCookieFunction;

package/dist/lib/server-runtime/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare const sign: (value: string, secret: string) => Promise<string>;
+export declare const unsign: (cookie: string, secret: string) => Promise<string | false>;

package/dist/lib/server-runtime/data.d.ts

@@ -0,0 +1,28 @@
+import type { ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs } from "./routeModules";
+/**
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
+ */
+export interface AppLoadContext {
+    [key: string]: unknown;
+}
+/**
+ * Data for a route that was returned from a `loader()`.
+ */
+export type AppData = unknown;
+export declare function callRouteAction({ loadContext, action, params, request, routeId, }: {
+    request: Request;
+    action: ActionFunction;
+    params: ActionFunctionArgs["params"];
+    loadContext: AppLoadContext;
+    routeId: string;
+}): Promise<{} | Response | null>;
+export declare function callRouteLoader({ loadContext, loader, params, request, routeId, }: {
+    request: Request;
+    loader: LoaderFunction;
+    params: LoaderFunctionArgs["params"];
+    loadContext: AppLoadContext;
+    routeId: string;
+}): Promise<{} | Response | null>;

package/dist/lib/server-runtime/dev.d.ts

@@ -0,0 +1,8 @@
+import type { ServerBuild } from "./build";
+type DevServerHooks = {
+    getCriticalCss?: (build: ServerBuild, pathname: string) => Promise<string | undefined>;
+    processRequestError?: (error: unknown) => void;
+};
+export declare function setDevServerHooks(devServerHooks: DevServerHooks): void;
+export declare function getDevServerHooks(): DevServerHooks | undefined;
+export {};

package/dist/lib/server-runtime/entry.d.ts

@@ -0,0 +1,3 @@
+import type { ServerRouteManifest } from "./routes";
+import type { RouteModules, EntryRouteModule } from "./routeModules";
+export declare function createEntryRouteModules(manifest: ServerRouteManifest): RouteModules<EntryRouteModule>;