react-router 7.16.0 → 8.0.0-pre.0

package/dist/production/lib/router/instrumentation.d.ts

@@ -0,0 +1,86 @@
+
+import { FormEncType, HTMLFormMethod, LoaderFunctionArgs, RouterContextProvider } from "./utils.js";
+//#region lib/router/instrumentation.d.ts
+type ServerInstrumentation = {
+  handler?: InstrumentRequestHandlerFunction;
+  route?: InstrumentRouteFunction;
+};
+type ClientInstrumentation = {
+  router?: InstrumentRouterFunction;
+  route?: InstrumentRouteFunction;
+};
+type InstrumentRequestHandlerFunction = (handler: InstrumentableRequestHandler) => void;
+type InstrumentRouterFunction = (router: InstrumentableRouter) => void;
+type InstrumentRouteFunction = (route: InstrumentableRoute) => void;
+type InstrumentationHandlerResult = {
+  status: "success";
+  error: undefined;
+} | {
+  status: "error";
+  error: Error;
+};
+type InstrumentFunction<T> = (handler: () => Promise<InstrumentationHandlerResult>, info: T) => Promise<void>;
+type ReadonlyRequest = {
+  method: string;
+  url: string;
+  headers: Pick<Headers, "get">;
+};
+type ReadonlyContext = Pick<RouterContextProvider, "get">;
+type InstrumentableRoute = {
+  id: string;
+  index: boolean | undefined;
+  path: string | undefined;
+  instrument(instrumentations: RouteInstrumentations): void;
+};
+type RouteInstrumentations = {
+  lazy?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+  "lazy.loader"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+  "lazy.action"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+  "lazy.middleware"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+  middleware?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+  loader?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+  action?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+};
+type RouteLazyInstrumentationInfo = undefined;
+type RouteHandlerInstrumentationInfo = Readonly<{
+  request: ReadonlyRequest;
+  params: LoaderFunctionArgs["params"];
+  pattern: string;
+  context: ReadonlyContext;
+}>;
+type InstrumentableRouter = {
+  instrument(instrumentations: RouterInstrumentations): void;
+};
+type RouterInstrumentations = {
+  navigate?: InstrumentFunction<RouterNavigationInstrumentationInfo>;
+  fetch?: InstrumentFunction<RouterFetchInstrumentationInfo>;
+};
+type RouterNavigationInstrumentationInfo = Readonly<{
+  to: string | number;
+  currentUrl: string;
+  formMethod?: HTMLFormMethod;
+  formEncType?: FormEncType;
+  formData?: FormData;
+  body?: any;
+}>;
+type RouterFetchInstrumentationInfo = Readonly<{
+  href: string;
+  currentUrl: string;
+  fetcherKey: string;
+  formMethod?: HTMLFormMethod;
+  formEncType?: FormEncType;
+  formData?: FormData;
+  body?: any;
+}>;
+type InstrumentableRequestHandler = {
+  instrument(instrumentations: RequestHandlerInstrumentations): void;
+};
+type RequestHandlerInstrumentations = {
+  request?: InstrumentFunction<RequestHandlerInstrumentationInfo>;
+};
+type RequestHandlerInstrumentationInfo = Readonly<{
+  request: ReadonlyRequest;
+  context: ReadonlyContext | undefined;
+}>;
+//#endregion
+export { ClientInstrumentation, InstrumentRequestHandlerFunction, InstrumentRouteFunction, InstrumentRouterFunction, InstrumentationHandlerResult, ServerInstrumentation };

package/dist/production/lib/router/instrumentation.js

@@ -0,0 +1,213 @@
+/**
+ * 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 { createPath, invariant } from "./history.js";
+//#region lib/router/instrumentation.ts
+const UninstrumentedSymbol = Symbol("Uninstrumented");
+function getRouteInstrumentationUpdates(fns, route) {
+	let aggregated = {
+		lazy: [],
+		"lazy.loader": [],
+		"lazy.action": [],
+		"lazy.middleware": [],
+		middleware: [],
+		loader: [],
+		action: []
+	};
+	fns.forEach((fn) => fn({
+		id: route.id,
+		index: route.index,
+		path: route.path,
+		instrument(i) {
+			let keys = Object.keys(aggregated);
+			for (let key of keys) if (i[key]) aggregated[key].push(i[key]);
+		}
+	}));
+	let updates = {};
+	if (typeof route.lazy === "function" && aggregated.lazy.length > 0) {
+		let instrumented = wrapImpl(aggregated.lazy, route.lazy, () => void 0);
+		if (instrumented) updates.lazy = instrumented;
+	}
+	if (typeof route.lazy === "object") {
+		let lazyObject = route.lazy;
+		[
+			"middleware",
+			"loader",
+			"action"
+		].forEach((key) => {
+			let lazyFn = lazyObject[key];
+			let instrumentations = aggregated[`lazy.${key}`];
+			if (typeof lazyFn === "function" && instrumentations.length > 0) {
+				let instrumented = wrapImpl(instrumentations, lazyFn, () => void 0);
+				if (instrumented) updates.lazy = Object.assign(updates.lazy || {}, { [key]: instrumented });
+			}
+		});
+	}
+	["loader", "action"].forEach((key) => {
+		let handler = route[key];
+		if (typeof handler === "function" && aggregated[key].length > 0) {
+			let original = handler[UninstrumentedSymbol] ?? handler;
+			let instrumented = wrapImpl(aggregated[key], original, (...args) => getHandlerInfo(args[0]));
+			if (instrumented) {
+				if (key === "loader" && original.hydrate === true) instrumented.hydrate = true;
+				instrumented[UninstrumentedSymbol] = original;
+				updates[key] = instrumented;
+			}
+		}
+	});
+	if (route.middleware && route.middleware.length > 0 && aggregated.middleware.length > 0) updates.middleware = route.middleware.map((middleware) => {
+		let original = middleware[UninstrumentedSymbol] ?? middleware;
+		let instrumented = wrapImpl(aggregated.middleware, original, (...args) => getHandlerInfo(args[0]));
+		if (instrumented) {
+			instrumented[UninstrumentedSymbol] = original;
+			return instrumented;
+		}
+		return middleware;
+	});
+	return updates;
+}
+function instrumentClientSideRouter(router, fns) {
+	let aggregated = {
+		navigate: [],
+		fetch: []
+	};
+	fns.forEach((fn) => fn({ instrument(i) {
+		let keys = Object.keys(i);
+		for (let key of keys) if (i[key]) aggregated[key].push(i[key]);
+	} }));
+	if (aggregated.navigate.length > 0) {
+		let navigate = router.navigate[UninstrumentedSymbol] ?? router.navigate;
+		let instrumentedNavigate = wrapImpl(aggregated.navigate, navigate, (...args) => {
+			let [to, opts] = args;
+			return {
+				to: typeof to === "number" || typeof to === "string" ? to : to ? createPath(to) : ".",
+				...getRouterInfo(router, opts ?? {})
+			};
+		});
+		if (instrumentedNavigate) {
+			instrumentedNavigate[UninstrumentedSymbol] = navigate;
+			router.navigate = instrumentedNavigate;
+		}
+	}
+	if (aggregated.fetch.length > 0) {
+		let fetch = router.fetch[UninstrumentedSymbol] ?? router.fetch;
+		let instrumentedFetch = wrapImpl(aggregated.fetch, fetch, (...args) => {
+			let [key, , href, opts] = args;
+			return {
+				href: href ?? ".",
+				fetcherKey: key,
+				...getRouterInfo(router, opts ?? {})
+			};
+		});
+		if (instrumentedFetch) {
+			instrumentedFetch[UninstrumentedSymbol] = fetch;
+			router.fetch = instrumentedFetch;
+		}
+	}
+	return router;
+}
+function instrumentHandler(handler, fns) {
+	let aggregated = { request: [] };
+	fns.forEach((fn) => fn({ instrument(i) {
+		let keys = Object.keys(i);
+		for (let key of keys) if (i[key]) aggregated[key].push(i[key]);
+	} }));
+	let instrumentedHandler = handler;
+	if (aggregated.request.length > 0) instrumentedHandler = wrapImpl(aggregated.request, handler, (...args) => {
+		let [request, context] = args;
+		return {
+			request: getReadonlyRequest(request),
+			context: context != null ? getReadonlyContext(context) : context
+		};
+	});
+	return instrumentedHandler;
+}
+function wrapImpl(impls, handler, getInfo) {
+	if (impls.length === 0) return null;
+	return async (...args) => {
+		let result = await recurseRight(impls, getInfo(...args), () => handler(...args), impls.length - 1);
+		if (result.type === "error") throw result.value;
+		return result.value;
+	};
+}
+async function recurseRight(impls, info, handler, index) {
+	let impl = impls[index];
+	let result;
+	if (!impl) try {
+		result = {
+			type: "success",
+			value: await handler()
+		};
+	} catch (e) {
+		result = {
+			type: "error",
+			value: e
+		};
+	}
+	else {
+		let handlerPromise = void 0;
+		let callHandler = async () => {
+			if (handlerPromise) console.error("You cannot call instrumented handlers more than once");
+			else handlerPromise = recurseRight(impls, info, handler, index - 1);
+			result = await handlerPromise;
+			invariant(result, "Expected a result");
+			if (result.type === "error" && result.value instanceof Error) return {
+				status: "error",
+				error: result.value
+			};
+			return {
+				status: "success",
+				error: void 0
+			};
+		};
+		try {
+			await impl(callHandler, info);
+		} catch (e) {
+			console.error("An instrumentation function threw an error:", e);
+		}
+		if (!handlerPromise) await callHandler();
+		await handlerPromise;
+	}
+	if (result) return result;
+	return {
+		type: "error",
+		value: /* @__PURE__ */ new Error("No result assigned in instrumentation chain.")
+	};
+}
+function getHandlerInfo(args) {
+	let { request, context, params, pattern } = args;
+	return {
+		request: getReadonlyRequest(request),
+		params: { ...params },
+		pattern,
+		context: getReadonlyContext(context)
+	};
+}
+function getRouterInfo(router, opts) {
+	return {
+		currentUrl: createPath(router.state.location),
+		..."formMethod" in opts ? { formMethod: opts.formMethod } : {},
+		..."formEncType" in opts ? { formEncType: opts.formEncType } : {},
+		..."formData" in opts ? { formData: opts.formData } : {},
+		..."body" in opts ? { body: opts.body } : {}
+	};
+}
+function getReadonlyRequest(request) {
+	return {
+		method: request.method,
+		url: request.url,
+		headers: { get: (...args) => request.headers.get(...args) }
+	};
+}
+function getReadonlyContext(context) {
+	return { get: (ctx) => context.get(ctx) };
+}
+//#endregion
+export { getRouteInstrumentationUpdates, instrumentClientSideRouter, instrumentHandler };

package/dist/production/lib/router/links.d.ts

@@ -0,0 +1,113 @@
+
+//#region lib/router/links.d.ts
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface HtmlLinkProps {
+  /**
+   * Address of the hyperlink
+   */
+  href?: string;
+  /**
+   * How the element handles crossorigin requests
+   */
+  crossOrigin?: "anonymous" | "use-credentials";
+  /**
+   * Relationship between the document containing the hyperlink and the destination resource
+   */
+  rel: LiteralUnion<"alternate" | "dns-prefetch" | "icon" | "manifest" | "modulepreload" | "next" | "pingback" | "preconnect" | "prefetch" | "preload" | "prerender" | "search" | "stylesheet", string>;
+  /**
+   * Applicable media: "screen", "print", "(max-width: 764px)"
+   */
+  media?: string;
+  /**
+   * Integrity metadata used in Subresource Integrity checks
+   */
+  integrity?: string;
+  /**
+   * Language of the linked resource
+   */
+  hrefLang?: string;
+  /**
+   * Hint for the type of the referenced resource
+   */
+  type?: string;
+  /**
+   * Referrer policy for fetches initiated by the element
+   */
+  referrerPolicy?: "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+  /**
+   * Sizes of the icons (for rel="icon")
+   */
+  sizes?: string;
+  /**
+   * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+   */
+  as?: LiteralUnion<"audio" | "audioworklet" | "document" | "embed" | "fetch" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt", string>;
+  /**
+   * Color to use when customizing a site's icon (for rel="mask-icon")
+   */
+  color?: string;
+  /**
+   * Whether the link is disabled
+   */
+  disabled?: boolean;
+  /**
+   * The title attribute has special semantics on this element: Title of the link; CSS style sheet set name.
+   */
+  title?: string;
+  /**
+   * Images to use in different situations, e.g., high-resolution displays,
+   * small monitors, etc. (for rel="preload")
+   */
+  imageSrcSet?: string;
+  /**
+   * Image sizes for different page layouts (for rel="preload")
+   */
+  imageSizes?: string;
+}
+interface HtmlLinkPreloadImage extends HtmlLinkProps {
+  /**
+   * Relationship between the document containing the hyperlink and the destination resource
+   */
+  rel: "preload";
+  /**
+   * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+   */
+  as: "image";
+  /**
+   * Address of the hyperlink
+   */
+  href?: string;
+  /**
+   * Images to use in different situations, e.g., high-resolution displays,
+   * small monitors, etc. (for rel="preload")
+   */
+  imageSrcSet: string;
+  /**
+   * Image sizes for different page layouts (for rel="preload")
+   */
+  imageSizes?: string;
+}
+/**
+ * Represents a `<link>` element.
+ *
+ * WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
+ */
+type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
+  imageSizes?: never;
+});
+interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
+  /**
+   * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
+   * attribute to render on the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+   * element
+   */
+  nonce?: string | undefined;
+  /**
+   * The absolute path of the page to prefetch, e.g. `/absolute/path`.
+   */
+  page: string;
+}
+type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
+//#endregion
+export { HtmlLinkDescriptor, LinkDescriptor, PageLinkDescriptor };