react-router 7.0.0-pre.1 → 7.0.0-pre.2

package/dist/lib/components.d.ts

@@ -2,7 +2,7 @@ import * as React from "react";
 import type { InitialEntry, Location, To } from "./router/history";
 import { Action as NavigationType } from "./router/history";
 import type { FutureConfig, HydrationState, RelativeRoutingType, Router as DataRouter } from "./router/router";
-import type { DataStrategyFunction, LazyRouteFunction, TrackedPromise } from "./router/utils";
+import type { DataStrategyFunction, LazyRouteFunction } from "./router/utils";
 import type { IndexRouteObject, Navigator, NonIndexRouteObject, PatchRoutesOnNavigationFunction, RouteMatch, RouteObject } from "./context";
 /**
  * @private
@@ -209,13 +209,13 @@ export interface RoutesProps {
  @category Components
  */
 export declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
-export interface AwaitResolveRenderFunction {
-    (data: Awaited<any>): React.ReactNode;
+export interface AwaitResolveRenderFunction<Resolve = any> {
+    (data: Awaited<Resolve>): React.ReactNode;
 }
 /**
  * @category Types
  */
-export interface AwaitProps {
+export interface AwaitProps<Resolve> {
     /**
     When using a function, the resolved value is provided as the parameter.
   
@@ -312,7 +312,7 @@ export interface AwaitProps {
     }
     ```
      */
-    resolve: TrackedPromise | any;
+    resolve: Resolve;
 }
 /**
 Used to render promise values with automatic error handling.
@@ -355,7 +355,7 @@ function Book() {
 @category Components
 
 */
-export declare function Await({ children, errorElement, resolve }: AwaitProps): React.JSX.Element;
+export declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
 /**
  * Creates a route config from a React "children" object, which is usually
  * either a `<Route>` element or an array of them. Used internally by

package/dist/lib/dom/lib.d.ts

@@ -6,6 +6,7 @@ import "./global";
 import type { SubmitOptions, URLSearchParamsInit, SubmitTarget, FetcherSubmitOptions } from "./dom";
 import type { DiscoverBehavior, PrefetchBehavior, ScriptsProps } from "./ssr/components";
 import type { RouteObject, NavigateOptions, PatchRoutesOnNavigationFunction } from "../context";
+import type { SerializeFrom } from "../types";
 interface DOMRouterOpts {
     basename?: string;
     future?: Partial<FutureConfig>;
@@ -834,7 +835,7 @@ export type FetcherWithComponents<TData> = Fetcher<TData> & {
 
   @category Hooks
  */
-export declare function useFetcher<TData = any>({ key, }?: {
+export declare function useFetcher<T = any>({ key, }?: {
     /**
       By default, `useFetcher` generate a unique fetcher scoped to that component. If you want to identify a fetcher with your own key such that you can access it from elsewhere in your app, you can do that with the `key` option:
   
@@ -853,7 +854,7 @@ export declare function useFetcher<TData = any>({ key, }?: {
       ```
      */
     key?: string;
-}): FetcherWithComponents<TData>;
+}): FetcherWithComponents<SerializeFrom<T>>;
 /**
   Returns an array of all in-flight fetchers. This is useful for components throughout the app that didn't create the fetchers but want to use their submissions to participate in optimistic UI.
 

package/dist/lib/dom/ssr/components.d.ts

@@ -2,7 +2,6 @@ import type { FocusEventHandler, MouseEventHandler, TouchEventHandler } from "re
 import * as React from "react";
 import type { FrameworkContextObject } from "./entry";
 import type { PageLinkDescriptor } from "../../router/links";
-export type SerializeFrom<D> = D extends () => {} ? Awaited<ReturnType<D>> : D;
 export declare const FrameworkContext: React.Context<FrameworkContextObject | undefined>;
 export declare function useFrameworkContext(): FrameworkContextObject;
 /**

package/dist/lib/dom/ssr/data.d.ts

@@ -1,7 +1,2 @@
 import "../global";
-/**
- * Data for a route that was returned from a `loader()`.
- */
-export type AppData = unknown;
-export declare function isResponse(value: any): value is Response;
 export declare function createRequestInit(request: Request): Promise<RequestInit>;

package/dist/lib/dom/ssr/entry.d.ts

@@ -1,6 +1,7 @@
 import type { StaticHandlerContext } from "../../router/router";
-import type { RouteManifest, EntryRoute } from "./routes";
+import type { EntryRoute } from "./routes";
 import type { RouteModules } from "./routeModules";
+import type { RouteManifest } from "../../router/utils";
 type SerializedError = {
     message: string;
     stack?: string;

package/dist/lib/dom/ssr/routeModules.d.ts

@@ -1,11 +1,10 @@
 import type { ComponentType, ReactElement } from "react";
 import type { Location } from "../../router/history";
-import type { ActionFunction as RRActionFunction, ActionFunctionArgs as RRActionFunctionArgs, LoaderFunction as RRLoaderFunction, LoaderFunctionArgs as RRLoaderFunctionArgs, Params, ShouldRevalidateFunction, LoaderFunctionArgs } from "../../router/utils";
-import type { SerializeFrom } from "./components";
-import type { AppData } from "./data";
+import type { ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs, Params, ShouldRevalidateFunction } from "../../router/utils";
 import type { EntryRoute } from "./routes";
 import type { DataRouteMatch } from "../../context";
 import type { LinkDescriptor } from "../../router/links";
+import type { SerializeFrom } from "../../types";
 export interface RouteModules {
     [routeId: string]: RouteModule | undefined;
 }
@@ -24,24 +23,24 @@ export interface RouteModule {
 /**
  * A function that handles data mutations for a route on the client
  */
-export type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<RRActionFunction>;
+export type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
 /**
  * Arguments passed to a route `clientAction` function
  */
-export type ClientActionFunctionArgs = RRActionFunctionArgs<undefined> & {
-    serverAction: <T = AppData>() => Promise<SerializeFrom<T>>;
+export type ClientActionFunctionArgs = ActionFunctionArgs<undefined> & {
+    serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
 };
 /**
  * A function that loads data for a route on the client
  */
-export type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<RRLoaderFunction>) & {
+export type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
     hydrate?: boolean;
 };
 /**
  * Arguments passed to a route `clientLoader` function
  */
-export type ClientLoaderFunctionArgs = RRLoaderFunctionArgs<undefined> & {
-    serverLoader: <T = AppData>() => Promise<SerializeFrom<T>>;
+export type ClientLoaderFunctionArgs = LoaderFunctionArgs<undefined> & {
+    serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
 };
 /**
  * ErrorBoundary to display for this route
@@ -69,33 +68,76 @@ export type LayoutComponent = ComponentType<{
 export interface LinksFunction {
     (): LinkDescriptor[];
 }
-type LoaderFunction = (args: LoaderFunctionArgs & {
-    context: unknown;
-    response?: {
-        status: number | undefined;
-        headers: Headers;
-    };
-}) => ReturnType<RRLoaderFunction>;
-export interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | unknown = unknown> {
+export interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
     id: RouteId;
     pathname: DataRouteMatch["pathname"];
-    data: Loader extends LoaderFunction ? SerializeFrom<Loader> : unknown;
+    data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
     handle?: RouteHandle;
     params: DataRouteMatch["params"];
     meta: MetaDescriptor[];
     error?: unknown;
 }
-export type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> = Array<{
+export type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
     [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
 }[keyof MatchLoaders]>;
-export interface MetaArgs<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
-    data: (Loader extends LoaderFunction ? SerializeFrom<Loader> : AppData) | undefined;
+export interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
     params: Params;
     location: Location;
     matches: MetaMatches<MatchLoaders>;
     error?: unknown;
 }
-export interface MetaFunction<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+/**
+ * A function that returns an array of data objects to use for rendering
+ * metadata HTML tags in a route. These tags are not rendered on descendant
+ * routes in the route hierarchy. In other words, they will only be rendered on
+ * the route in which they are exported.
+ *
+ * @param Loader - The type of the current route's loader function
+ * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+ * function type
+ *
+ * Note that parent route filepaths are relative to the `app/` directory.
+ *
+ * For example, if this meta function is for `/sales/customers/$customerId`:
+ *
+ * ```ts
+ * // app/root.tsx
+ * const loader = () => ({ hello: "world" })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales.tsx
+ * const loader = () => ({ salesCount: 1074 })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers.tsx
+ * const loader = () => ({ customerCount: 74 })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers/$customersId.tsx
+ * import type { Loader as RootLoader } from "../../../root"
+ * import type { Loader as SalesLoader } from "../../sales"
+ * import type { Loader as CustomersLoader } from "../../sales/customers"
+ *
+ * const loader = () => ({ name: "Customer name" })
+ *
+ * const meta: MetaFunction<typeof loader, {
+ *  "root": RootLoader,
+ *  "routes/sales": SalesLoader,
+ *  "routes/sales/customers": CustomersLoader,
+ * }> = ({ data, matches }) => {
+ *   const { name } = data
+ *   //      ^? string
+ *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+ *   //      ^? number
+ *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+ *   //      ^? number
+ *   const { hello } = matches.find((match) => match.id === "root").data
+ *   //      ^? "world"
+ * }
+ * ```
+ */
+export interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
     (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
 }
 export type MetaDescriptor = {

package/dist/lib/dom/ssr/routes.d.ts

@@ -1,11 +1,9 @@
 import type { HydrationState } from "../../router/router";
+import type { RouteManifest } from "../../router/utils";
 import type { RouteModule, RouteModules } from "./routeModules";
 import type { FutureConfig } from "./entry";
 import type { DataRouteObject } from "../../context";
-export interface RouteManifest<Route> {
-    [routeId: string]: Route;
-}
-interface Route {
+export interface Route {
     index?: boolean;
     caseSensitive?: boolean;
     id: string;
@@ -29,4 +27,3 @@ export declare function createServerRoutes(manifest: RouteManifest<EntryRoute>,
 export declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, future: FutureConfig, isSpaMode: boolean): DataRouteObject[];
 export declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
 export declare function shouldHydrateRouteLoader(route: EntryRoute, routeModule: RouteModule, isSpaMode: boolean): boolean;
-export {};

package/dist/lib/hooks.d.ts

@@ -4,6 +4,7 @@ import type { Location, Path, To } from "./router/history";
 import { Action as NavigationType } from "./router/history";
 import type { Blocker, BlockerFunction, RelativeRoutingType, Router as DataRouter, RevalidationState } from "./router/router";
 import type { ParamParseKey, Params, PathMatch, PathPattern, UIMatch } from "./router/utils";
+import type { SerializeFrom } from "./types";
 /**
   Resolves a URL against the current location.
 
@@ -289,7 +290,7 @@ export declare function useMatches(): UIMatch[];
 
   @category Hooks
  */
-export declare function useLoaderData(): unknown;
+export declare function useLoaderData<T = any>(): SerializeFrom<T>;
 /**
   Returns the loader data for a given route by route ID.
 
@@ -317,7 +318,7 @@ export declare function useLoaderData(): unknown;
 
   @category Hooks
  */
-export declare function useRouteLoaderData(routeId: string): unknown;
+export declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
 /**
   Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
 
@@ -343,7 +344,7 @@ export declare function useRouteLoaderData(routeId: string): unknown;
 
   @category Hooks
  */
-export declare function useActionData(): unknown;
+export declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
 /**
   Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
 

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

@@ -516,6 +516,7 @@ export type BlockerFunction = (args: {
     nextLocation: Location;
     historyAction: NavigationType;
 }) => boolean;
+export declare const redirectStatusCodes: Set<number>;
 export declare const IDLE_NAVIGATION: NavigationStates["Idle"];
 export declare const IDLE_FETCHER: FetcherStates["Idle"];
 export declare const IDLE_BLOCKER: BlockerUnblocked;
@@ -537,4 +538,7 @@ export declare function createStaticHandler(routes: AgnosticRouteObject[], opts?
  */
 export declare function getStaticContextFromError(routes: AgnosticDataRouteObject[], context: StaticHandlerContext, error: any): StaticHandlerContext;
 export declare function isDataWithResponseInit(value: any): value is DataWithResponseInit<unknown>;
+export declare function isResponse(value: any): value is Response;
+export declare function isRedirectStatusCode(statusCode: number): boolean;
+export declare function isRedirectResponse(result: any): result is Response;
 export {};

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

@@ -1,4 +1,3 @@
-import type { JsonFunction } from "../server-runtime/responses";
 import type { Location, Path, To } from "./history";
 /**
  * Map of routeId -> data returned from a loader/action/error
@@ -252,7 +251,7 @@ export type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
  * 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>;
+export type RouteManifest<R = AgnosticDataRouteObject> = Record<string, R | 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:
@@ -424,13 +423,6 @@ export declare const normalizeSearch: (search: string) => string;
  * @private
  */
 export declare const normalizeHash: (hash: string) => string;
-/**
- * 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;

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

@@ -1,4 +1,4 @@
-import type { ActionFunctionArgs, LoaderFunctionArgs } from "./routeModules";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "../router/utils";
 import type { AssetsManifest, EntryContext, FutureConfig } from "../dom/ssr/entry";
 import type { ServerRouteManifest } from "./routes";
 import type { AppLoadContext } from "./data";

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

@@ -1,5 +1,5 @@
-import type { CookieParseOptions, CookieSerializeOptions } from "cookie";
-export type { CookieParseOptions, CookieSerializeOptions };
+import type { ParseOptions, SerializeOptions } from "cookie";
+export type { ParseOptions as CookieParseOptions, SerializeOptions as CookieSerializeOptions, };
 export interface CookieSignatureOptions {
     /**
      * An array of secrets that may be used to sign/unsign the value of a cookie.
@@ -11,7 +11,7 @@ export interface CookieSignatureOptions {
      */
     secrets?: string[];
 }
-export type CookieOptions = CookieParseOptions & CookieSerializeOptions & CookieSignatureOptions;
+export type CookieOptions = ParseOptions & SerializeOptions & CookieSignatureOptions;
 /**
  * A HTTP cookie.
  *
@@ -42,12 +42,12 @@ export interface Cookie {
      * 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>;
+    parse(cookieHeader: string | null, options?: ParseOptions): Promise<any>;
     /**
      * Serializes the given value to a string and returns the `Set-Cookie`
      * header.
      */
-    serialize(value: any, options?: CookieSerializeOptions): Promise<string>;
+    serialize(value: any, options?: SerializeOptions): Promise<string>;
 }
 /**
  * Creates a logical container for managing a browser cookie from the server.

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

@@ -1,4 +1,4 @@
-import type { ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs } from "./routeModules";
+import type { LoaderFunction, ActionFunction, LoaderFunctionArgs, ActionFunctionArgs } from "../router/utils";
 /**
  * An object of unknown type for route loaders and actions provided by the
  * server's `getLoadContext()` function.  This is defined as an empty interface
@@ -8,8 +8,4 @@ import type { ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunction
 export interface AppLoadContext {
     [key: string]: unknown;
 }
-/**
- * Data for a route that was returned from a `loader()`.
- */
-export type AppData = unknown;
 export declare function callRouteHandler(handler: LoaderFunction | ActionFunction, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<{} | Response | null>;

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

@@ -1,63 +1,8 @@
-import type { Location } from "../router/history";
-import type { ActionFunction as RRActionFunction, ActionFunctionArgs as RRActionFunctionArgs, AgnosticRouteMatch, LoaderFunction as RRLoaderFunction, LoaderFunctionArgs as RRLoaderFunctionArgs, Params } from "../router/utils";
-import type { AppData, AppLoadContext } from "./data";
-import type { SerializeFrom } from "../dom/ssr/components";
-import type { LinkDescriptor } from "../router/links";
+import type { ActionFunction, LoaderFunction } from "../router/utils";
+import type { ClientActionFunction, ClientLoaderFunction, LinksFunction, MetaFunction } from "../dom/ssr/routeModules";
 export interface RouteModules<RouteModule> {
     [routeId: string]: RouteModule | undefined;
 }
-/**
- * @deprecated Use `LoaderFunctionArgs`/`ActionFunctionArgs` instead
- */
-export type DataFunctionArgs = RRActionFunctionArgs<AppLoadContext> & RRLoaderFunctionArgs<AppLoadContext> & {
-    context: AppLoadContext;
-};
-/**
- * A function that handles data mutations for a route on the server
- */
-export type ActionFunction = (args: ActionFunctionArgs) => ReturnType<RRActionFunction>;
-/**
- * Arguments passed to a route `action` function
- */
-export type ActionFunctionArgs = RRActionFunctionArgs<AppLoadContext> & {
-    context: AppLoadContext;
-};
-/**
- * A function that handles data mutations for a route on the client
- * @private Public API is exported from @react-router/react
- */
-type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<RRActionFunction>;
-/**
- * Arguments passed to a route `clientAction` function
- * @private Public API is exported from @react-router/react
- */
-export type ClientActionFunctionArgs = RRActionFunctionArgs<undefined> & {
-    serverAction: <T = AppData>() => Promise<SerializeFrom<T>>;
-};
-/**
- * A function that loads data for a route on the server
- */
-export type LoaderFunction = (args: LoaderFunctionArgs) => ReturnType<RRLoaderFunction>;
-/**
- * Arguments passed to a route `loader` function
- */
-export type LoaderFunctionArgs = RRLoaderFunctionArgs<AppLoadContext> & {
-    context: AppLoadContext;
-};
-/**
- * A function that loads data for a route on the client
- * @private Public API is exported from @react-router/react
- */
-type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<RRLoaderFunction>) & {
-    hydrate?: boolean;
-};
-/**
- * Arguments passed to a route `clientLoader` function
- * @private Public API is exported from @react-router/react
- */
-export type ClientLoaderFunctionArgs = RRLoaderFunctionArgs<undefined> & {
-    serverLoader: <T = AppData>() => Promise<SerializeFrom<T>>;
-};
 export type HeadersArgs = {
     loaderHeaders: Headers;
     parentHeaders: Headers;
@@ -71,122 +16,6 @@ export type HeadersArgs = {
 export interface HeadersFunction {
     (args: HeadersArgs): Headers | HeadersInit;
 }
-/**
- * A function that defines `<link>` tags to be inserted into the `<head>` of
- * the document on route transitions.
- */
-export interface LinksFunction {
-    (): LinkDescriptor[];
-}
-/**
- * A function that returns an array of data objects to use for rendering
- * metadata HTML tags in a route. These tags are not rendered on descendant
- * routes in the route hierarchy. In other words, they will only be rendered on
- * the route in which they are exported.
- *
- * @param Loader - The type of the current route's loader function
- * @param MatchLoaders - Mapping from a parent route's filepath to its loader
- * function type
- *
- * Note that parent route filepaths are relative to the `app/` directory.
- *
- * For example, if this meta function is for `/sales/customers/$customerId`:
- *
- * ```ts
- * // app/root.tsx
- * const loader = () => {
- *  return json({ hello: "world" } as const)
- * }
- * export type Loader = typeof loader
- *
- * // app/routes/sales.tsx
- * const loader = () => {
- *  return json({ salesCount: 1074 })
- * }
- * export type Loader = typeof loader
- *
- * // app/routes/sales/customers.tsx
- * const loader = () => {
- *   return json({ customerCount: 74 })
- * }
- * export type Loader = typeof loader
- *
- * // app/routes/sales/customers/$customersId.tsx
- * import type { Loader as RootLoader } from "../../../root"
- * import type { Loader as SalesLoader } from "../../sales"
- * import type { Loader as CustomersLoader } from "../../sales/customers"
- *
- * const loader = () => {
- *   return json({ name: "Customer name" })
- * }
- *
- * const meta: MetaFunction<typeof loader, {
- *  "root": RootLoader,
- *  "routes/sales": SalesLoader,
- *  "routes/sales/customers": CustomersLoader,
- * }> = ({ data, matches }) => {
- *   const { name } = data
- *   //      ^? string
- *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
- *   //      ^? number
- *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
- *   //      ^? number
- *   const { hello } = matches.find((match) => match.id === "root").data
- *   //      ^? "world"
- * }
- * ```
- */
-export interface ServerRuntimeMetaFunction<Loader extends LoaderFunction | unknown = unknown, ParentsLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
-    (args: ServerRuntimeMetaArgs<Loader, ParentsLoaders>): ServerRuntimeMetaDescriptor[];
-}
-interface ServerRuntimeMetaMatch<RouteId extends string = string, Loader extends LoaderFunction | unknown = unknown> {
-    id: RouteId;
-    pathname: AgnosticRouteMatch["pathname"];
-    data: Loader extends LoaderFunction ? SerializeFrom<Loader> : unknown;
-    handle?: RouteHandle;
-    params: AgnosticRouteMatch["params"];
-    meta: ServerRuntimeMetaDescriptor[];
-    error?: unknown;
-}
-type ServerRuntimeMetaMatches<MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> = Array<{
-    [K in keyof MatchLoaders]: ServerRuntimeMetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
-}[keyof MatchLoaders]>;
-export interface ServerRuntimeMetaArgs<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
-    data: (Loader extends LoaderFunction ? SerializeFrom<Loader> : AppData) | undefined;
-    params: Params;
-    location: Location;
-    matches: ServerRuntimeMetaMatches<MatchLoaders>;
-    error?: unknown;
-}
-export type ServerRuntimeMetaDescriptor = {
-    charSet: "utf-8";
-} | {
-    title: string;
-} | {
-    name: string;
-    content: string;
-} | {
-    property: string;
-    content: string;
-} | {
-    httpEquiv: string;
-    content: string;
-} | {
-    "script:ld+json": LdJsonObject;
-} | {
-    tagName: "meta" | "link";
-    [name: string]: string;
-} | {
-    [name: string]: unknown;
-};
-type LdJsonObject = {
-    [Key in string]: LdJsonValue;
-} & {
-    [Key in string]?: LdJsonValue | undefined;
-};
-type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
-type LdJsonPrimitive = string | number | boolean | null;
-type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
 /**
  * An arbitrary object that is associated with a route.
  */
@@ -200,7 +29,7 @@ export interface EntryRouteModule {
     default: any;
     handle?: RouteHandle;
     links?: LinksFunction;
-    meta?: ServerRuntimeMetaFunction;
+    meta?: MetaFunction;
 }
 export interface ServerRouteModule extends EntryRouteModule {
     action?: ActionFunction;
@@ -209,4 +38,3 @@ export interface ServerRouteModule extends EntryRouteModule {
     };
     loader?: LoaderFunction;
 }
-export {};

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

@@ -1,28 +1,8 @@
-import type { AgnosticDataRouteObject } from "../router/utils";
+import type { AgnosticDataRouteObject, RouteManifest } from "../router/utils";
 import type { FutureConfig } from "../dom/ssr/entry";
+import type { Route } from "../dom/ssr/routes";
 import type { ServerRouteModule } from "./routeModules";
-export interface RouteManifest<Route> {
-    [routeId: string]: Route;
-}
 export type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
-export interface Route {
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    path?: string;
-}
-export interface EntryRoute extends Route {
-    hasAction: boolean;
-    hasLoader: boolean;
-    hasClientAction: boolean;
-    hasClientLoader: boolean;
-    hasErrorBoundary: boolean;
-    imports?: string[];
-    css?: string[];
-    module: string;
-    parentId?: string;
-}
 export interface ServerRoute extends Route {
     children: ServerRoute[];
     module: ServerRouteModule;

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

@@ -1,4 +1,4 @@
-import type { CookieParseOptions, CookieSerializeOptions } from "cookie";
+import type { ParseOptions, SerializeOptions } from "cookie";
 import type { Cookie, CookieOptions } from "./cookies";
 /**
  * An object of name/value pairs to be used in the session.
@@ -83,17 +83,17 @@ export interface SessionStorage<Data = SessionData, FlashData = Data> {
      * Session. If there is no session associated with the cookie, this will
      * return a new Session with no data.
      */
-    getSession: (cookieHeader?: string | null, options?: CookieParseOptions) => Promise<Session<Data, FlashData>>;
+    getSession: (cookieHeader?: string | null, options?: ParseOptions) => Promise<Session<Data, FlashData>>;
     /**
      * Stores all data in the Session and returns the Set-Cookie header to be
      * used in the HTTP response.
      */
-    commitSession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
+    commitSession: (session: Session<Data, FlashData>, options?: SerializeOptions) => Promise<string>;
     /**
      * Deletes all data associated with the Session and returns the Set-Cookie
      * header to be used in the HTTP response.
      */
-    destroySession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
+    destroySession: (session: Session<Data, FlashData>, options?: SerializeOptions) => Promise<string>;
 }
 /**
  * SessionIdStorageStrategy is designed to allow anyone to easily build their