react-router 7.15.1 → 8.0.0-pre.0

package/dist/development/lib/types/route-data.d.ts

@@ -0,0 +1,113 @@
+
+import { DataWithResponseInit, RouterContextProvider } from "../router/utils.js";
+import { Equal, Func, IsAny } from "./utils.js";
+import { RouteModule } from "./route-module.js";
+import { unstable_SerializesTo } from "./serializes-to.js";
+import { Serializable } from "../server-runtime/single-fetch.js";
+import { ClientActionFunctionArgs, ClientLoaderFunctionArgs } from "../dom/ssr/routeModules.js";
+
+//#region lib/types/route-data.d.ts
+type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends ((...args: any[]) => unknown) ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? { [K in keyof T]: Serialize<T[K]> } : undefined;
+type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
+type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
+type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
+type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
+type ServerDataFrom<T> = ServerData<DataFrom<T>>;
+type ClientDataFrom<T> = ClientData<DataFrom<T>>;
+type ClientDataFunctionArgs<Params> = {
+  /**
+   * 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;
+  /**
+   * A URL instance representing the application location being navigated to or
+   * fetched.
+   *
+   * In Framework mode, this is a normalized URL with React-Router-specific
+   * implementation details removed (`.data` suffixes, `index`/`_routes` search
+   * params). For the raw incoming URL, use `request.url`.
+   */
+  url: URL;
+  /**
+   * {@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: Params;
+  /**
+   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+   */
+  pattern: string;
+  /**
+   * An instance of `RouterContextProvider` that can be used to access context
+   * values from your route middlewares.  You may pass in initial context values
+   * in your `<HydratedRouter getContext>` prop.
+   */
+  context: Readonly<RouterContextProvider>;
+};
+type ServerDataFunctionArgs<Params> = {
+  /** 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;
+  /**
+   * A URL instance representing the application location being navigated to or
+   * fetched.
+   *
+   * In Framework mode, this is a normalized URL with React-Router-specific
+   * implementation details removed (`.data` suffixes, `index`/`_routes` search
+   * params). For the raw incoming URL, use `request.url`.
+   */
+  url: URL;
+  /**
+   * {@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: Params;
+  /**
+   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+   */
+  pattern: string;
+  /**
+   * An instance of `RouterContextProvider` that can be used for type-safe
+   * access to context values 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: Readonly<RouterContextProvider>;
+};
+type SerializeFrom<T> = T extends ((...args: infer Args) => unknown) ? Args extends [ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
+type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
+type IsHydrate<ClientLoader> = ClientLoader extends {
+  hydrate: true;
+} ? true : ClientLoader extends {
+  hydrate: false;
+} ? false : false;
+type GetLoaderData<T extends RouteModule> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
+  HydrateFallback: Func;
+} ? true : false>;
+type _DataLoaderData<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 GetActionData<T extends RouteModule> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
+type _DataActionData<ServerActionData, ClientActionData> = Awaited<[IsDefined<ServerActionData>, IsDefined<ClientActionData>] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
+//#endregion
+export { ClientDataFunctionArgs, GetActionData, GetLoaderData, SerializeFrom, ServerDataFrom, ServerDataFunctionArgs };

package/dist/development/lib/types/route-module-annotations.d.ts

@@ -0,0 +1,149 @@
+
+import { Location } from "../router/history.js";
+import { DataStrategyResult, MiddlewareNextFunction } from "../router/utils.js";
+import { LinkDescriptor } from "../router/links.js";
+import { Func, Pretty } from "./utils.js";
+import { RouteModule } from "./route-module.js";
+import { ClientDataFunctionArgs, GetLoaderData, ServerDataFrom, ServerDataFunctionArgs } from "./route-data.js";
+import { MetaDescriptor } from "../dom/ssr/routeModules.js";
+
+//#region lib/types/route-module-annotations.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type Props = {
+  params: unknown;
+  loaderData: unknown;
+  actionData: unknown;
+};
+type RouteInfo = Props & {
+  module: RouteModule;
+  matches: Array<MatchInfo>;
+};
+type MatchInfo = {
+  id: string;
+  module: RouteModule;
+};
+type MetaMatch<T extends MatchInfo> = Pretty<{
+  id: T["id"];
+  params: Record<string, string | undefined>;
+  pathname: string;
+  meta: MetaDescriptor[];
+  loaderData: GetLoaderData<T["module"]>;
+  handle?: unknown;
+  error?: unknown;
+}>;
+type MetaMatches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [MetaMatch<F>, ...MetaMatches<R>] : Array<MetaMatch<MatchInfo> | undefined>;
+type HasErrorBoundary<T extends RouteInfo> = T["module"] extends {
+  ErrorBoundary: Func;
+} ? true : false;
+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 */
+  loaderData: T["loaderData"] | (HasErrorBoundary<T> extends true ? undefined : never); /** 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["matches"]>;
+};
+type MetaDescriptors = MetaDescriptor[];
+type HeadersArgs = {
+  loaderHeaders: Headers;
+  parentHeaders: Headers;
+  actionHeaders: Headers;
+  errorHeaders: Headers | undefined;
+};
+type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
+type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Record<string, DataStrategyResult>>) => MaybePromise<Record<string, DataStrategyResult> | void>;
+type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
+type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
+  /** 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["params"]>;
+type CreateClientActionArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
+  /** 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, RSCEnabled extends boolean> = {
+  params: T["params"];
+} & (RSCEnabled extends true ? {
+  /** The data returned from the `loader` */loaderData?: ServerDataFrom<T["module"]["loader"]>; /** The data returned from the `action` following an action submission. */
+  actionData?: ServerDataFrom<T["module"]["action"]>;
+} : {
+  /** 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"];
+});
+type Match<T extends MatchInfo> = Pretty<{
+  id: T["id"];
+  params: Record<string, string | undefined>;
+  pathname: string;
+  loaderData: GetLoaderData<T["module"]>;
+  handle: unknown;
+}>;
+type Matches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [Match<F>, ...Matches<R>] : Array<Match<MatchInfo> | undefined>;
+type CreateComponentProps<T extends RouteInfo, RSCEnabled extends boolean> = {
+  /**
+   * {@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"]; /** 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["matches"]>;
+} & (RSCEnabled extends true ? {
+  /** The data returned from the `loader` */loaderData: ServerDataFrom<T["module"]["loader"]>; /** The data returned from the `action` following an action submission. */
+  actionData?: ServerDataFrom<T["module"]["action"]>;
+} : {
+  /** 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"];
+});
+type CreateErrorBoundaryProps<T extends RouteInfo, RSCEnabled extends boolean> = {
+  /**
+   * {@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;
+} & (RSCEnabled extends true ? {
+  /** The data returned from the `loader` */loaderData?: ServerDataFrom<T["module"]["loader"]>; /** The data returned from the `action` following an action submission. */
+  actionData?: ServerDataFrom<T["module"]["action"]>;
+} : {
+  /** 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"];
+});
+type GetAnnotations<Info extends RouteInfo> = {
+  LinkDescriptors: LinkDescriptor[];
+  LinksFunction: () => LinkDescriptor[];
+  MetaArgs: CreateMetaArgs<Info>;
+  MetaDescriptors: MetaDescriptors;
+  MetaFunction: (args: CreateMetaArgs<Info>) => MetaDescriptors;
+  HeadersArgs: HeadersArgs;
+  HeadersFunction: (args: HeadersArgs) => Headers | HeadersInit;
+  MiddlewareFunction: CreateServerMiddlewareFunction<Info>;
+  ClientMiddlewareFunction: CreateClientMiddlewareFunction<Info>;
+  LoaderArgs: CreateServerLoaderArgs<Info>;
+  ClientLoaderArgs: CreateClientLoaderArgs<Info>;
+  ActionArgs: CreateServerActionArgs<Info>;
+  ClientActionArgs: CreateClientActionArgs<Info>;
+  HydrateFallbackProps: CreateHydrateFallbackProps<Info, false>;
+  ServerHydrateFallbackProps: CreateHydrateFallbackProps<Info, true>;
+  ComponentProps: CreateComponentProps<Info, false>;
+  ServerComponentProps: CreateComponentProps<Info, true>;
+  ErrorBoundaryProps: CreateErrorBoundaryProps<Info, false>;
+  ServerErrorBoundaryProps: CreateErrorBoundaryProps<Info, true>;
+};
+//#endregion
+export { GetAnnotations };

package/dist/development/lib/types/route-module.d.ts

@@ -0,0 +1,19 @@
+
+import { Func } from "./utils.js";
+
+//#region lib/types/route-module.d.ts
+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;
+};
+//#endregion
+export { RouteModule };

package/dist/development/lib/types/serializes-to.d.ts

@@ -0,0 +1,13 @@
+
+//#region lib/types/serializes-to.d.ts
+/**
+ * A brand that can be applied to a type to indicate that it will serialize
+ * to a specific type when transported to the client from a loader.
+ * Only use this if you have additional serialization/deserialization logic
+ * in your application.
+ */
+type unstable_SerializesTo<T> = {
+  unstable__ReactRouter_SerializesTo: [T];
+};
+//#endregion
+export { unstable_SerializesTo };

package/dist/development/lib/types/utils.d.ts

@@ -0,0 +1,11 @@
+
+//#region lib/types/utils.d.ts
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Func = (...args: any[]) => unknown;
+type Pretty<T> = { [K in keyof T]: T[K] } & {};
+type Normalize<T> = _Normalize<UnionKeys<T>, T>;
+type _Normalize<Key extends keyof any, T> = T extends infer U ? Pretty<{ [K in Key as K extends keyof U ? undefined extends U[K] ? never : K : never]: K extends keyof U ? U[K] : never } & { [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never } & { [K in Key as K extends keyof U ? never : K]?: undefined }> : never;
+type UnionKeys<T> = T extends any ? keyof T : never;
+//#endregion
+export { Equal, Func, IsAny, Normalize, Pretty };

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

@@ -0,0 +1,159 @@
+/**
+ * react-router v8.0.0-pre.0
+ *
+ * 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/flatten.ts
+const TIME_LIMIT_MS = 1;
+const getNow = () => Date.now();
+const yieldToMain = () => new Promise((resolve) => setTimeout(resolve, 0));
+async function flatten(input) {
+	const { indices } = this;
+	const existing = indices.get(input);
+	if (existing) return [existing];
+	if (input === void 0) return -7;
+	if (input === null) return -5;
+	if (Number.isNaN(input)) return -2;
+	if (input === Number.POSITIVE_INFINITY) return -6;
+	if (input === Number.NEGATIVE_INFINITY) return -3;
+	if (input === 0 && 1 / input < 0) return -4;
+	const index = this.index++;
+	indices.set(input, index);
+	const stack = [[input, index]];
+	await stringify.call(this, stack);
+	return index;
+}
+async function stringify(stack) {
+	const { deferred, indices, plugins, postPlugins } = this;
+	const str = this.stringified;
+	let lastYieldTime = getNow();
+	const flattenValue = (value) => {
+		const existing = indices.get(value);
+		if (existing) return [existing];
+		if (value === void 0) return -7;
+		if (value === null) return -5;
+		if (Number.isNaN(value)) return -2;
+		if (value === Number.POSITIVE_INFINITY) return -6;
+		if (value === Number.NEGATIVE_INFINITY) return -3;
+		if (value === 0 && 1 / value < 0) return -4;
+		const index = this.index++;
+		indices.set(value, index);
+		stack.push([value, index]);
+		return index;
+	};
+	let i = 0;
+	while (stack.length > 0) {
+		const now = getNow();
+		if (++i % 6e3 === 0 && now - lastYieldTime >= TIME_LIMIT_MS) {
+			await yieldToMain();
+			lastYieldTime = getNow();
+		}
+		const [input, index] = stack.pop();
+		const partsForObj = (obj) => Object.keys(obj).map((k) => `"_${flattenValue(k)}":${flattenValue(obj[k])}`).join(",");
+		let error = null;
+		switch (typeof input) {
+			case "boolean":
+			case "number":
+			case "string":
+				str[index] = JSON.stringify(input);
+				break;
+			case "bigint":
+				str[index] = `["B","${input}"]`;
+				break;
+			case "symbol": {
+				const keyFor = Symbol.keyFor(input);
+				if (!keyFor) error = /* @__PURE__ */ new Error("Cannot encode symbol unless created with Symbol.for()");
+				else str[index] = `["Y",${JSON.stringify(keyFor)}]`;
+				break;
+			}
+			case "object": {
+				if (!input) {
+					str[index] = `-5`;
+					break;
+				}
+				const isArray = Array.isArray(input);
+				let pluginHandled = false;
+				if (!isArray && plugins) for (const plugin of plugins) {
+					const pluginResult = plugin(input);
+					if (Array.isArray(pluginResult)) {
+						pluginHandled = true;
+						const [pluginIdentifier, ...rest] = pluginResult;
+						str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+						if (rest.length > 0) str[index] += `,${rest.map((v) => flattenValue(v)).join(",")}`;
+						str[index] += "]";
+						break;
+					}
+				}
+				if (!pluginHandled) {
+					let result = isArray ? "[" : "{";
+					if (isArray) {
+						for (let i = 0; i < input.length; i++) result += (i ? "," : "") + (i in input ? flattenValue(input[i]) : -1);
+						str[index] = `${result}]`;
+					} else if (input instanceof Date) {
+						const dateTime = input.getTime();
+						str[index] = `["D",${Number.isNaN(dateTime) ? JSON.stringify("invalid") : dateTime}]`;
+					} else if (input instanceof URL) str[index] = `["U",${JSON.stringify(input.href)}]`;
+					else if (input instanceof RegExp) str[index] = `["R",${JSON.stringify(input.source)},${JSON.stringify(input.flags)}]`;
+					else if (input instanceof Set) if (input.size > 0) str[index] = `["S",${[...input].map((val) => flattenValue(val)).join(",")}]`;
+					else str[index] = `["S"]`;
+					else if (input instanceof Map) if (input.size > 0) str[index] = `["M",${[...input].flatMap(([k, v]) => [flattenValue(k), flattenValue(v)]).join(",")}]`;
+					else str[index] = `["M"]`;
+					else if (input instanceof Promise) {
+						str[index] = `["P",${index}]`;
+						deferred[index] = input;
+					} else if (input instanceof Error) {
+						str[index] = `["E",${JSON.stringify(input.message)}`;
+						if (input.name !== "Error") str[index] += `,${JSON.stringify(input.name)}`;
+						str[index] += "]";
+					} else if (Object.getPrototypeOf(input) === null) str[index] = `["N",{${partsForObj(input)}}]`;
+					else if (isPlainObject(input)) str[index] = `{${partsForObj(input)}}`;
+					else error = /* @__PURE__ */ new Error("Cannot encode object with prototype");
+				}
+				break;
+			}
+			default: {
+				const isArray = Array.isArray(input);
+				let pluginHandled = false;
+				if (!isArray && plugins) for (const plugin of plugins) {
+					const pluginResult = plugin(input);
+					if (Array.isArray(pluginResult)) {
+						pluginHandled = true;
+						const [pluginIdentifier, ...rest] = pluginResult;
+						str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+						if (rest.length > 0) str[index] += `,${rest.map((v) => flattenValue(v)).join(",")}`;
+						str[index] += "]";
+						break;
+					}
+				}
+				if (!pluginHandled) error = /* @__PURE__ */ new Error("Cannot encode function or unexpected type");
+			}
+		}
+		if (error) {
+			let pluginHandled = false;
+			if (postPlugins) for (const plugin of postPlugins) {
+				const pluginResult = plugin(input);
+				if (Array.isArray(pluginResult)) {
+					pluginHandled = true;
+					const [pluginIdentifier, ...rest] = pluginResult;
+					str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+					if (rest.length > 0) str[index] += `,${rest.map((v) => flattenValue(v)).join(",")}`;
+					str[index] += "]";
+					break;
+				}
+			}
+			if (!pluginHandled) throw error;
+		}
+	}
+}
+const objectProtoNames = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+function isPlainObject(thing) {
+	const proto = Object.getPrototypeOf(thing);
+	return proto === Object.prototype || proto === null || Object.getOwnPropertyNames(proto).sort().join("\0") === objectProtoNames;
+}
+//#endregion
+export { flatten };

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

@@ -0,0 +1,178 @@
+/**
+ * react-router v8.0.0-pre.0
+ *
+ * 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 { Deferred, createLineSplittingTransform } from "./utils.js";
+import { flatten } from "./flatten.js";
+import { unflatten } from "./unflatten.js";
+//#region vendor/turbo-stream-v2/turbo-stream.ts
+async function decode(readable, options) {
+	const { plugins } = options ?? {};
+	const done = new Deferred();
+	const reader = readable.pipeThrough(createLineSplittingTransform()).getReader();
+	const decoder = {
+		values: [],
+		hydrated: [],
+		deferred: {},
+		plugins
+	};
+	const decoded = await decodeInitial.call(decoder, reader);
+	let donePromise = done.promise;
+	if (decoded.done) done.resolve();
+	else donePromise = decodeDeferred.call(decoder, reader).then(done.resolve).catch((reason) => {
+		for (const deferred of Object.values(decoder.deferred)) deferred.reject(reason);
+		done.reject(reason);
+	});
+	return {
+		done: donePromise.then(() => reader.closed),
+		value: decoded.value
+	};
+}
+async function decodeInitial(reader) {
+	const read = await reader.read();
+	if (!read.value) throw new SyntaxError();
+	let line;
+	try {
+		line = JSON.parse(read.value);
+	} catch (reason) {
+		throw new SyntaxError();
+	}
+	return {
+		done: read.done,
+		value: unflatten.call(this, line)
+	};
+}
+async function decodeDeferred(reader) {
+	let read = await reader.read();
+	while (!read.done) {
+		if (!read.value) continue;
+		const line = read.value;
+		switch (line[0]) {
+			case "P": {
+				const colonIndex = line.indexOf(":");
+				const deferredId = Number(line.slice(1, colonIndex));
+				const deferred = this.deferred[deferredId];
+				if (!deferred) throw new Error(`Deferred ID ${deferredId} not found in stream`);
+				const lineData = line.slice(colonIndex + 1);
+				let jsonLine;
+				try {
+					jsonLine = JSON.parse(lineData);
+				} catch (reason) {
+					throw new SyntaxError();
+				}
+				const value = unflatten.call(this, jsonLine);
+				deferred.resolve(value);
+				break;
+			}
+			case "E": {
+				const colonIndex = line.indexOf(":");
+				const deferredId = Number(line.slice(1, colonIndex));
+				const deferred = this.deferred[deferredId];
+				if (!deferred) throw new Error(`Deferred ID ${deferredId} not found in stream`);
+				const lineData = line.slice(colonIndex + 1);
+				let jsonLine;
+				try {
+					jsonLine = JSON.parse(lineData);
+				} catch (reason) {
+					throw new SyntaxError();
+				}
+				const value = unflatten.call(this, jsonLine);
+				deferred.reject(value);
+				break;
+			}
+			default: throw new SyntaxError();
+		}
+		read = await reader.read();
+	}
+}
+function encode(input, options) {
+	const { onComplete, plugins, postPlugins, signal } = options ?? {};
+	const encoder = {
+		deferred: {},
+		index: 0,
+		indices: /* @__PURE__ */ new Map(),
+		stringified: [],
+		plugins,
+		postPlugins,
+		signal
+	};
+	const textEncoder = new TextEncoder();
+	let lastSentIndex = 0;
+	return new ReadableStream({ async start(controller) {
+		const id = await flatten.call(encoder, input);
+		if (Array.isArray(id)) throw new Error("This should never happen");
+		if (id < 0) controller.enqueue(textEncoder.encode(`${id}\n`));
+		else {
+			controller.enqueue(textEncoder.encode(`[${encoder.stringified.join(",")}]\n`));
+			lastSentIndex = encoder.stringified.length - 1;
+		}
+		const seenPromises = /* @__PURE__ */ new WeakSet();
+		let processingChain = Promise.resolve();
+		if (Object.keys(encoder.deferred).length) {
+			let raceDone;
+			const racePromise = new Promise((resolve, reject) => {
+				raceDone = resolve;
+				if (signal) {
+					const rejectPromise = () => reject(signal.reason || /* @__PURE__ */ new Error("Signal was aborted."));
+					if (signal.aborted) rejectPromise();
+					else signal.addEventListener("abort", (event) => {
+						rejectPromise();
+					});
+				}
+			});
+			while (Object.keys(encoder.deferred).length > 0) {
+				for (const [deferredId, deferred] of Object.entries(encoder.deferred)) {
+					if (seenPromises.has(deferred)) continue;
+					seenPromises.add(encoder.deferred[Number(deferredId)] = Promise.race([racePromise, deferred]).then((resolved) => {
+						processingChain = processingChain.then(async () => {
+							const id = await flatten.call(encoder, resolved);
+							if (Array.isArray(id)) {
+								controller.enqueue(textEncoder.encode(`P${deferredId}:[["Z",${id[0]}]]\n`));
+								encoder.index++;
+								lastSentIndex++;
+							} else if (id < 0) controller.enqueue(textEncoder.encode(`P${deferredId}:${id}\n`));
+							else {
+								const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
+								controller.enqueue(textEncoder.encode(`P${deferredId}:[${values}]\n`));
+								lastSentIndex = encoder.stringified.length - 1;
+							}
+						});
+						return processingChain;
+					}, (reason) => {
+						processingChain = processingChain.then(async () => {
+							if (!reason || typeof reason !== "object" || !(reason instanceof Error)) reason = /* @__PURE__ */ new Error("An unknown error occurred");
+							const id = await flatten.call(encoder, reason);
+							if (Array.isArray(id)) {
+								controller.enqueue(textEncoder.encode(`E${deferredId}:[["Z",${id[0]}]]\n`));
+								encoder.index++;
+								lastSentIndex++;
+							} else if (id < 0) controller.enqueue(textEncoder.encode(`E${deferredId}:${id}\n`));
+							else {
+								const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
+								controller.enqueue(textEncoder.encode(`E${deferredId}:[${values}]\n`));
+								lastSentIndex = encoder.stringified.length - 1;
+							}
+						});
+						return processingChain;
+					}).finally(() => {
+						delete encoder.deferred[Number(deferredId)];
+					}));
+				}
+				await Promise.race(Object.values(encoder.deferred));
+			}
+			raceDone();
+		}
+		await Promise.all(Object.values(encoder.deferred));
+		await processingChain;
+		controller.close();
+		onComplete?.();
+	} });
+}
+//#endregion
+export { decode, encode };