react-router 7.18.0 → 8.0.0-pre.1

package/dist/development/vendor/turbo-stream-v2/unflatten.js

@@ -0,0 +1,199 @@
+/**
+ * react-router v8.0.0-pre.1
+ *
+ * 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 { SUPPORTED_ERROR_TYPES } from "../../lib/router/utils.js";
+import { Deferred } from "./utils.js";
+//#region vendor/turbo-stream-v2/unflatten.ts
+const globalObj = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : void 0;
+function unflatten(parsed) {
+	const { hydrated, values } = this;
+	if (typeof parsed === "number") return hydrate.call(this, parsed);
+	if (!Array.isArray(parsed) || !parsed.length) throw new SyntaxError();
+	const startIndex = values.length;
+	for (const value of parsed) values.push(value);
+	hydrated.length = values.length;
+	return hydrate.call(this, startIndex);
+}
+function hydrate(index) {
+	const { hydrated, values, deferred, plugins } = this;
+	let result;
+	const stack = [[index, (v) => {
+		result = v;
+	}]];
+	let postRun = [];
+	while (stack.length > 0) {
+		const [index, set] = stack.pop();
+		switch (index) {
+			case -7:
+				set(void 0);
+				continue;
+			case -5:
+				set(null);
+				continue;
+			case -2:
+				set(NaN);
+				continue;
+			case -6:
+				set(Infinity);
+				continue;
+			case -3:
+				set(-Infinity);
+				continue;
+			case -4:
+				set(-0);
+				continue;
+		}
+		if (hydrated[index]) {
+			set(hydrated[index]);
+			continue;
+		}
+		const value = values[index];
+		if (!value || typeof value !== "object") {
+			hydrated[index] = value;
+			set(value);
+			continue;
+		}
+		if (Array.isArray(value)) if (typeof value[0] === "string") {
+			const [type, b, c] = value;
+			switch (type) {
+				case "D":
+					set(hydrated[index] = new Date(b));
+					continue;
+				case "U":
+					set(hydrated[index] = new URL(b));
+					continue;
+				case "B":
+					set(hydrated[index] = BigInt(b));
+					continue;
+				case "R":
+					set(hydrated[index] = new RegExp(b, c));
+					continue;
+				case "Y":
+					set(hydrated[index] = Symbol.for(b));
+					continue;
+				case "S":
+					const newSet = /* @__PURE__ */ new Set();
+					hydrated[index] = newSet;
+					for (let i = value.length - 1; i > 0; i--) stack.push([value[i], (v) => {
+						newSet.add(v);
+					}]);
+					set(newSet);
+					continue;
+				case "M":
+					const map = /* @__PURE__ */ new Map();
+					hydrated[index] = map;
+					for (let i = value.length - 2; i > 0; i -= 2) {
+						const r = [];
+						stack.push([value[i + 1], (v) => {
+							r[1] = v;
+						}]);
+						stack.push([value[i], (k) => {
+							r[0] = k;
+						}]);
+						postRun.push(() => {
+							map.set(r[0], r[1]);
+						});
+					}
+					set(map);
+					continue;
+				case "N":
+					const obj = Object.create(null);
+					hydrated[index] = obj;
+					for (const key of Object.keys(b).reverse()) {
+						const r = [];
+						stack.push([b[key], (v) => {
+							r[1] = v;
+						}]);
+						stack.push([Number(key.slice(1)), (k) => {
+							r[0] = k;
+						}]);
+						postRun.push(() => {
+							obj[r[0]] = r[1];
+						});
+					}
+					set(obj);
+					continue;
+				case "P":
+					if (hydrated[b]) set(hydrated[index] = hydrated[b]);
+					else {
+						const d = new Deferred();
+						deferred[b] = d;
+						set(hydrated[index] = d.promise);
+					}
+					continue;
+				case "E":
+					const [, message, errorType] = value;
+					let error = errorType && globalObj && SUPPORTED_ERROR_TYPES.includes(errorType) && errorType in globalObj && typeof globalObj[errorType] === "function" ? new globalObj[errorType](message) : new Error(message);
+					hydrated[index] = error;
+					set(error);
+					continue;
+				case "Z":
+					set(hydrated[index] = hydrated[b]);
+					continue;
+				default:
+					if (Array.isArray(plugins)) {
+						const r = [];
+						const vals = value.slice(1);
+						for (let i = 0; i < vals.length; i++) {
+							const v = vals[i];
+							stack.push([v, (v) => {
+								r[i] = v;
+							}]);
+						}
+						postRun.push(() => {
+							for (const plugin of plugins) {
+								const result = plugin(value[0], ...r);
+								if (result) {
+									set(hydrated[index] = result.value);
+									return;
+								}
+							}
+							throw new SyntaxError();
+						});
+						continue;
+					}
+					throw new SyntaxError();
+			}
+		} else {
+			const array = [];
+			hydrated[index] = array;
+			for (let i = 0; i < value.length; i++) {
+				const n = value[i];
+				if (n !== -1) stack.push([n, (v) => {
+					array[i] = v;
+				}]);
+			}
+			set(array);
+			continue;
+		}
+		else {
+			const object = {};
+			hydrated[index] = object;
+			for (const key of Object.keys(value).reverse()) {
+				const r = [];
+				stack.push([value[key], (v) => {
+					r[1] = v;
+				}]);
+				stack.push([Number(key.slice(1)), (k) => {
+					r[0] = k;
+				}]);
+				postRun.push(() => {
+					object[r[0]] = r[1];
+				});
+			}
+			set(object);
+			continue;
+		}
+	}
+	while (postRun.length > 0) postRun.pop()();
+	return result;
+}
+//#endregion
+export { unflatten };

package/dist/development/vendor/turbo-stream-v2/utils.js

@@ -0,0 +1,39 @@
+/**
+ * react-router v8.0.0-pre.1
+ *
+ * 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
+ */
+//#region vendor/turbo-stream-v2/utils.ts
+var Deferred = class {
+	promise;
+	resolve;
+	reject;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+	}
+};
+function createLineSplittingTransform() {
+	const decoder = new TextDecoder();
+	let leftover = "";
+	return new TransformStream({
+		transform(chunk, controller) {
+			const str = decoder.decode(chunk, { stream: true });
+			const parts = (leftover + str).split("\n");
+			leftover = parts.pop() || "";
+			for (const part of parts) controller.enqueue(part);
+		},
+		flush(controller) {
+			if (leftover) controller.enqueue(leftover);
+		}
+	});
+}
+//#endregion
+export { Deferred, createLineSplittingTransform };

package/dist/production/dom-export.d.ts

@@ -1,173 +1,7 @@
-import * as React from 'react';
-import { RouterProviderProps as RouterProviderProps$1, RouterInit, ClientOnErrorFunction } from 'react-router';
-import { C as ClientInstrumentation } from './instrumentation-Dkmpzd13.js';
-export { D as unstable_DecodeActionFunction, a as unstable_DecodeFormStateFunction, b as unstable_DecodeReplyFunction, R as unstable_RSCHydratedRouter, d as unstable_RSCManifestPayload, e as unstable_RSCPayload, f as unstable_RSCRenderPayload, c as unstable_createCallServer } from './browser-B2PdsXXH.js';
-import './data-CjO11-hU.js';
 
-type RouterProviderProps = Omit<RouterProviderProps$1, "flushSync">;
-declare function RouterProvider(props: RouterProviderProps): React.JSX.Element;
-
-/**
- * Props for the {@link dom.HydratedRouter} component.
- *
- * @category Types
- */
-interface HydratedRouterProps {
-    /**
-     * Context factory function to be passed through to {@link createBrowserRouter}.
-     * This function will be called to create a fresh `context` instance on each
-     * navigation/fetch and made available to
-     * [`clientAction`](../../start/framework/route-module#clientAction)/[`clientLoader`](../../start/framework/route-module#clientLoader)
-     * functions.
-     */
-    getContext?: RouterInit["getContext"];
-    /**
-     * Array of instrumentation objects allowing you to instrument the router and
-     * individual routes prior to router initialization (and on any subsequently
-     * added routes via `route.lazy` or `patchRoutesOnNavigation`).  This is
-     * mostly useful for observability such as wrapping navigations, fetches,
-     * as well as route loaders/actions/middlewares with logging and/or performance
-     * tracing. See the [docs](../../how-to/instrumentation) for more information.
-     *
-     * ```tsx
-     * const logging = {
-     *   router({ instrument }) {
-     *     instrument({
-     *       navigate: (impl, { to }) => logExecution(`navigate ${to}`, impl),
-     *       fetch: (impl, { to }) => logExecution(`fetch ${to}`, impl)
-     *     });
-     *   },
-     *   route({ instrument, id }) {
-     *     instrument({
-     *       middleware: (impl, { request }) => logExecution(
-     *         `middleware ${request.url} (route ${id})`,
-     *         impl
-     *       ),
-     *       loader: (impl, { request }) => logExecution(
-     *         `loader ${request.url} (route ${id})`,
-     *         impl
-     *       ),
-     *       action: (impl, { request }) => logExecution(
-     *         `action ${request.url} (route ${id})`,
-     *         impl
-     *       ),
-     *     })
-     *   }
-     * };
-     *
-     * async function logExecution(label: string, impl: () => Promise<void>) {
-     *   let start = performance.now();
-     *   console.log(`start ${label}`);
-     *   await impl();
-     *   let duration = Math.round(performance.now() - start);
-     *   console.log(`end ${label} (${duration}ms)`);
-     * }
-     *
-     * startTransition(() => {
-     *   hydrateRoot(
-     *     document,
-     *     <HydratedRouter instrumentations={[logging]} />
-     *   );
-     * });
-     * ```
-     */
-    instrumentations?: ClientInstrumentation[];
-    /**
-     * An error handler function that will be called for any middleware, loader, action,
-     * or render errors that are encountered in your application.  This is useful for
-     * logging or reporting errors instead of in the {@link ErrorBoundary} because it's not
-     * subject to re-rendering and will only run one time per error.
-     *
-     * The `errorInfo` parameter is passed along from
-     * [`componentDidCatch`](https://react.dev/reference/react/Component#componentdidcatch)
-     * and is only present for render errors.
-     *
-     * ```tsx
-     * <HydratedRouter onError={(error, info) => {
-     *   let { location, params, pattern, errorInfo } = info;
-     *   console.error(error, location, errorInfo);
-     *   reportToErrorService(error, location, errorInfo);
-     * }} />
-     * ```
-     */
-    onError?: ClientOnErrorFunction;
-    /**
-     * Control whether router state updates are internally wrapped in
-     * [`React.startTransition`](https://react.dev/reference/react/startTransition).
-     *
-     * - When left `undefined`, all state updates are wrapped in
-     *   `React.startTransition`
-     *   - This can lead to buggy behaviors if you are wrapping your own
-     *     navigations/fetchers in `startTransition`.
-     * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
-     *   in `React.startTransition` and router state changes will be wrapped in
-     *   `React.startTransition` and also sent through
-     *   [`useOptimistic`](https://react.dev/reference/react/useOptimistic) to
-     *   surface mid-navigation router state changes to the UI.
-     * - When set to `false`, the router will not leverage `React.startTransition` or
-     *   `React.useOptimistic` on any navigations or state changes.
-     *
-     * For more information, please see the [docs](../../explanation/react-transitions).
-     */
-    useTransitions?: boolean;
-}
-/**
- * Framework-mode router component to be used to hydrate a router from a
- * {@link ServerRouter}. See [`entry.client.tsx`](../framework-conventions/entry.client.tsx).
- *
- * @public
- * @category Framework Routers
- * @mode framework
- * @param props Props
- * @param {dom.HydratedRouterProps.getContext} props.getContext n/a
- * @param {dom.HydratedRouterProps.onError} props.onError n/a
- * @returns A React element that represents the hydrated application.
- */
-declare function HydratedRouter(props: HydratedRouterProps): React.JSX.Element;
-
-declare global {
-    interface Window {
-        __FLIGHT_DATA: any[];
-    }
-}
-/**
- * Get the prerendered [RSC](https://react.dev/reference/rsc/server-components)
- * stream for hydration. Usually passed directly to your
- * `react-server-dom-xyz/client`'s `createFromReadableStream`.
- *
- * @example
- * import { startTransition, StrictMode } from "react";
- * import { hydrateRoot } from "react-dom/client";
- * import {
- *   unstable_getRSCStream as getRSCStream,
- *   unstable_RSCHydratedRouter as RSCHydratedRouter,
- * } from "react-router";
- * import type { unstable_RSCPayload as RSCPayload } from "react-router";
- *
- * createFromReadableStream(getRSCStream()).then(
- *   (payload: RSCServerPayload) => {
- *     startTransition(async () => {
- *       hydrateRoot(
- *         document,
- *         <StrictMode>
- *           <RSCHydratedRouter {...props} />
- *         </StrictMode>,
- *         {
- *           // Options
- *         }
- *       );
- *     });
- *   }
- * );
- *
- * @name unstable_getRSCStream
- * @public
- * @category RSC
- * @mode data
- * @returns A [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
- * that contains the [RSC](https://react.dev/reference/rsc/server-components)
- * data for hydration.
- */
-declare function getRSCStream(): ReadableStream;
-
-export { HydratedRouter, type HydratedRouterProps, RouterProvider, type RouterProviderProps, getRSCStream as unstable_getRSCStream };
+import { RouterProvider, RouterProviderProps } from "./lib/dom-export/dom-router-provider.js";
+import { DecodeActionFunction, DecodeFormStateFunction, DecodeReplyFunction, RSCManifestPayload, RSCPayload, RSCRenderPayload } from "./lib/rsc/server.rsc.js";
+import { RSCHydratedRouter, createCallServer } from "./lib/rsc/browser.js";
+import { HydratedRouter, HydratedRouterProps } from "./lib/dom-export/hydrated-router.js";
+import { getRSCStream } from "./lib/rsc/html-stream/browser.js";
+export { HydratedRouter, type HydratedRouterProps, RouterProvider, type RouterProviderProps, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, createCallServer as unstable_createCallServer, getRSCStream as unstable_getRSCStream };