react-router 0.0.0-experimental-e6fb6e074 → 0.0.0-experimental-5bbc45fb6

package/dist/development/index.mjs

@@ -0,0 +1,246 @@
+/**
+ * react-router v0.0.0-experimental-5bbc45fb6
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import {
+  Action,
+  Await,
+  BrowserRouter,
+  DataRouterContext,
+  DataRouterStateContext,
+  ErrorResponseImpl,
+  FetchersContext,
+  Form,
+  FrameworkContext,
+  HashRouter,
+  HistoryRouter,
+  IDLE_BLOCKER,
+  IDLE_FETCHER,
+  IDLE_NAVIGATION,
+  Link,
+  Links,
+  LocationContext,
+  MemoryRouter,
+  Meta,
+  NavLink,
+  Navigate,
+  NavigationContext,
+  Outlet,
+  PrefetchPageLinks,
+  RemixErrorBoundary,
+  Route,
+  RouteContext,
+  Router,
+  RouterProvider,
+  Routes,
+  Scripts,
+  ScrollRestoration,
+  ServerMode,
+  ServerRouter,
+  SingleFetchRedirectSymbol,
+  StaticRouter,
+  StaticRouterProvider,
+  ViewTransitionContext,
+  createBrowserHistory,
+  createBrowserRouter,
+  createClientRoutes,
+  createClientRoutesWithHMRRevalidationOptOut,
+  createCookie,
+  createCookieSessionStorage,
+  createHashRouter,
+  createMemoryRouter,
+  createMemorySessionStorage,
+  createPath,
+  createRequestHandler,
+  createRouter,
+  createRoutesFromChildren,
+  createRoutesFromElements,
+  createRoutesStub,
+  createSearchParams,
+  createSession,
+  createSessionStorage,
+  createStaticHandler,
+  createStaticRouter,
+  data,
+  decodeViaTurboStream,
+  deserializeErrors,
+  generatePath,
+  getHydrationData,
+  getPatchRoutesOnNavigationFunction,
+  getTurboStreamSingleFetchDataStrategy,
+  href,
+  hydrationRouteProperties,
+  invariant,
+  isCookie,
+  isRouteErrorResponse,
+  isSession,
+  mapRouteProperties,
+  matchPath,
+  matchRoutes,
+  parsePath,
+  redirect,
+  redirectDocument,
+  renderMatches,
+  replace,
+  resolvePath,
+  setDevServerHooks,
+  shouldHydrateRouteLoader,
+  unstable_RouterContextProvider,
+  unstable_createContext,
+  useActionData,
+  useAsyncError,
+  useAsyncValue,
+  useBeforeUnload,
+  useBlocker,
+  useFetcher,
+  useFetchers,
+  useFogOFWarDiscovery,
+  useFormAction,
+  useHref,
+  useInRouterContext,
+  useLinkClickHandler,
+  useLoaderData,
+  useLocation,
+  useMatch,
+  useMatches,
+  useNavigate,
+  useNavigation,
+  useNavigationType,
+  useOutlet,
+  useOutletContext,
+  useParams,
+  usePrompt,
+  useResolvedPath,
+  useRevalidator,
+  useRouteError,
+  useRouteLoaderData,
+  useRoutes,
+  useScrollRestoration,
+  useSearchParams,
+  useSubmit,
+  useViewTransitionState
+} from "./chunk-EKICUOCX.mjs";
+export {
+  Await,
+  BrowserRouter,
+  Form,
+  HashRouter,
+  IDLE_BLOCKER,
+  IDLE_FETCHER,
+  IDLE_NAVIGATION,
+  Link,
+  Links,
+  MemoryRouter,
+  Meta,
+  NavLink,
+  Navigate,
+  Action as NavigationType,
+  Outlet,
+  PrefetchPageLinks,
+  Route,
+  Router,
+  RouterProvider,
+  Routes,
+  Scripts,
+  ScrollRestoration,
+  ServerRouter,
+  StaticRouter,
+  StaticRouterProvider,
+  DataRouterContext as UNSAFE_DataRouterContext,
+  DataRouterStateContext as UNSAFE_DataRouterStateContext,
+  ErrorResponseImpl as UNSAFE_ErrorResponseImpl,
+  FetchersContext as UNSAFE_FetchersContext,
+  FrameworkContext as UNSAFE_FrameworkContext,
+  LocationContext as UNSAFE_LocationContext,
+  NavigationContext as UNSAFE_NavigationContext,
+  RemixErrorBoundary as UNSAFE_RemixErrorBoundary,
+  RouteContext as UNSAFE_RouteContext,
+  ServerMode as UNSAFE_ServerMode,
+  SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol,
+  ViewTransitionContext as UNSAFE_ViewTransitionContext,
+  createBrowserHistory as UNSAFE_createBrowserHistory,
+  createClientRoutes as UNSAFE_createClientRoutes,
+  createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
+  createRouter as UNSAFE_createRouter,
+  decodeViaTurboStream as UNSAFE_decodeViaTurboStream,
+  deserializeErrors as UNSAFE_deserializeErrors,
+  getHydrationData as UNSAFE_getHydrationData,
+  getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction,
+  getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy,
+  hydrationRouteProperties as UNSAFE_hydrationRouteProperties,
+  invariant as UNSAFE_invariant,
+  mapRouteProperties as UNSAFE_mapRouteProperties,
+  shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader,
+  useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery,
+  useScrollRestoration as UNSAFE_useScrollRestoration,
+  createBrowserRouter,
+  createCookie,
+  createCookieSessionStorage,
+  createHashRouter,
+  createMemoryRouter,
+  createMemorySessionStorage,
+  createPath,
+  createRequestHandler,
+  createRoutesFromChildren,
+  createRoutesFromElements,
+  createRoutesStub,
+  createSearchParams,
+  createSession,
+  createSessionStorage,
+  createStaticHandler,
+  createStaticRouter,
+  data,
+  generatePath,
+  href,
+  isCookie,
+  isRouteErrorResponse,
+  isSession,
+  matchPath,
+  matchRoutes,
+  parsePath,
+  redirect,
+  redirectDocument,
+  renderMatches,
+  replace,
+  resolvePath,
+  HistoryRouter as unstable_HistoryRouter,
+  unstable_RouterContextProvider,
+  unstable_createContext,
+  setDevServerHooks as unstable_setDevServerHooks,
+  usePrompt as unstable_usePrompt,
+  useActionData,
+  useAsyncError,
+  useAsyncValue,
+  useBeforeUnload,
+  useBlocker,
+  useFetcher,
+  useFetchers,
+  useFormAction,
+  useHref,
+  useInRouterContext,
+  useLinkClickHandler,
+  useLoaderData,
+  useLocation,
+  useMatch,
+  useMatches,
+  useNavigate,
+  useNavigation,
+  useNavigationType,
+  useOutlet,
+  useOutletContext,
+  useParams,
+  useResolvedPath,
+  useRevalidator,
+  useRouteError,
+  useRouteLoaderData,
+  useRoutes,
+  useSearchParams,
+  useSubmit,
+  useViewTransitionState
+};

package/dist/development/lib/types/internal.d.mts

@@ -0,0 +1,275 @@
+import { R as Register } from '../../register-e9PGCFx1.mjs';
+import { aV as Normalize, aW as ServerDataFrom, aX as ClientDataFrom, aY as Func, aE as LinkDescriptor, E as Equal, L as Location, aB as MetaDescriptor, aZ as unstable_MiddlewareNextFunction, ac as unstable_RouterContextProvider, s as MiddlewareEnabled, t as AppLoadContext, a_ as Pretty } from '../../route-data-BwJdBC92.mjs';
+import 'react';
+
+type AnyRoutes = Record<string, {
+    parentId?: string;
+    path?: string;
+    index?: boolean;
+    file: string;
+    params: Record<string, string | undefined>;
+}>;
+type RoutesPre = Register extends {
+    routesPre: infer RegisteredRoutes extends AnyRoutes;
+} ? RegisteredRoutes : AnyRoutes;
+type RouteId = keyof RoutesPre;
+type GetParents<Id extends RouteId> = RoutesPre[Id] extends {
+    parentId: infer P extends RouteId;
+} ? [
+    ...GetParents<P>,
+    P
+] : [
+];
+type _GetChildren<Id extends RouteId> = {
+    [K in RouteId]: RoutesPre[K] extends {
+        parentId: Id;
+    } ? RoutesPre[K] extends {
+        index: true;
+    } ? [K] : RoutesPre[K] extends {
+        path: undefined;
+    } ? [K, ...GetChildren<K>] : [
+        K
+    ] | [K, ...GetChildren<K>] : [
+    ];
+}[RouteId];
+type GetChildren<Id extends RouteId> = _GetChildren<Id> extends [] ? [] : Exclude<_GetChildren<Id>, []>;
+type GetBranch<Id extends RouteId> = [
+    ...GetParents<Id>,
+    Id,
+    ..._GetChildren<Id>
+];
+type Branches = {
+    [Id in RouteId]: GetBranch<Id>;
+};
+type PartialParams = {
+    [Id in RouteId]: RoutesPre[Id]["params"];
+};
+type BranchParams<Branch extends Array<RouteId>> = Branch extends [
+    infer Id extends RouteId,
+    ...infer Ids extends Array<RouteId>
+] ? PartialParams[Id] & BranchParams<Ids> : {};
+type Params = {
+    [Id in RouteId]: Normalize<BranchParams<Branches[Id]>>;
+};
+
+type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
+type MaybePromise<T> = T | Promise<T>;
+type RouteModule = {
+    meta?: Func;
+    links?: Func;
+    headers?: Func;
+    loader?: Func;
+    clientLoader?: Func;
+    action?: Func;
+    clientAction?: Func;
+    HydrateFallback?: Func;
+    default?: Func;
+    ErrorBoundary?: Func;
+    [key: string]: unknown;
+};
+type Props = {
+    params: unknown;
+    loaderData: unknown;
+    actionData: unknown;
+};
+type RouteInfo = Props & {
+    parents: Props[];
+    module: RouteModule;
+};
+type MetaMatch<T extends Props> = Pretty<Pick<T, "params"> & {
+    pathname: string;
+    meta: MetaDescriptor[];
+    data: T["loaderData"];
+    handle?: unknown;
+    error?: unknown;
+}>;
+type MetaMatches<T extends Props[]> = T extends [infer F extends Props, ...infer R extends Props[]] ? [MetaMatch<F>, ...MetaMatches<R>] : Array<MetaMatch<RouteInfo> | undefined>;
+type CreateMetaArgs<T extends RouteInfo> = {
+    /** This is the current router `Location` object. This is useful for generating tags for routes at specific paths or query parameters. */
+    location: Location;
+    /** {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route. */
+    params: T["params"];
+    /** The return value for this route's server loader function */
+    data: T["loaderData"];
+    /** Thrown errors that trigger error boundaries will be passed to the meta function. This is useful for generating metadata for error pages. */
+    error?: unknown;
+    /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react_router.UIMatch.html route matches}, including parent route matches. */
+    matches: MetaMatches<[...T["parents"], T]>;
+};
+type MetaDescriptors = MetaDescriptor[];
+type HeadersArgs = {
+    loaderHeaders: Headers;
+    parentHeaders: Headers;
+    actionHeaders: Headers;
+    errorHeaders: Headers | undefined;
+};
+type IsHydrate<ClientLoader> = ClientLoader extends {
+    hydrate: true;
+} ? true : ClientLoader extends {
+    hydrate: false;
+} ? false : false;
+type CreateLoaderData<T extends RouteModule> = _CreateLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
+    HydrateFallback: Func;
+} ? true : false>;
+type _CreateLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [
+    HasHydrateFallback,
+    ClientLoaderHydrate
+] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [
+    IsDefined<ClientLoaderData>,
+    IsDefined<ServerLoaderData>
+] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
+type CreateActionData<T extends RouteModule> = _CreateActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
+type _CreateActionData<ServerActionData, ClientActionData> = Awaited<[
+    IsDefined<ServerActionData>,
+    IsDefined<ClientActionData>
+] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
+type ClientDataFunctionArgs<T extends RouteInfo> = {
+    /**
+     * A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the URL, the method, the "content-type" header, and the request body from the request.
+     *
+     * @note Because client data functions are called before a network request is made, the Request object does not include the headers which the browser automatically adds. React Router infers the "content-type" header from the enc-type of the form that performed the submission.
+     **/
+    request: Request;
+    /**
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export function clientLoader({
+     *   params,
+     * }: Route.ClientLoaderArgs) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: T["params"];
+    /**
+     * When `future.unstable_middleware` is not enabled, this is undefined.
+     *
+     * When `future.unstable_middleware` is enabled, this is an instance of
+     * `unstable_RouterContextProvider` and can be used to access context values
+     * from your route middlewares.  You may pass in initial context values in your
+     * `<HydratedRouter unstable_getContext>` prop
+     */
+    context: unstable_RouterContextProvider;
+};
+type ServerDataFunctionArgs<T extends RouteInfo> = {
+    /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the url, method, headers (such as cookies), and request body from the request. */
+    request: Request;
+    /**
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export function loader({
+     *   params,
+     * }: Route.LoaderArgs) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: T["params"];
+    /**
+     * Without `future.unstable_middleware` enabled, this is the context passed in
+     * to your server adapter's `getLoadContext` function. It's a way to bridge the
+     * gap between the adapter's request/response API with your React Router app.
+     * It is only applicable if you are using a custom server adapter.
+     *
+     * With `future.unstable_middleware` enabled, this is an instance of
+     * `unstable_RouterContextProvider` and can be used for type-safe access to
+     * context value set in your route middlewares.  If you are using a custom
+     * server adapter, you may provide an initial set of context values from your
+     * `getLoadContext` function.
+     */
+    context: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext;
+};
+type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
+type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<undefined>) => MaybePromise<void>;
+type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T>;
+type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T> & {
+    /** This is an asynchronous function to get the data from the server loader for this route. On client-side navigations, this will make a {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server loader. If you opt-into running your clientLoader on hydration, then this function will return the data that was already loaded on the server (via Promise.resolve). */
+    serverLoader: () => Promise<ServerDataFrom<T["module"]["loader"]>>;
+};
+type CreateServerActionArgs<T extends RouteInfo> = ServerDataFunctionArgs<T>;
+type CreateClientActionArgs<T extends RouteInfo> = ClientDataFunctionArgs<T> & {
+    /** This is an asynchronous function that makes the {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server action for this route. */
+    serverAction: () => Promise<ServerDataFrom<T["module"]["action"]>>;
+};
+type CreateHydrateFallbackProps<T extends RouteInfo> = {
+    params: T["params"];
+    loaderData?: T["loaderData"];
+    actionData?: T["actionData"];
+};
+type Match<T extends Props> = Pretty<Pick<T, "params"> & {
+    pathname: string;
+    data: T["loaderData"];
+    handle: unknown;
+}>;
+type Matches<T extends Props[]> = T extends [infer F extends Props, ...infer R extends Props[]] ? [Match<F>, ...Matches<R>] : Array<Match<Props> | undefined>;
+type CreateComponentProps<T extends RouteInfo> = {
+    /**
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export default function Component({
+     *   params,
+     * }: Route.ComponentProps) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: T["params"];
+    /** The data returned from the `loader` or `clientLoader` */
+    loaderData: T["loaderData"];
+    /** The data returned from the `action` or `clientAction` following an action submission. */
+    actionData?: T["actionData"];
+    /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react_router.UIMatch.html route matches}, including parent route matches. */
+    matches: Matches<[...T["parents"], T]>;
+};
+type CreateErrorBoundaryProps<T extends RouteInfo> = {
+    /**
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export function ErrorBoundary({
+     *   params,
+     * }: Route.ErrorBoundaryProps) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: T["params"];
+    error: unknown;
+    loaderData?: T["loaderData"];
+    actionData?: T["actionData"];
+};
+type RouteModuleAnnotations<Info extends RouteInfo> = {
+    LinkDescriptors: LinkDescriptor[];
+    LinksFunction: () => LinkDescriptor[];
+    MetaArgs: CreateMetaArgs<Info>;
+    MetaDescriptors: MetaDescriptors;
+    MetaFunction: (args: CreateMetaArgs<Info>) => MetaDescriptors;
+    HeadersArgs: HeadersArgs;
+    HeadersFunction: (args: HeadersArgs) => Headers | HeadersInit;
+    unstable_MiddlewareFunction: CreateServerMiddlewareFunction<Info>;
+    unstable_ClientMiddlewareFunction: CreateClientMiddlewareFunction<Info>;
+    LoaderArgs: CreateServerLoaderArgs<Info>;
+    ClientLoaderArgs: CreateClientLoaderArgs<Info>;
+    ActionArgs: CreateServerActionArgs<Info>;
+    ClientActionArgs: CreateClientActionArgs<Info>;
+    HydrateFallbackProps: CreateHydrateFallbackProps<Info>;
+    ComponentProps: CreateComponentProps<Info>;
+    ErrorBoundaryProps: CreateErrorBoundaryProps<Info>;
+};
+
+export type { CreateActionData, CreateLoaderData, Params, RouteModuleAnnotations };