react-router 0.0.0-experimental-c19b79d → 0.0.0-experimental-e0b6ce9

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

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { RouterProviderProps as RouterProviderProps$1, RouterInit, unstable_ClientOnErrorFunction } from 'react-router';
+import { u as unstable_ClientInstrumentation } from './instrumentation-BGrNA7uj.js';
 
 type RouterProviderProps = Omit<RouterProviderProps$1, "flushSync">;
 declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">): React.JSX.Element;
@@ -11,12 +12,67 @@ declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">):
  */
 interface HydratedRouterProps {
     /**
-     * Context object to be passed through to {@link createBrowserRouter} and made
-     * available to
+     * 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
+     * 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.
+     *
+     * ```tsx
+     * startTransition(() => {
+     *   hydrateRoot(
+     *     document,
+     *     <HydratedRouter unstable_instrumentations={[logging]} />
+     *   );
+     * });
+     *
+     * 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}`);
+     *   try {
+     *     await impl();
+     *   } finally {
+     *     let end = performance.now();
+     *     console.log(`end ${label} (${Math.round(end - start)}ms)`);
+     *   }
+     * }
+     * ```
+     */
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     /**
      * An error handler function that will be called for any loader/action/render
      * errors that are encountered in your application.  This is useful for

package/dist/production/dom-export.js

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
- * react-router v0.0.0-experimental-c19b79d
+ * react-router v0.0.0-experimental-e0b6ce9
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -11,7 +11,7 @@
 "use client";
 
 
-var _chunk2L5AG5Y5js = require('./chunk-2L5AG5Y5.js');
+var _chunkK7VXYOZDjs = require('./chunk-K7VXYOZD.js');
 
 // lib/dom-export/dom-router-provider.tsx
 var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react);
@@ -67,7 +67,8 @@ function initSsrInfo() {
   }
 }
 function createHydratedRouter({
-  getContext
+  getContext,
+  unstable_instrumentations
 }) {
   initSsrInfo();
   if (!ssrInfo) {
@@ -134,6 +135,7 @@ function createHydratedRouter({
     getContext,
     hydrationData,
     hydrationRouteProperties: _reactrouter.UNSAFE_hydrationRouteProperties,
+    unstable_instrumentations,
     mapRouteProperties: _reactrouter.UNSAFE_mapRouteProperties,
     future: {
       middleware: ssrInfo.context.future.v8_middleware
@@ -167,7 +169,8 @@ function createHydratedRouter({
 function HydratedRouter(props) {
   if (!router) {
     router = createHydratedRouter({
-      getContext: props.getContext
+      getContext: props.getContext,
+      unstable_instrumentations: props.unstable_instrumentations
     });
   }
   let [criticalCss, setCriticalCss] = React2.useState(
@@ -180,7 +183,7 @@ function HydratedRouter(props) {
   }, []);
   React2.useEffect(() => {
     if (process.env.NODE_ENV === "development" && criticalCss === void 0) {
-      document.querySelectorAll(`[${_chunk2L5AG5Y5js.CRITICAL_CSS_DATA_ATTRIBUTE}]`).forEach((element) => element.remove());
+      document.querySelectorAll(`[${_chunkK7VXYOZDjs.CRITICAL_CSS_DATA_ATTRIBUTE}]`).forEach((element) => element.remove());
     }
   }, [criticalCss]);
   let [location, setLocation] = React2.useState(router.state.location);

package/dist/production/dom-export.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-c19b79d
+ * react-router v0.0.0-experimental-e0b6ce9
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -12,7 +12,7 @@
 import {
   deserializeErrors,
   getHydrationData
-} from "./chunk-AODJW4D3.mjs";
+} from "./chunk-52MYED7O.mjs";
 import {
   CRITICAL_CSS_DATA_ATTRIBUTE,
   FrameworkContext,
@@ -29,7 +29,7 @@ import {
   invariant,
   mapRouteProperties,
   useFogOFWarDiscovery
-} from "./chunk-UOQCOPF6.mjs";
+} from "./chunk-LKSLGWXX.mjs";
 
 // lib/dom-export/dom-router-provider.tsx
 import * as React from "react";
@@ -67,7 +67,8 @@ function initSsrInfo() {
   }
 }
 function createHydratedRouter({
-  getContext
+  getContext,
+  unstable_instrumentations
 }) {
   initSsrInfo();
   if (!ssrInfo) {
@@ -134,6 +135,7 @@ function createHydratedRouter({
     getContext,
     hydrationData,
     hydrationRouteProperties,
+    unstable_instrumentations,
     mapRouteProperties,
     future: {
       middleware: ssrInfo.context.future.v8_middleware
@@ -167,7 +169,8 @@ function createHydratedRouter({
 function HydratedRouter(props) {
   if (!router) {
     router = createHydratedRouter({
-      getContext: props.getContext
+      getContext: props.getContext,
+      unstable_instrumentations: props.unstable_instrumentations
     });
   }
   let [criticalCss, setCriticalCss] = React2.useState(

package/dist/production/{index-react-server-client-2EDmGlsZ.d.mts → index-react-server-client-CYIi6gi0.d.mts}

@@ -1,60 +1,33 @@
-import { b7 as RouteManifest, i as MiddlewareEnabled, g as RouterContextProvider, b as LoaderFunctionArgs, A as ActionFunctionArgs, O as StaticHandlerContext, H as HydrationState, F as DataRouteObject, a3 as HTMLFormMethod, a1 as FormEncType, m as RelativeRoutingType, T as To, b8 as History, K as GetScrollRestorationKeyFunction, a as RouterInit, b9 as FutureConfig$1, k as DataStrategyFunction, C as PatchRoutesOnNavigationFunction, N as NavigateOptions, Q as Fetcher, t as RouteObject, j as Router, B as BlockerFunction, L as Location, ba as CreateStaticHandlerOptions$1, G as StaticHandler } from './context-BqL5Eckq.mjs';
+import { bc as RouteManifest, H as HydrationState, G as DataRouteObject, Q as StaticHandlerContext, e as MiddlewareEnabled, c as RouterContextProvider, f as LoaderFunctionArgs, A as ActionFunctionArgs, ad as unstable_ServerInstrumentation, a4 as HTMLFormMethod, a2 as FormEncType, n as RelativeRoutingType, T as To, bd as History, O as GetScrollRestorationKeyFunction, a as RouterInit, be as FutureConfig$1, u as unstable_ClientInstrumentation, l as DataStrategyFunction, F as PatchRoutesOnNavigationFunction, N as NavigateOptions, V as Fetcher, v as RouteObject, k as Router, B as BlockerFunction, L as Location, bf as CreateStaticHandlerOptions$1, J as StaticHandler } from './router-DWv6Clt-.mjs';
 import * as React from 'react';
-import { o as ServerRouteModule, A as AppLoadContext, c as RouteModules, h as ClientLoaderFunction, m as PageLinkDescriptor, d as SerializeFrom } from './route-data-CDwqkzPE.mjs';
+import { c as RouteModules, h as ClientLoaderFunction, o as ServerRouteModule, A as AppLoadContext, m as PageLinkDescriptor, d as SerializeFrom } from './routeModules-Cy4Xsfoi.mjs';
 
-type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
-interface ServerRoute extends Route {
-    children: ServerRoute[];
-    module: ServerRouteModule;
-}
-
-type OptionalCriticalCss = CriticalCss | undefined;
-/**
- * The output of the compiler for the server build.
- */
-interface ServerBuild {
-    entry: {
-        module: ServerEntryModule;
-    };
-    routes: ServerRouteManifest;
-    assets: AssetsManifest;
-    basename?: string;
-    publicPath: string;
-    assetsBuildDirectory: string;
-    future: FutureConfig;
-    ssr: boolean;
-    unstable_getCriticalCss?: (args: {
-        pathname: string;
-    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
-    /**
-     * @deprecated This is now done via a custom header during prerendering
-     */
-    isSpaMode: boolean;
-    prerender: string[];
-    routeDiscovery: {
-        mode: "lazy" | "initial";
-        manifestPath: string;
-    };
-}
-interface HandleDocumentRequestFunction {
-    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? RouterContextProvider : AppLoadContext): Promise<Response> | Response;
-}
-interface HandleDataRequestFunction {
-    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
-}
-interface HandleErrorFunction {
-    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
+interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
 }
-/**
- * A module that serves as the entry point for a Remix app during server
- * rendering.
- */
-interface ServerEntryModule {
-    default: HandleDocumentRequestFunction;
-    handleDataRequest?: HandleDataRequestFunction;
-    handleError?: HandleErrorFunction;
-    streamTimeout?: number;
+interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    clientActionModule: string | undefined;
+    clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
+    hydrateFallbackModule: string | undefined;
+    parentId?: string;
 }
+declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
+declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
 
 type SerializedError = {
     message: string;
@@ -108,32 +81,68 @@ interface AssetsManifest {
     sri?: Record<string, string> | true;
 }
 
-interface Route {
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    path?: string;
+type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+interface ServerRoute extends Route {
+    children: ServerRoute[];
+    module: ServerRouteModule;
 }
-interface EntryRoute extends Route {
-    hasAction: boolean;
-    hasLoader: boolean;
-    hasClientAction: boolean;
-    hasClientLoader: boolean;
-    hasClientMiddleware: boolean;
-    hasErrorBoundary: boolean;
-    imports?: string[];
-    css?: string[];
-    module: string;
-    clientActionModule: string | undefined;
-    clientLoaderModule: string | undefined;
-    clientMiddlewareModule: string | undefined;
-    hydrateFallbackModule: string | undefined;
-    parentId?: string;
+
+type OptionalCriticalCss = CriticalCss | undefined;
+/**
+ * The output of the compiler for the server build.
+ */
+interface ServerBuild {
+    entry: {
+        module: ServerEntryModule;
+    };
+    routes: ServerRouteManifest;
+    assets: AssetsManifest;
+    basename?: string;
+    publicPath: string;
+    assetsBuildDirectory: string;
+    future: FutureConfig;
+    ssr: boolean;
+    unstable_getCriticalCss?: (args: {
+        pathname: string;
+    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
+    /**
+     * @deprecated This is now done via a custom header during prerendering
+     */
+    isSpaMode: boolean;
+    prerender: string[];
+    routeDiscovery: {
+        mode: "lazy" | "initial";
+        manifestPath: string;
+    };
+}
+interface HandleDocumentRequestFunction {
+    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? RouterContextProvider : AppLoadContext): Promise<Response> | Response;
+}
+interface HandleDataRequestFunction {
+    (response: Response, args: {
+        request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
+        context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
+        params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
+    }): Promise<Response> | Response;
+}
+interface HandleErrorFunction {
+    (error: unknown, args: {
+        request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
+        context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
+        params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
+    }): void;
+}
+/**
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
+ */
+interface ServerEntryModule {
+    default: HandleDocumentRequestFunction;
+    handleDataRequest?: HandleDataRequestFunction;
+    handleError?: HandleErrorFunction;
+    unstable_instrumentations?: unstable_ServerInstrumentation[];
+    streamTimeout?: number;
 }
-declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
-declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
-declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
 
 type ParamKeyValuePair = [string, string];
 type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
@@ -522,6 +531,58 @@ interface DOMRouterOpts {
      * ```
      */
     hydrationData?: HydrationState;
+    /**
+     * 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.
+     *
+     * ```tsx
+     * let router = createBrowserRouter(routes, {
+     *   unstable_instrumentations: [logging]
+     * });
+     *
+     *
+     * let logging = {
+     *   router({ instrument }) {
+     *     instrument({
+     *       navigate: (impl, info) => logExecution(`navigate ${info.to}`, impl),
+     *       fetch: (impl, info) => logExecution(`fetch ${info.to}`, impl)
+     *     });
+     *   },
+     *   route({ instrument, id }) {
+     *     instrument({
+     *       middleware: (impl, info) => logExecution(
+     *         `middleware ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *       loader: (impl, info) => logExecution(
+     *         `loader ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *       action: (impl, info) => logExecution(
+     *         `action ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *     })
+     *   }
+     * };
+     *
+     * async function logExecution(label: string, impl: () => Promise<void>) {
+     *   let start = performance.now();
+     *   console.log(`start ${label}`);
+     *   try {
+     *     await impl();
+     *   } finally {
+     *     let end = performance.now();
+     *     console.log(`end ${label} (${Math.round(end - start)}ms)`);
+     *   }
+     * }
+     * ```
+     */
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     /**
      * Override the default data strategy of running loaders in parallel.
      * See {@link DataStrategyFunction}.
@@ -1027,6 +1088,7 @@ interface DOMRouterOpts {
  * @param {DOMRouterOpts.future} opts.future n/a
  * @param {DOMRouterOpts.getContext} opts.getContext n/a
  * @param {DOMRouterOpts.hydrationData} opts.hydrationData n/a
+ * @param {DOMRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
  * @param {DOMRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
  * @param {DOMRouterOpts.window} opts.window n/a
  * @returns An initialized {@link DataRouter| data router} to pass to {@link RouterProvider | `<RouterProvider>`}
@@ -1045,6 +1107,7 @@ declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts
  * @param {DOMRouterOpts.future} opts.future n/a
  * @param {DOMRouterOpts.getContext} opts.getContext n/a
  * @param {DOMRouterOpts.hydrationData} opts.hydrationData n/a
+ * @param {DOMRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
  * @param {DOMRouterOpts.dataStrategy} opts.dataStrategy n/a
  * @param {DOMRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
  * @param {DOMRouterOpts.window} opts.window n/a