npm - react-router - Versions diffs - 6.27.0 → 7.0.0-pre.1 - Mend

react-router 6.27.0 → 7.0.0-pre.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (84) hide show

package/CHANGELOG.md +309 -11
package/README.md +1 -14
package/dist/dom-export.d.ts +3 -0
package/dist/dom-export.mjs +205 -0
package/dist/dom-export.mjs.map +1 -0
package/dist/index.d.ts +74 -29
package/dist/index.mjs +11543 -0
package/dist/index.mjs.map +1 -0
package/dist/lib/components.d.ts +250 -35
package/dist/lib/context.d.ts +18 -5
package/dist/lib/dom/dom.d.ts +123 -0
package/dist/lib/dom/global.d.ts +40 -0
package/dist/lib/dom/lib.d.ts +940 -0
package/dist/lib/dom/server.d.ts +41 -0
package/dist/lib/dom/ssr/components.d.ts +123 -0
package/dist/lib/dom/ssr/data.d.ts +7 -0
package/dist/lib/dom/ssr/entry.d.ts +47 -0
package/dist/lib/dom/ssr/errorBoundaries.d.ts +36 -0
package/dist/lib/dom/ssr/errors.d.ts +2 -0
package/dist/lib/dom/ssr/fallback.d.ts +2 -0
package/dist/lib/dom/ssr/fog-of-war.d.ts +28 -0
package/dist/lib/dom/ssr/invariant.d.ts +2 -0
package/dist/lib/dom/ssr/links.d.ts +25 -0
package/dist/lib/dom/ssr/markup.d.ts +5 -0
package/dist/lib/dom/ssr/routeModules.d.ts +141 -0
package/dist/lib/dom/ssr/routes-test-stub.d.ts +59 -0
package/dist/lib/dom/ssr/routes.d.ts +32 -0
package/dist/lib/dom/ssr/server.d.ts +16 -0
package/dist/lib/dom/ssr/single-fetch.d.ts +37 -0
package/dist/lib/dom-export/dom-router-provider.d.ts +5 -0
package/dist/lib/dom-export/hydrated-router.d.ts +5 -0
package/dist/lib/dom-export.d.ts +3 -0
package/dist/lib/hooks.d.ts +286 -57
package/dist/lib/router/history.d.ts +253 -0
package/dist/lib/router/links.d.ts +104 -0
package/dist/lib/router/router.d.ts +540 -0
package/dist/lib/router/utils.d.ts +505 -0
package/dist/lib/server-runtime/build.d.ts +38 -0
package/dist/lib/server-runtime/cookies.d.ts +62 -0
package/dist/lib/server-runtime/crypto.d.ts +2 -0
package/dist/lib/server-runtime/data.d.ts +15 -0
package/dist/lib/server-runtime/dev.d.ts +8 -0
package/dist/lib/server-runtime/entry.d.ts +3 -0
package/dist/lib/server-runtime/errors.d.ts +51 -0
package/dist/lib/server-runtime/headers.d.ts +3 -0
package/dist/lib/server-runtime/invariant.d.ts +2 -0
package/dist/lib/server-runtime/jsonify.d.ts +33 -0
package/dist/lib/server-runtime/markup.d.ts +1 -0
package/dist/lib/server-runtime/mode.d.ts +9 -0
package/dist/lib/server-runtime/responses.d.ts +37 -0
package/dist/lib/server-runtime/routeMatching.d.ts +8 -0
package/dist/lib/server-runtime/routeModules.d.ts +212 -0
package/dist/lib/server-runtime/routes.d.ts +31 -0
package/dist/lib/server-runtime/server.d.ts +5 -0
package/dist/lib/server-runtime/serverHandoff.d.ts +11 -0
package/dist/lib/server-runtime/sessions/cookieStorage.d.ts +19 -0
package/dist/lib/server-runtime/sessions/memoryStorage.d.ts +17 -0
package/dist/lib/server-runtime/sessions.d.ts +140 -0
package/dist/lib/server-runtime/single-fetch.d.ts +30 -0
package/dist/lib/server-runtime/typecheck.d.ts +4 -0
package/dist/lib/server-runtime/warnings.d.ts +1 -0
package/dist/lib/types.d.ts +76 -0
package/dist/lib/types.mjs +10 -0
package/dist/main-dom-export.js +19 -0
package/dist/main.js +1 -1
package/dist/react-router-dom.development.js +199 -0
package/dist/react-router-dom.development.js.map +1 -0
package/dist/react-router-dom.production.min.js +12 -0
package/dist/react-router-dom.production.min.js.map +1 -0
package/dist/react-router.development.js +12281 -1141
package/dist/react-router.development.js.map +1 -1
package/dist/react-router.production.min.js +2 -2
package/dist/react-router.production.min.js.map +1 -1
package/dist/umd/react-router-dom.development.js +241 -0
package/dist/umd/react-router-dom.development.js.map +1 -0
package/dist/umd/react-router-dom.production.min.js +12 -0
package/dist/umd/react-router-dom.production.min.js.map +1 -0
package/dist/umd/react-router.development.js +12467 -1238
package/dist/umd/react-router.development.js.map +1 -1
package/dist/umd/react-router.production.min.js +2 -2
package/dist/umd/react-router.production.min.js.map +1 -1
package/package.json +35 -6
package/dist/index.js +0 -1467
package/dist/index.js.map +0 -1

package/dist/lib/dom/server.d.ts ADDED Viewed

@@ -0,0 +1,41 @@
+import * as React from "react";
+import type { Location } from "../router/history";
+import type { FutureConfig, Router as DataRouter, CreateStaticHandlerOptions as RouterCreateStaticHandlerOptions, StaticHandlerContext } from "../router/router";
+import type { RouteObject } from "../context";
+export interface StaticRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    location: Partial<Location> | string;
+}
+/**
+ * A `<Router>` that may not navigate to any other location. This is useful
+ * on the server where there is no stateful UI.
+ *
+ * @category Router Components
+ */
+export declare function StaticRouter({ basename, children, location: locationProp, }: StaticRouterProps): React.JSX.Element;
+export interface StaticRouterProviderProps {
+    context: StaticHandlerContext;
+    router: DataRouter;
+    hydrate?: boolean;
+    nonce?: string;
+}
+/**
+ * A Data Router that may not navigate to any other location. This is useful
+ * on the server where there is no stateful UI.
+ *
+ * @category Router Components
+ */
+export declare function StaticRouterProvider({ context, router, hydrate, nonce, }: StaticRouterProviderProps): React.JSX.Element;
+type CreateStaticHandlerOptions = Omit<RouterCreateStaticHandlerOptions, "mapRouteProperties">;
+/**
+ * @category Utils
+ */
+export declare function createStaticHandler(routes: RouteObject[], opts?: CreateStaticHandlerOptions): import("../router/router").StaticHandler;
+/**
+ * @category Routers
+ */
+export declare function createStaticRouter(routes: RouteObject[], context: StaticHandlerContext, opts?: {
+    future?: Partial<FutureConfig>;
+}): DataRouter;
+export {};

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

@@ -0,0 +1,123 @@
+import type { FocusEventHandler, MouseEventHandler, TouchEventHandler } from "react";
+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;
+/**
+ * Defines the discovery behavior of the link:
+ *
+ * - "render" - default, discover the route when the link renders
+ * - "none" - don't eagerly discover, only discover if the link is clicked
+ */
+export type DiscoverBehavior = "render" | "none";
+/**
+ * Defines the prefetching behavior of the link:
+ *
+ * - "none": Never fetched
+ * - "intent": Fetched when the user focuses or hovers the link
+ * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link is in the viewport
+ */
+export type PrefetchBehavior = "intent" | "render" | "none" | "viewport";
+interface PrefetchHandlers {
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+    onMouseEnter?: MouseEventHandler;
+    onMouseLeave?: MouseEventHandler;
+    onTouchStart?: TouchEventHandler;
+}
+export declare function usePrefetchBehavior<T extends HTMLAnchorElement>(prefetch: PrefetchBehavior, theirElementProps: PrefetchHandlers): [boolean, React.RefObject<T>, PrefetchHandlers];
+export declare function composeEventHandlers<EventType extends React.SyntheticEvent | Event>(theirHandler: ((event: EventType) => any) | undefined, ourHandler: (event: EventType) => any): (event: EventType) => any;
+/**
+  Renders all of the `<link>` tags created by route module {@link LinksFunction} export. You should render it inside the `<head>` of your document.
+  ```tsx
+  import { Links } from "react-router";
+  export default function Root() {
+    return (
+      <html>
+        <head>
+          <Links />
+        </head>
+        <body></body>
+      </html>
+    );
+  }
+  ```
+  @category Components
+ */
+export declare function Links(): React.JSX.Element;
+/**
+  Renders `<link rel=prefetch|modulepreload>` tags for modules and data of another page to enable an instant navigation to that page. {@link LinkProps.prefetch | `<Link prefetch>`} uses this internally, but you can render it to prefetch a page for any other reason.
+  ```tsx
+  import { PrefetchPageLinks } from "react-router"
+  <PrefetchPageLinks page="/absolute/path" />
+  ```
+  For example, you may render one of this as the user types into a search field to prefetch search results before they click through to their selection.
+  @category Components
+ */
+export declare function PrefetchPageLinks({ page, ...dataLinkProps }: PageLinkDescriptor): React.JSX.Element | null;
+/**
+  Renders all the `<meta>` tags created by route module {@link MetaFunction} exports. You should render it inside the `<head>` of your HTML.
+  ```tsx
+  import { Meta } from "react-router";
+  export default function Root() {
+    return (
+      <html>
+        <head>
+          <Meta />
+        </head>
+      </html>
+    );
+  }
+  ```
+  @category Components
+ */
+export declare function Meta(): React.JSX.Element;
+/**
+  A couple common attributes:
+  - `<Scripts crossOrigin>` for hosting your static assets on a different server than your app.
+  - `<Scripts nonce>` to support a [content security policy for scripts](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) with [nonce-sources](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/Sources#sources) for your `<script>` tags.
+  You cannot pass through attributes such as `async`, `defer`, `src`, `type`, `noModule` because they are managed by React Router internally.
+  @category Types
+ */
+export type ScriptsProps = Omit<React.HTMLProps<HTMLScriptElement>, "children" | "async" | "defer" | "src" | "type" | "noModule" | "dangerouslySetInnerHTML" | "suppressHydrationWarning">;
+/**
+  Renders the client runtime of your app. It should be rendered inside the `<body>` of the document.
+  ```tsx
+  import { Scripts } from "react-router";
+  export default function Root() {
+    return (
+      <html>
+        <head />
+        <body>
+          <Scripts />
+        </body>
+      </html>
+    );
+  }
+  ```
+  If server rendering, you can omit `<Scripts/>` and the app will work as a traditional web app without JavaScript, relying solely on HTML and browser behaviors.
+  @category Components
+ */
+export declare function Scripts(props: ScriptsProps): React.JSX.Element | null;
+export declare function mergeRefs<T = any>(...refs: Array<React.MutableRefObject<T> | React.LegacyRef<T>>): React.RefCallback<T>;
+export {};

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

@@ -0,0 +1,7 @@
+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 ADDED Viewed

@@ -0,0 +1,47 @@
+import type { StaticHandlerContext } from "../../router/router";
+import type { RouteManifest, EntryRoute } from "./routes";
+import type { RouteModules } from "./routeModules";
+type SerializedError = {
+    message: string;
+    stack?: string;
+};
+export interface FrameworkContextObject {
+    manifest: AssetsManifest;
+    routeModules: RouteModules;
+    criticalCss?: string;
+    serverHandoffString?: string;
+    future: FutureConfig;
+    isSpaMode: boolean;
+    abortDelay?: number;
+    serializeError?(error: Error): SerializedError;
+    renderMeta?: {
+        didRenderScripts?: boolean;
+        streamCache?: Record<number, Promise<void> & {
+            result?: {
+                done: boolean;
+                value: string;
+            };
+            error?: unknown;
+        }>;
+    };
+}
+export interface EntryContext extends FrameworkContextObject {
+    staticHandlerContext: StaticHandlerContext;
+    serverHandoffStream?: ReadableStream<Uint8Array>;
+}
+export interface FutureConfig {
+}
+export interface AssetsManifest {
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    routes: RouteManifest<EntryRoute>;
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number;
+        runtime: string;
+    };
+}
+export {};

package/dist/lib/dom/ssr/errorBoundaries.d.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import * as React from "react";
+import type { Location } from "../../router/history";
+type RemixErrorBoundaryProps = React.PropsWithChildren<{
+    location: Location;
+    isOutsideRemixApp?: boolean;
+    error?: Error;
+}>;
+type RemixErrorBoundaryState = {
+    error: null | Error;
+    location: Location;
+};
+export declare class RemixErrorBoundary extends React.Component<RemixErrorBoundaryProps, RemixErrorBoundaryState> {
+    constructor(props: RemixErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    static getDerivedStateFromProps(props: RemixErrorBoundaryProps, state: RemixErrorBoundaryState): {
+        error: Error | null;
+        location: Location<any>;
+    };
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+}
+/**
+ * When app's don't provide a root level ErrorBoundary, we default to this.
+ */
+export declare function RemixRootDefaultErrorBoundary({ error, isOutsideRemixApp, }: {
+    error: unknown;
+    isOutsideRemixApp?: boolean;
+}): React.JSX.Element;
+export declare function BoundaryShell({ title, renderScripts, isOutsideRemixApp, children, }: {
+    title: string;
+    renderScripts?: boolean;
+    isOutsideRemixApp?: boolean;
+    children: React.ReactNode | React.ReactNode[];
+}): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+export {};

package/dist/lib/dom/ssr/errors.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { RouterState } from "../../router/router";
2	+ export declare function deserializeErrors(errors: RouterState["errors"]): RouterState["errors"];

package/dist/lib/dom/ssr/fallback.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import * as React from "react";
2	+ export declare function RemixRootDefaultHydrateFallback(): React.JSX.Element;

package/dist/lib/dom/ssr/fog-of-war.d.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import type { PatchRoutesOnNavigationFunction } from "../../context";
+import type { Router as DataRouter } from "../../router/router";
+import type { AssetsManifest } from "./entry";
+import type { RouteModules } from "./routeModules";
+declare global {
+    interface Navigator {
+        connection?: {
+            saveData: boolean;
+        };
+    }
+}
+export declare function isFogOfWarEnabled(isSpaMode: boolean): boolean;
+export declare function getPartialManifest(manifest: AssetsManifest, router: DataRouter): {
+    routes: {};
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number | undefined;
+        runtime: string;
+    } | undefined;
+};
+export declare function getPatchRoutesOnNavigationFunction(manifest: AssetsManifest, routeModules: RouteModules, isSpaMode: boolean, basename: string | undefined): PatchRoutesOnNavigationFunction | undefined;
+export declare function useFogOFWarDiscovery(router: DataRouter, manifest: AssetsManifest, routeModules: RouteModules, isSpaMode: boolean): void;
+export declare function fetchAndApplyManifestPatches(paths: string[], manifest: AssetsManifest, routeModules: RouteModules, isSpaMode: boolean, basename: string | undefined, patchRoutes: DataRouter["patchRoutes"]): Promise<void>;

package/dist/lib/dom/ssr/invariant.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export default function invariant(value: boolean, message?: string): asserts value;
2	+ export default function invariant<T>(value: T \| null \| undefined, message?: string): asserts value is T;

package/dist/lib/dom/ssr/links.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import type { Location } from "../../router/history";
+import type { AgnosticDataRouteMatch } from "../../router/utils";
+import type { AssetsManifest } from "./entry";
+import type { RouteModules, RouteModule } from "./routeModules";
+import type { EntryRoute } from "./routes";
+import type { HtmlLinkDescriptor, LinkDescriptor, PageLinkDescriptor } from "../../router/links";
+/**
+ * Gets all the links for a set of matches. The modules are assumed to have been
+ * loaded already.
+ */
+export declare function getKeyedLinksForMatches(matches: AgnosticDataRouteMatch[], routeModules: RouteModules, manifest: AssetsManifest): KeyedLinkDescriptor[];
+export declare function prefetchStyleLinks(route: EntryRoute, routeModule: RouteModule): Promise<void>;
+export declare function isPageLinkDescriptor(object: any): object is PageLinkDescriptor;
+export type KeyedHtmlLinkDescriptor = {
+    key: string;
+    link: HtmlLinkDescriptor;
+};
+export declare function getKeyedPrefetchLinks(matches: AgnosticDataRouteMatch[], manifest: AssetsManifest, routeModules: RouteModules): Promise<KeyedHtmlLinkDescriptor[]>;
+export declare function getNewMatchesForLinks(page: string, nextMatches: AgnosticDataRouteMatch[], currentMatches: AgnosticDataRouteMatch[], manifest: AssetsManifest, location: Location, mode: "data" | "assets"): AgnosticDataRouteMatch[];
+export declare function getModuleLinkHrefs(matches: AgnosticDataRouteMatch[], manifestPatch: AssetsManifest): string[];
+type KeyedLinkDescriptor<Descriptor extends LinkDescriptor = LinkDescriptor> = {
+    key: string;
+    link: Descriptor;
+};
+export {};

package/dist/lib/dom/ssr/markup.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export declare function escapeHtml(html: string): string;
+export interface SafeHtml {
+    __html: string;
+}
+export declare function createHtml(html: string): SafeHtml;

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

@@ -0,0 +1,141 @@
+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 { EntryRoute } from "./routes";
+import type { DataRouteMatch } from "../../context";
+import type { LinkDescriptor } from "../../router/links";
+export interface RouteModules {
+    [routeId: string]: RouteModule | undefined;
+}
+export interface RouteModule {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: ErrorBoundaryComponent;
+    HydrateFallback?: HydrateFallbackComponent;
+    Layout?: LayoutComponent;
+    default: RouteComponent;
+    handle?: RouteHandle;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: ShouldRevalidateFunction;
+}
+/**
+ * A function that handles data mutations for a route on the client
+ */
+export type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<RRActionFunction>;
+/**
+ * Arguments passed to a route `clientAction` function
+ */
+export type ClientActionFunctionArgs = RRActionFunctionArgs<undefined> & {
+    serverAction: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * A function that loads data for a route on the client
+ */
+export type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<RRLoaderFunction>) & {
+    hydrate?: boolean;
+};
+/**
+ * Arguments passed to a route `clientLoader` function
+ */
+export type ClientLoaderFunctionArgs = RRLoaderFunctionArgs<undefined> & {
+    serverLoader: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * ErrorBoundary to display for this route
+ */
+export type ErrorBoundaryComponent = ComponentType;
+/**
+ * `<Route HydrateFallback>` component to render on initial loads
+ * when client loaders are present
+ */
+export type HydrateFallbackComponent = ComponentType;
+/**
+ * Optional, root-only `<Route Layout>` component to wrap the root content in.
+ * Useful for defining the <html>/<head>/<body> document shell shared by the
+ * Component, HydrateFallback, and ErrorBoundary
+ */
+export type LayoutComponent = ComponentType<{
+    children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
+}>;
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ *
+ * @see https://remix.run/route/meta
+ */
+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> {
+    id: RouteId;
+    pathname: DataRouteMatch["pathname"];
+    data: Loader extends LoaderFunction ? 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<{
+    [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;
+    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>> {
+    (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
+}
+export type MetaDescriptor = {
+    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;
+/**
+ * A React component that is rendered for a route.
+ */
+export type RouteComponent = ComponentType<{}>;
+/**
+ * An arbitrary object that is associated with a route.
+ *
+ * @see https://remix.run/route/handle
+ */
+export type RouteHandle = unknown;
+export declare function loadRouteModule(route: EntryRoute, routeModulesCache: RouteModules): Promise<RouteModule>;
+export {};

package/dist/lib/dom/ssr/routes-test-stub.d.ts ADDED Viewed

@@ -0,0 +1,59 @@
+import * as React from "react";
+import type { ActionFunction, LoaderFunction } from "../../router/utils";
+import type { IndexRouteObject, NonIndexRouteObject } from "../../context";
+import type { LinksFunction, MetaFunction } from "./routeModules";
+import type { InitialEntry } from "../../router/history";
+import type { HydrationState } from "../../router/router";
+import type { FutureConfig } from "./entry";
+interface StubIndexRouteObject extends Omit<IndexRouteObject, "loader" | "action" | "element" | "errorElement" | "children"> {
+    loader?: LoaderFunction;
+    action?: ActionFunction;
+    children?: StubRouteObject[];
+    meta?: MetaFunction;
+    links?: LinksFunction;
+}
+interface StubNonIndexRouteObject extends Omit<NonIndexRouteObject, "loader" | "action" | "element" | "errorElement" | "children"> {
+    loader?: LoaderFunction;
+    action?: ActionFunction;
+    children?: StubRouteObject[];
+    meta?: MetaFunction;
+    links?: LinksFunction;
+}
+type StubRouteObject = StubIndexRouteObject | StubNonIndexRouteObject;
+interface AppLoadContext {
+    [key: string]: unknown;
+}
+export interface RoutesTestStubProps {
+    /**
+     *  The initial entries in the history stack. This allows you to start a test with
+     *  multiple locations already in the history stack (for testing a back navigation, etc.)
+     *  The test will default to the last entry in initialEntries if no initialIndex is provided.
+     *  e.g. initialEntries={["/home", "/about", "/contact"]}
+     */
+    initialEntries?: InitialEntry[];
+    /**
+     * The initial index in the history stack to render. This allows you to start a test at a specific entry.
+     * It defaults to the last entry in initialEntries.
+     * e.g.
+     *   initialEntries: ["/", "/events/123"]
+     *   initialIndex: 1 // start at "/events/123"
+     */
+    initialIndex?: number;
+    /**
+     *  Used to set the route's initial loader and action data.
+     *  e.g. hydrationData={{
+     *   loaderData: { "/contact": { locale: "en-US" } },
+     *   actionData: { "/login": { errors: { email: "invalid email" } }}
+     *  }}
+     */
+    hydrationData?: HydrationState;
+    /**
+     * Future flags mimicking the settings in remix.config.js
+     */
+    future?: Partial<FutureConfig>;
+}
+/**
+ * @category Utils
+ */
+export declare function createRoutesStub(routes: StubRouteObject[], context?: AppLoadContext): ({ initialEntries, initialIndex, hydrationData, future, }: RoutesTestStubProps) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,32 @@
+import type { HydrationState } from "../../router/router";
+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 {
+    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 declare function createServerRoutes(manifest: RouteManifest<EntryRoute>, routeModules: RouteModules, future: FutureConfig, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, spaModeLazyPromise?: Promise<{
+    Component: () => null;
+}>): DataRouteObject[];
+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/dom/ssr/server.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { ReactElement } from "react";
+import type { EntryContext } from "./entry";
+export interface ServerRouterProps {
+    context: EntryContext;
+    url: string | URL;
+    abortDelay?: number;
+    nonce?: string;
+}
+/**
+ * The entry point for a Remix app when it is rendered on the server (in
+ * `app/entry.server.js`). This component is used to generate the HTML in the
+ * response from the server.
+ *
+ * @category Components
+ */
+export declare function ServerRouter({ context, url, abortDelay, nonce, }: ServerRouterProps): ReactElement;

package/dist/lib/dom/ssr/single-fetch.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import * as React from "react";
+import type { Router as DataRouter } from "../../router/router";
+import type { DataStrategyFunction } from "../../router/utils";
+import type { AssetsManifest, EntryContext } from "./entry";
+import type { RouteModules } from "./routeModules";
+export declare const SingleFetchRedirectSymbol: unique symbol;
+export type SingleFetchRedirectResult = {
+    redirect: string;
+    status: number;
+    revalidate: boolean;
+    reload: boolean;
+    replace: boolean;
+};
+export type SingleFetchResult = {
+    data: unknown;
+} | {
+    error: unknown;
+} | SingleFetchRedirectResult;
+export type SingleFetchResults = {
+    [key: string]: SingleFetchResult;
+    [SingleFetchRedirectSymbol]?: SingleFetchRedirectResult;
+};
+interface StreamTransferProps {
+    context: EntryContext;
+    identifier: number;
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    textDecoder: TextDecoder;
+    nonce?: string;
+}
+export declare function StreamTransfer({ context, identifier, reader, textDecoder, nonce, }: StreamTransferProps): React.JSX.Element | null;
+export declare function getSingleFetchDataStrategy(manifest: AssetsManifest, routeModules: RouteModules, getRouter: () => DataRouter): DataStrategyFunction;
+export declare function singleFetchUrl(reqUrl: URL | string): URL;
+export declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
+    done: Promise<undefined>;
+    value: unknown;
+}>;
+export {};

package/dist/lib/dom-export/dom-router-provider.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { RouterProviderProps as BaseRouterProviderProps } from "react-router";
+export { HydratedRouter } from "./hydrated-router";
+export type RouterProviderProps = Omit<BaseRouterProviderProps, "flushSync">;
+export declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">): React.JSX.Element;

package/dist/lib/dom-export/hydrated-router.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import * as React from "react";
+/**
+ * @category Router Components
+ */
+export declare function HydratedRouter(): React.JSX.Element;

package/dist/lib/dom-export.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export type { RouterProviderProps } from "./lib/dom-export/dom-router-provider";
+export { RouterProvider } from "./lib/dom-export/dom-router-provider";
+export { HydratedRouter } from "./lib/dom-export/hydrated-router";