react-router 0.0.0-experimental-c7dd3d3a → 0.0.0-experimental-e53172d16

package/dist/lib/components.d.ts

@@ -1,11 +1,22 @@
-import type { InitialEntry, LazyRouteFunction, Location, RelativeRoutingType, Router as RemixRouter, To, TrackedPromise } from "@remix-run/router";
-import { Action as NavigationType } from "@remix-run/router";
+import type { FutureConfig as RouterFutureConfig, HydrationState, InitialEntry, LazyRouteFunction, Location, RelativeRoutingType, Router as RemixRouter, To, TrackedPromise, unstable_DataStrategyFunction } from "./router";
+import { Action as NavigationType } from "./router";
 import * as React from "react";
 import type { IndexRouteObject, Navigator, NonIndexRouteObject, RouteMatch, RouteObject } from "./context";
 export interface FutureConfig {
     v7_relativeSplatPath: boolean;
     v7_startTransition: boolean;
 }
+export declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
+    hasErrorBoundary: boolean;
+};
+export declare function createMemoryRouter(routes: RouteObject[], opts?: {
+    basename?: string;
+    future?: Partial<Omit<RouterFutureConfig, "v7_prependBasename">>;
+    hydrationData?: HydrationState;
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+    unstable_dataStrategy?: unstable_DataStrategyFunction;
+}): RemixRouter;
 export interface RouterProviderProps {
     fallbackElement?: React.ReactNode;
     router: RemixRouter;

package/dist/lib/context.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import type { AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, History, LazyRouteFunction, Location, Action as NavigationType, RelativeRoutingType, Router, StaticHandlerContext, To, TrackedPromise } from "@remix-run/router";
+import type { AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, History, LazyRouteFunction, Location, Action as NavigationType, RelativeRoutingType, Router, StaticHandlerContext, To, TrackedPromise } from "./router";
 export interface IndexRouteObject {
     caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
     path?: AgnosticIndexRouteObject["path"];
@@ -52,7 +52,7 @@ export interface DataRouterContextObject extends Omit<NavigationContextObject, "
     staticContext?: StaticHandlerContext;
 }
 export declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
-export declare const DataRouterStateContext: React.Context<import("@remix-run/router").RouterState | null>;
+export declare const DataRouterStateContext: React.Context<import("./router").RouterState | null>;
 export declare const AwaitContext: React.Context<TrackedPromise | null>;
 export interface NavigateOptions {
     replace?: boolean;

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

@@ -0,0 +1,104 @@
+import type { FormEncType, HTMLFormMethod, RelativeRoutingType } from "../router";
+export declare const defaultMethod: HTMLFormMethod;
+export declare function isHtmlElement(object: any): object is HTMLElement;
+export declare function isButtonElement(object: any): object is HTMLButtonElement;
+export declare function isFormElement(object: any): object is HTMLFormElement;
+export declare function isInputElement(object: any): object is HTMLInputElement;
+type LimitedMouseEvent = Pick<MouseEvent, "button" | "metaKey" | "altKey" | "ctrlKey" | "shiftKey">;
+export declare function shouldProcessLinkClick(event: LimitedMouseEvent, target?: string): boolean;
+export type ParamKeyValuePair = [string, string];
+export type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
+/**
+ * Creates a URLSearchParams object using the given initializer.
+ *
+ * This is identical to `new URLSearchParams(init)` except it also
+ * supports arrays as values in the object form of the initializer
+ * instead of just strings. This is convenient when you need multiple
+ * values for a given key, but don't want to use an array initializer.
+ *
+ * For example, instead of:
+ *
+ *   let searchParams = new URLSearchParams([
+ *     ['sort', 'name'],
+ *     ['sort', 'price']
+ *   ]);
+ *
+ * you can do:
+ *
+ *   let searchParams = createSearchParams({
+ *     sort: ['name', 'price']
+ *   });
+ */
+export declare function createSearchParams(init?: URLSearchParamsInit): URLSearchParams;
+export declare function getSearchParamsForLocation(locationSearch: string, defaultSearchParams: URLSearchParams | null): URLSearchParams;
+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;
+export type SubmitTarget = HTMLFormElement | HTMLButtonElement | HTMLInputElement | FormData | URLSearchParams | JsonValue | null;
+export interface SubmitOptions {
+    /**
+     * The HTTP method used to submit the form. Overrides `<form method>`.
+     * Defaults to "GET".
+     */
+    method?: HTMLFormMethod;
+    /**
+     * The action URL path used to submit the form. Overrides `<form action>`.
+     * Defaults to the path of the current route.
+     */
+    action?: string;
+    /**
+     * The encoding used to submit the form. Overrides `<form encType>`.
+     * Defaults to "application/x-www-form-urlencoded".
+     */
+    encType?: FormEncType;
+    /**
+     * Indicate a specific fetcherKey to use when using navigate=false
+     */
+    fetcherKey?: string;
+    /**
+     * navigate=false will use a fetcher instead of a navigation
+     */
+    navigate?: boolean;
+    /**
+     * Set `true` to replace the current entry in the browser's history stack
+     * instead of creating a new one (i.e. stay on "the same page"). Defaults
+     * to `false`.
+     */
+    replace?: boolean;
+    /**
+     * State object to add to the history stack entry for this navigation
+     */
+    state?: any;
+    /**
+     * Determines whether the form action is relative to the route hierarchy or
+     * the pathname.  Use this if you want to opt out of navigating the route
+     * hierarchy and want to instead route based on /-delimited URL segments
+     */
+    relative?: RelativeRoutingType;
+    /**
+     * In browser-based environments, prevent resetting scroll after this
+     * navigation when using the <ScrollRestoration> component
+     */
+    preventScrollReset?: boolean;
+    /**
+     * Enable flushSync for this navigation's state updates
+     */
+    unstable_flushSync?: boolean;
+    /**
+     * Enable view transitions on this submission navigation
+     */
+    unstable_viewTransition?: boolean;
+}
+export declare function getFormSubmissionInfo(target: SubmitTarget, basename: string): {
+    action: string | null;
+    method: string;
+    encType: string;
+    formData: FormData | undefined;
+    body: any;
+};
+export {};

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

@@ -0,0 +1,36 @@
+import type { HydrationState, Router as RemixRouter } from "../router";
+import type { ViewTransition } from "./lib";
+import type { AssetsManifest, FutureConfig as RemixFutureConfig } from "./ssr/entry";
+import type { RouteModules } from "./ssr/routeModules";
+export type WindowRemixContext = {
+    url: string;
+    basename?: string;
+    state: HydrationState;
+    criticalCss?: string;
+    future: RemixFutureConfig;
+    isSpaMode: boolean;
+    stream: ReadableStream<Uint8Array> | undefined;
+    streamController: ReadableStreamDefaultController<Uint8Array>;
+    a?: number;
+    dev?: {
+        port?: number;
+        hmrRuntime?: string;
+    };
+};
+declare global {
+    var __staticRouterHydrationData: HydrationState | undefined;
+    var __reactRouterVersion: string;
+    interface Document {
+        startViewTransition(cb: () => Promise<void> | void): ViewTransition;
+    }
+    var __remixContext: WindowRemixContext | undefined;
+    var __remixManifest: AssetsManifest | undefined;
+    var __remixRouteModules: RouteModules | undefined;
+    var __remixRouter: RemixRouter | undefined;
+    var __remixRevalidation: number | undefined;
+    var __remixClearCriticalCss: (() => void) | undefined;
+    var $RefreshRuntime$: {
+        performReactRefresh: () => void;
+    } | undefined;
+}
+export {};

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

@@ -0,0 +1,304 @@
+import * as React from "react";
+import type { unstable_DataStrategyFunction, Fetcher, FutureConfig as RouterFutureConfig, GetScrollRestorationKeyFunction, History, HTMLFormMethod, HydrationState, Router as RemixRouter, BlockerFunction, Location, RelativeRoutingType, To } from "../router";
+import "./global";
+import type { SubmitOptions, URLSearchParamsInit, SubmitTarget } from "./dom";
+import type { PrefetchBehavior, ScriptProps } from "./ssr/components";
+import type { RouterProviderProps, FutureConfig as RenderFutureConfig } from "../components";
+import type { RouteObject, NavigateOptions } from "../context";
+interface DOMRouterOpts {
+    basename?: string;
+    future?: Partial<Omit<RouterFutureConfig, "v7_prependBasename">>;
+    hydrationData?: HydrationState;
+    unstable_dataStrategy?: unstable_DataStrategyFunction;
+    window?: Window;
+}
+export declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts): RemixRouter;
+export declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts): RemixRouter;
+type ViewTransitionContextObject = {
+    isTransitioning: false;
+} | {
+    isTransitioning: true;
+    flushSync: boolean;
+    currentLocation: Location;
+    nextLocation: Location;
+};
+declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
+export { ViewTransitionContext as UNSAFE_ViewTransitionContext };
+type FetchersContextObject = Map<string, any>;
+declare const FetchersContext: React.Context<FetchersContextObject>;
+export { FetchersContext as UNSAFE_FetchersContext };
+export interface ViewTransition {
+    finished: Promise<void>;
+    ready: Promise<void>;
+    updateCallbackDone: Promise<void>;
+    skipTransition(): void;
+}
+/**
+ * Given a Remix Router instance, render the appropriate UI
+ */
+export declare function RouterProvider({ fallbackElement, router, future, }: RouterProviderProps): React.ReactElement;
+export interface BrowserRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    future?: Partial<RenderFutureConfig>;
+    window?: Window;
+}
+/**
+ * A `<Router>` for use in web browsers. Provides the cleanest URLs.
+ */
+export declare function BrowserRouter({ basename, children, future, window, }: BrowserRouterProps): React.JSX.Element;
+export interface HashRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    future?: Partial<RenderFutureConfig>;
+    window?: Window;
+}
+/**
+ * A `<Router>` for use in web browsers. Stores the location in the hash
+ * portion of the URL so it is not sent to the server.
+ */
+export declare function HashRouter({ basename, children, future, window, }: HashRouterProps): React.JSX.Element;
+export interface HistoryRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    future?: RenderFutureConfig;
+    history: History;
+}
+/**
+ * A `<Router>` that accepts a pre-instantiated history object. It's important
+ * to note that using your own history object is highly discouraged and may add
+ * two versions of the history library to your bundles unless you use the same
+ * version of the history library that React Router uses internally.
+ */
+declare function HistoryRouter({ basename, children, future, history, }: HistoryRouterProps): React.JSX.Element;
+declare namespace HistoryRouter {
+    var displayName: string;
+}
+export { HistoryRouter as unstable_HistoryRouter };
+export interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    prefetch?: PrefetchBehavior;
+    reloadDocument?: boolean;
+    replace?: boolean;
+    state?: any;
+    preventScrollReset?: boolean;
+    relative?: RelativeRoutingType;
+    to: To;
+    unstable_viewTransition?: boolean;
+}
+/**
+ * The public API for rendering a history-aware `<a>`.
+ */
+export declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+type NavLinkRenderProps = {
+    isActive: boolean;
+    isPending: boolean;
+    isTransitioning: boolean;
+};
+export interface NavLinkProps extends Omit<LinkProps, "className" | "style" | "children"> {
+    children?: React.ReactNode | ((props: NavLinkRenderProps) => React.ReactNode);
+    caseSensitive?: boolean;
+    className?: string | ((props: NavLinkRenderProps) => string | undefined);
+    end?: boolean;
+    style?: React.CSSProperties | ((props: NavLinkRenderProps) => React.CSSProperties | undefined);
+}
+/**
+ * A `<Link>` wrapper that knows if it's "active" or not.
+ */
+export declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export interface FetcherFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    /**
+     * The HTTP verb to use when the form is submit. Supports "get", "post",
+     * "put", "delete", "patch".
+     */
+    method?: HTMLFormMethod;
+    /**
+     * `<form encType>` - enhancing beyond the normal string type and limiting
+     * to the built-in browser supported values
+     */
+    encType?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
+    /**
+     * Normal `<form action>` but supports React Router's relative paths.
+     */
+    action?: string;
+    /**
+     * Determines whether the form action is relative to the route hierarchy or
+     * the pathname.  Use this if you want to opt out of navigating the route
+     * hierarchy and want to instead route based on /-delimited URL segments
+     */
+    relative?: RelativeRoutingType;
+    /**
+     * Prevent the scroll position from resetting to the top of the viewport on
+     * completion of the navigation when using the <ScrollRestoration> component
+     */
+    preventScrollReset?: boolean;
+    /**
+     * A function to call when the form is submitted. If you call
+     * `event.preventDefault()` then this form will not do anything.
+     */
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+}
+export interface FormProps extends FetcherFormProps {
+    /**
+     * Indicate a specific fetcherKey to use when using navigate=false
+     */
+    fetcherKey?: string;
+    /**
+     * navigate=false will use a fetcher instead of a navigation
+     */
+    navigate?: boolean;
+    /**
+     * Forces a full document navigation instead of a fetch.
+     */
+    reloadDocument?: boolean;
+    /**
+     * Replaces the current entry in the browser history stack when the form
+     * navigates. Use this if you don't want the user to be able to click "back"
+     * to the page with the form on it.
+     */
+    replace?: boolean;
+    /**
+     * State object to add to the history stack entry for this navigation
+     */
+    state?: any;
+    /**
+     * Enable view transitions on this Form navigation
+     */
+    unstable_viewTransition?: boolean;
+}
+/**
+ * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
+ * that the interaction with the server is with `fetch` instead of new document
+ * requests, allowing components to add nicer UX to the page as the form is
+ * submitted and returns with data.
+ */
+export declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
+export type ScrollRestorationProps = ScriptProps & {
+    getKey?: GetScrollRestorationKeyFunction;
+    storageKey?: string;
+};
+/**
+ * This component will emulate the browser's scroll restoration on location
+ * changes.
+ */
+export declare function ScrollRestoration({ getKey, storageKey, ...props }: ScrollRestorationProps): React.JSX.Element | null;
+export declare namespace ScrollRestoration {
+    var displayName: string;
+}
+/**
+ * Handles the click behavior for router `<Link>` components. This is useful if
+ * you need to create custom `<Link>` components with the same click behavior we
+ * use in our exported `<Link>`.
+ */
+export declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, unstable_viewTransition, }?: {
+    target?: React.HTMLAttributeAnchorTarget;
+    replace?: boolean;
+    state?: any;
+    preventScrollReset?: boolean;
+    relative?: RelativeRoutingType;
+    unstable_viewTransition?: boolean;
+}): (event: React.MouseEvent<E, MouseEvent>) => void;
+/**
+ * A convenient wrapper for reading and writing search parameters via the
+ * URLSearchParams interface.
+ */
+export declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URLSearchParams, SetURLSearchParams];
+export type SetURLSearchParams = (nextInit?: URLSearchParamsInit | ((prev: URLSearchParams) => URLSearchParamsInit), navigateOpts?: NavigateOptions) => void;
+/**
+ * Submits a HTML `<form>` to the server without reloading the page.
+ */
+export interface SubmitFunction {
+    (
+    /**
+     * Specifies the `<form>` to be submitted to the server, a specific
+     * `<button>` or `<input type="submit">` to use to submit the form, or some
+     * arbitrary data to submit.
+     *
+     * Note: When using a `<button>` its `name` and `value` will also be
+     * included in the form data that is submitted.
+     */
+    target: SubmitTarget, 
+    /**
+     * Options that override the `<form>`'s own attributes. Required when
+     * submitting arbitrary data without a backing `<form>`.
+     */
+    options?: SubmitOptions): void;
+}
+/**
+ * Submits a fetcher `<form>` to the server without reloading the page.
+ */
+export interface FetcherSubmitFunction {
+    (target: SubmitTarget, options?: Omit<SubmitOptions, "replace" | "state">): void;
+}
+/**
+ * Returns a function that may be used to programmatically submit a form (or
+ * some arbitrary data) to the server.
+ */
+export declare function useSubmit(): SubmitFunction;
+export declare function useFormAction(action?: string, { relative }?: {
+    relative?: RelativeRoutingType;
+}): string;
+export type FetcherWithComponents<TData> = Fetcher<TData> & {
+    Form: React.ForwardRefExoticComponent<FetcherFormProps & React.RefAttributes<HTMLFormElement>>;
+    submit: FetcherSubmitFunction;
+    load: (href: string, opts?: {
+        unstable_flushSync?: boolean;
+    }) => void;
+};
+/**
+ * Interacts with route loaders and actions without causing a navigation. Great
+ * for any interaction that stays on the same page.
+ */
+export declare function useFetcher<TData = any>({ key, }?: {
+    key?: string;
+}): FetcherWithComponents<TData>;
+/**
+ * Provides all fetchers currently on the page. Useful for layouts and parent
+ * routes that need to provide pending/optimistic UI regarding the fetch.
+ */
+export declare function useFetchers(): (Fetcher & {
+    key: string;
+})[];
+/**
+ * When rendered inside a RouterProvider, will restore scroll positions on navigations
+ */
+declare function useScrollRestoration({ getKey, storageKey, }?: {
+    getKey?: GetScrollRestorationKeyFunction;
+    storageKey?: string;
+}): void;
+export { useScrollRestoration as UNSAFE_useScrollRestoration };
+/**
+ * Setup a callback to be fired on the window's `beforeunload` event. This is
+ * useful for saving some data to `window.localStorage` just before the page
+ * refreshes.
+ *
+ * Note: The `callback` argument should be a function created with
+ * `React.useCallback()`.
+ */
+export declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) => any, options?: {
+    capture?: boolean;
+}): void;
+/**
+ * Wrapper around useBlocker to show a window.confirm prompt to users instead
+ * of building a custom UI with useBlocker.
+ *
+ * Warning: This has *a lot of rough edges* and behaves very differently (and
+ * very incorrectly in some cases) across browsers if user click addition
+ * back/forward navigations while the confirm is open.  Use at your own risk.
+ */
+declare function usePrompt({ when, message, }: {
+    when: boolean | BlockerFunction;
+    message: string;
+}): void;
+export { usePrompt as unstable_usePrompt };
+/**
+ * Return a boolean indicating if there is an active view transition to the
+ * given href.  You can use this value to render CSS classes or viewTransitionName
+ * styles onto your elements
+ *
+ * @param href The destination href
+ * @param [opts.relative] Relative routing type ("route" | "path")
+ */
+declare function useViewTransitionState(to: To, opts?: {
+    relative?: RelativeRoutingType;
+}): boolean;
+export { useViewTransitionState as unstable_useViewTransitionState };

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

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

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

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

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

@@ -0,0 +1,61 @@
+import type { FocusEventHandler, MouseEventHandler, TouchEventHandler } from "react";
+import * as React from "react";
+import type { RemixContextObject } from "./entry";
+import type { PrefetchPageDescriptor } from "./links";
+export type SerializeFrom<D> = D extends () => {} ? Awaited<ReturnType<D>> : D;
+export declare const RemixContext: React.Context<RemixContextObject | undefined>;
+export declare function useRemixContext(): RemixContextObject;
+/**
+ * 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 the `<link>` tags for the current routes.
+ *
+ * @see https://remix.run/components/links
+ */
+export declare function Links(): React.JSX.Element;
+/**
+ * This component renders all the `<link rel="prefetch">` and
+ * `<link rel="modulepreload"/>` tags for all the assets (data, modules, css) of
+ * a given page.
+ *
+ * @param props
+ * @param props.page
+ * @see https://remix.run/components/prefetch-page-links
+ */
+export declare function PrefetchPageLinks({ page, ...dataLinkProps }: PrefetchPageDescriptor): React.JSX.Element | null;
+/**
+ * Renders HTML tags related to metadata for the current route.
+ *
+ * @see https://remix.run/components/meta
+ */
+export declare function Meta(): React.JSX.Element;
+export type ScriptProps = Omit<React.HTMLProps<HTMLScriptElement>, "children" | "async" | "defer" | "src" | "type" | "noModule" | "dangerouslySetInnerHTML" | "suppressHydrationWarning">;
+/**
+ * Renders the `<script>` tags needed for the initial render. Bundles for
+ * additional routes are loaded later as needed.
+ *
+ * @param props Additional properties to add to each script tag that is rendered.
+ * In addition to scripts, \<link rel="modulepreload"> tags receive the crossOrigin
+ * property if provided.
+ *
+ * @see https://remix.run/components/scripts
+ */
+export declare function Scripts(props: ScriptProps): 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/create-remix-stub.d.ts

@@ -0,0 +1,56 @@
+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 RemixStubProps {
+    /**
+     *  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>;
+}
+export declare function createRemixStub(routes: StubRouteObject[], context?: AppLoadContext): ({ initialEntries, initialIndex, hydrationData, future, }: RemixStubProps) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { UNSAFE_DeferredData as DeferredData } from "../../router";
+import "../global";
+/**
+ * Data for a route that was returned from a `loader()`.
+ */
+export type AppData = unknown;
+export declare function isCatchResponse(response: Response): boolean;
+export declare function isErrorResponse(response: any): response is Response;
+export declare function isNetworkErrorResponse(response: any): response is Response;
+export declare function isRedirectResponse(response: Response): boolean;
+export declare function isDeferredResponse(response: Response): boolean;
+export declare function isResponse(value: any): value is Response;
+export declare function isDeferredData(value: any): value is DeferredData;
+export declare function fetchData(request: Request, routeId: string, retry?: number): Promise<Response | Error>;
+export declare function createRequestInit(request: Request): Promise<RequestInit>;
+export declare function parseDeferredReadableStream(stream: ReadableStream<Uint8Array>): Promise<DeferredData>;