react-router 0.0.0-experimental-e5dac68cb → 0.0.0-experimental-59413d9ab

package/dist/development/browser-DYcG-QSM.d.mts

@@ -0,0 +1,141 @@
+import * as React from 'react';
+import { p as ActionFunction, C as ClientActionFunction, q as ClientLoaderFunction, r as HeadersFunction, s as LinksFunction, t as LoaderFunction, M as MetaFunction, u as ShouldRevalidateFunction, L as Location, g as Params, h as Router } from './route-data-Csr8hE3v.mjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+type ServerContext = {
+    redirect?: Response;
+};
+declare global {
+    var ___reactRouterServerStorage___: AsyncLocalStorage<ServerContext> | undefined;
+}
+type ServerRouteObjectBase = {
+    action?: ActionFunction;
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: React.ComponentType<any>;
+    handle?: any;
+    headers?: HeadersFunction;
+    HydrateFallback?: React.ComponentType<any>;
+    Layout?: React.ComponentType<any>;
+    links?: LinksFunction;
+    loader?: LoaderFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+type ServerRouteObject = ServerRouteObjectBase & {
+    id: string;
+    path?: string;
+    Component?: React.ComponentType<any>;
+    lazy?: () => Promise<ServerRouteObjectBase & ({
+        default?: React.ComponentType<any>;
+        Component?: never;
+    } | {
+        default?: never;
+        Component?: React.ComponentType<any>;
+    })>;
+} & ({
+    index: true;
+} | {
+    children?: ServerRouteObject[];
+});
+type RenderedRoute = {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    element?: React.ReactElement | false;
+    errorElement?: React.ReactElement;
+    handle?: any;
+    hasAction: boolean;
+    hasComponent: boolean;
+    hasErrorBoundary: boolean;
+    hasLoader: boolean;
+    hydrateFallbackElement?: React.ReactElement;
+    id: string;
+    index?: boolean;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    parentId?: string;
+    path?: string;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+type ServerRouteMatch = RenderedRoute & {
+    params: Params;
+    pathname: string;
+    pathnameBase: string;
+};
+type ServerRenderPayload = {
+    type: "render";
+    actionData: Record<string, any> | null;
+    basename?: string;
+    errors: Record<string, any> | null;
+    loaderData: Record<string, any>;
+    location: Location;
+    matches: ServerRouteMatch[];
+    patches?: RenderedRoute[];
+    nonce?: string;
+    formState?: unknown;
+};
+type ServerManifestPayload = {
+    type: "manifest";
+    patches: RenderedRoute[];
+};
+type ServerActionPayload = {
+    type: "action";
+    actionResult: Promise<unknown>;
+    rerender?: Promise<ServerRenderPayload | ServerRedirectPayload>;
+};
+type ServerRedirectPayload = {
+    type: "redirect";
+    status: number;
+    location: string;
+    replace: boolean;
+    reload: boolean;
+    actionResult?: Promise<unknown>;
+};
+type ServerPayload = ServerRenderPayload | ServerManifestPayload | ServerActionPayload | ServerRedirectPayload;
+type ServerMatch = {
+    statusCode: number;
+    headers: Headers;
+    payload: ServerPayload;
+};
+type DecodeCallServerFunction = (id: string, reply: FormData | string) => Promise<() => Promise<unknown>>;
+type DecodeFormActionFunction = (formData: FormData) => Promise<() => Promise<void>>;
+type DecodeFormStateFunction = (result: unknown, formData: FormData) => unknown;
+declare function matchRSCServerRequest({ decodeCallServer, decodeFormAction, decodeFormState, onError, request, routes, generateResponse, }: {
+    decodeCallServer?: DecodeCallServerFunction;
+    decodeFormAction?: DecodeFormActionFunction;
+    decodeFormState?: DecodeFormStateFunction;
+    onError?: (error: unknown) => void;
+    request: Request;
+    routes: ServerRouteObject[];
+    generateResponse: (match: ServerMatch) => Response;
+}): Promise<Response>;
+
+type DecodeServerResponseFunction = (body: ReadableStream<Uint8Array>) => Promise<ServerPayload>;
+type EncodeActionFunction = (args: unknown[]) => Promise<BodyInit>;
+declare global {
+    interface Window {
+        __router: Router;
+        __routerInitialized: boolean;
+        __routerActionID: number;
+    }
+}
+declare function createCallServer({ decode, encodeAction, fetch: fetchImplementation, }: {
+    decode: DecodeServerResponseFunction;
+    encodeAction: EncodeActionFunction;
+    fetch?: (request: Request) => Promise<Response>;
+}): (id: string, args: unknown[]) => Promise<unknown>;
+declare function RSCHydratedRouter({ decode, fetch: fetchImplementation, payload, routeDiscovery, }: {
+    decode: DecodeServerResponseFunction;
+    fetch?: (request: Request) => Promise<Response>;
+    payload: ServerPayload;
+    routeDiscovery?: "eager" | "lazy";
+}): React.JSX.Element;
+
+declare global {
+    interface Window {
+        __FLIGHT_DATA: any[];
+    }
+}
+declare function getServerStream(): ReadableStream<any>;
+
+export { type DecodeServerResponseFunction as D, type EncodeActionFunction as E, RSCHydratedRouter as R, type ServerPayload as S, type DecodeCallServerFunction as a, type DecodeFormActionFunction as b, createCallServer as c, type ServerManifestPayload as d, type ServerMatch as e, type ServerRenderPayload as f, getServerStream as g, type RenderedRoute as h, type ServerRouteMatch as i, type ServerRouteObject as j, matchRSCServerRequest as m };

package/dist/development/chunk-5D3KTOSM.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});/**
+ * react-router v0.0.0-experimental-59413d9ab
+ *
+ * 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
+ */
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+
+
+
+
+exports.__privateGet = __privateGet; exports.__privateAdd = __privateAdd;