react-router 0.0.0-experimental-a65d6f5 → 0.0.0-experimental-e0b6ce9

package/dist/development/{chunk-QOFB7XZ5.js → chunk-INO4IHBF.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 _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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-a65d6f5
+ * react-router v0.0.0-experimental-e0b6ce9
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -956,182 +956,130 @@ function getRoutePattern(paths) {
 
 // lib/router/instrumentation.ts
 var UninstrumentedSymbol = Symbol("Uninstrumented");
-function getInstrumentedImplementation(impls, handler, getInfo = () => void 0) {
-  if (impls.length === 0) {
-    return null;
-  }
-  return async (...args) => {
-    let value;
-    let info = getInfo(...args);
-    await recurseRight(
-      impls,
-      info,
-      async () => {
-        value = await handler(...args);
-      },
-      impls.length - 1
-    );
-    return value;
+function getRouteInstrumentationUpdates(fns, route) {
+  let aggregated = {
+    lazy: [],
+    "lazy.loader": [],
+    "lazy.action": [],
+    "lazy.middleware": [],
+    middleware: [],
+    loader: [],
+    action: []
   };
-}
-async function recurseRight(impls, info, handler, index) {
-  let impl = impls[index];
-  if (!impl) {
-    await handler();
-  } else {
-    await impl(async () => {
-      await recurseRight(impls, info, handler, index - 1);
-    }, info);
-  }
-}
-function getInstrumentationInfo(args) {
-  let { request, context, params, unstable_pattern } = args;
-  return {
-    // pseudo "Request" with the info they may want to read from
-    request: {
-      method: request.method,
-      url: request.url,
-      // Maybe make this a proxy that only supports `get`?
-      headers: {
-        get: (...args2) => request.headers.get(...args2)
-      }
-    },
-    params: { ...params },
-    unstable_pattern,
-    context: {
-      get: (...args2) => context.get(...args2)
-    }
-  };
-}
-function getInstrumentationsByType(instrumentations, key) {
-  let value = [];
-  for (let i in instrumentations) {
-    let instrumentation = instrumentations[i];
-    if (key in instrumentation && instrumentation[key] != null) {
-      value.push(instrumentation[key]);
-    }
-  }
-  return value;
-}
-function getInstrumentationUpdates(fns, route) {
-  let instrumentations = [];
   fns.forEach(
     (fn) => fn({
       id: route.id,
       index: route.index,
       path: route.path,
       instrument(i) {
-        instrumentations.push(i);
+        let keys = Object.keys(aggregated);
+        for (let key of keys) {
+          if (i[key]) {
+            aggregated[key].push(i[key]);
+          }
+        }
       }
     })
   );
   let updates = {};
-  if (instrumentations.length > 0) {
-    ["lazy", "loader", "action"].forEach((key) => {
-      let func = route[key];
-      if (typeof func === "function") {
-        let original = _nullishCoalesce(func[UninstrumentedSymbol], () => ( func));
-        let instrumented = getInstrumentedImplementation(
-          getInstrumentationsByType(instrumentations, key),
-          original,
-          key === "lazy" ? () => void 0 : (...args) => getInstrumentationInfo(
-            args[0]
-          )
-        );
+  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) {
-          instrumented[UninstrumentedSymbol] = original;
-          updates[key] = instrumented;
+          updates.lazy = Object.assign(updates.lazy || {}, {
+            [key]: instrumented
+          });
         }
       }
     });
-    if (route.middleware && route.middleware.length > 0) {
-      updates.middleware = route.middleware.map((middleware) => {
-        let original = _nullishCoalesce(middleware[UninstrumentedSymbol], () => ( middleware));
-        let instrumented = getInstrumentedImplementation(
-          getInstrumentationsByType(instrumentations, "middleware"),
-          original,
-          (...args) => getInstrumentationInfo(
-            args[0]
-          )
-        );
-        if (instrumented) {
-          instrumented[UninstrumentedSymbol] = original;
-          return instrumented;
-        }
-        return middleware;
-      });
-    }
-    if (typeof route.lazy === "object") {
-      let lazyObject = route.lazy;
-      ["middleware", "loader", "action"].forEach((key) => {
-        let func = lazyObject[key];
-        if (typeof func === "function") {
-          let instrumented = getInstrumentedImplementation(
-            getInstrumentationsByType(instrumentations, `lazy.${key}`),
-            func
-          );
-          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 = _nullishCoalesce(handler[UninstrumentedSymbol], () => ( handler));
+      let instrumented = wrapImpl(
+        aggregated[key],
+        original,
+        (...args) => getHandlerInfo(args[0])
+      );
+      if (instrumented) {
+        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 = _nullishCoalesce(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 instrumentations = [];
+  let aggregated = {
+    navigate: [],
+    fetch: []
+  };
   fns.forEach(
     (fn) => fn({
       instrument(i) {
-        instrumentations.push(i);
+        let keys = Object.keys(i);
+        for (let key of keys) {
+          if (i[key]) {
+            aggregated[key].push(i[key]);
+          }
+        }
       }
     })
   );
-  if (instrumentations.length > 0) {
+  if (aggregated.navigate.length > 0) {
     let navigate = _nullishCoalesce(router.navigate[UninstrumentedSymbol], () => ( router.navigate));
-    let instrumentedNavigate = getInstrumentedImplementation(
-      getInstrumentationsByType(instrumentations, "navigate"),
+    let instrumentedNavigate = wrapImpl(
+      aggregated.navigate,
       navigate,
       (...args) => {
         let [to, opts] = args;
-        opts = _nullishCoalesce(opts, () => ( {}));
-        let info = {
+        return {
           to: typeof to === "number" || typeof to === "string" ? to : to ? createPath(to) : ".",
-          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 } : {}
+          ...getRouterInfo(router, _nullishCoalesce(opts, () => ( {})))
         };
-        return info;
       }
     );
     if (instrumentedNavigate) {
       instrumentedNavigate[UninstrumentedSymbol] = navigate;
       router.navigate = instrumentedNavigate;
     }
+  }
+  if (aggregated.fetch.length > 0) {
     let fetch2 = _nullishCoalesce(router.fetch[UninstrumentedSymbol], () => ( router.fetch));
-    let instrumentedFetch = getInstrumentedImplementation(
-      getInstrumentationsByType(instrumentations, "fetch"),
-      fetch2,
-      (...args) => {
-        let [key, , href, opts] = args;
-        opts = _nullishCoalesce(opts, () => ( {}));
-        let info = {
-          href: _nullishCoalesce(href, () => ( ".")),
-          currentUrl: createPath(router.state.location),
-          fetcherKey: key,
-          ..."formMethod" in opts ? { formMethod: opts.formMethod } : {},
-          ..."formEncType" in opts ? { formEncType: opts.formEncType } : {},
-          ..."formData" in opts ? { formData: opts.formData } : {},
-          ..."body" in opts ? { body: opts.body } : {}
-        };
-        return info;
-      }
-    );
+    let instrumentedFetch = wrapImpl(aggregated.fetch, fetch2, (...args) => {
+      let [key, , href, opts] = args;
+      return {
+        href: _nullishCoalesce(href, () => ( ".")),
+        fetcherKey: key,
+        ...getRouterInfo(router, _nullishCoalesce(opts, () => ( {})))
+      };
+    });
     if (instrumentedFetch) {
       instrumentedFetch[UninstrumentedSymbol] = fetch2;
       router.fetch = instrumentedFetch;
@@ -1140,38 +1088,94 @@ function instrumentClientSideRouter(router, fns) {
   return router;
 }
 function instrumentHandler(handler, fns) {
-  let instrumentations = [];
+  let aggregated = {
+    request: []
+  };
   fns.forEach(
     (fn) => fn({
       instrument(i) {
-        instrumentations.push(i);
+        let keys = Object.keys(i);
+        for (let key of keys) {
+          if (i[key]) {
+            aggregated[key].push(i[key]);
+          }
+        }
       }
     })
   );
-  if (instrumentations.length === 0) {
-    return handler;
-  }
-  let instrumentedHandler = getInstrumentedImplementation(
-    getInstrumentationsByType(instrumentations, "request"),
-    handler,
-    (...args) => {
+  let instrumentedHandler = handler;
+  if (aggregated.request.length > 0) {
+    instrumentedHandler = wrapImpl(aggregated.request, handler, (...args) => {
       let [request, context] = args;
-      let info = {
-        request: {
-          method: request.method,
-          url: request.url,
-          headers: {
-            get: (...args2) => request.headers.get(...args2)
-          }
-        },
-        context: {
-          get: (ctx) => context ? context.get(ctx) : void 0
-        }
+      return {
+        request: getReadonlyRequest(request),
+        // TODO: Handle non-middleware flows
+        // @ts-expect-error
+        context: getReadonlyContext(context)
       };
-      return info;
+    });
+  }
+  return instrumentedHandler;
+}
+function wrapImpl(impls, handler, getInfo) {
+  if (impls.length === 0) {
+    return null;
+  }
+  return async (...args) => {
+    let value;
+    let info = getInfo(...args);
+    await recurseRight(
+      impls,
+      info,
+      async () => {
+        value = await handler(...args);
+      },
+      impls.length - 1
+    );
+    return value;
+  };
+}
+async function recurseRight(impls, info, handler, index) {
+  let impl = impls[index];
+  if (!impl) {
+    await handler();
+  } else {
+    await impl(async () => {
+      await recurseRight(impls, info, handler, index - 1);
+    }, info);
+  }
+}
+function getHandlerInfo(args) {
+  let { request, context, params, unstable_pattern } = args;
+  return {
+    request: getReadonlyRequest(request),
+    params: { ...params },
+    unstable_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)
     }
-  );
-  return _nullishCoalesce(instrumentedHandler, () => ( handler));
+  };
+}
+function getReadonlyContext(context) {
+  return {
+    get: (ctx) => context.get(ctx)
+  };
 }
 
 // lib/router/router.ts
@@ -1239,7 +1243,7 @@ function createRouter(init) {
     mapRouteProperties = (route) => {
       return {
         ..._mapRouteProperties(route),
-        ...getInstrumentationUpdates(
+        ...getRouteInstrumentationUpdates(
           instrumentations.map((i) => i.route).filter(Boolean),
           route
         )
@@ -3019,7 +3023,7 @@ function createStaticHandler(routes, opts) {
     mapRouteProperties = (route) => {
       return {
         ..._mapRouteProperties(route),
-        ...getInstrumentationUpdates(
+        ...getRouteInstrumentationUpdates(
           instrumentations.map((i) => i.route).filter(Boolean),
           route
         )
@@ -3517,13 +3521,14 @@ function createStaticHandler(routes, opts) {
         // Up to but not including the boundary
         matches.findIndex((m) => m.route.id === pendingActionResult[0]) - 1
       ) : void 0;
+      let pattern = getRoutePattern(matches.map((m) => m.route.path));
       dsMatches = matches.map((match, index) => {
         if (maxIdx != null && index > maxIdx) {
           return getDataStrategyMatch(
             mapRouteProperties,
             manifest,
             request,
-            getRoutePattern(matches.map((m) => m.route.path)),
+            pattern,
             match,
             [],
             requestContext,
@@ -3534,7 +3539,7 @@ function createStaticHandler(routes, opts) {
           mapRouteProperties,
           manifest,
           request,
-          getRoutePattern(matches.map((m) => m.route.path)),
+          pattern,
           match,
           [],
           requestContext,
@@ -3816,7 +3821,6 @@ function getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest,
     actionStatus
   };
   let pattern = getRoutePattern(matches.map((m) => m.route.path));
-  console.log(pattern, matches);
   let dsMatches = matches.map((match, index) => {
     let { route } = match;
     let forceShouldLoad = null;
@@ -4315,7 +4319,7 @@ function runClientMiddlewarePipeline(args, handler) {
   }
 }
 async function runMiddlewarePipeline(args, handler, processResult, isResult, errorHandler) {
-  let { matches, request, params, context } = args;
+  let { matches, request, params, context, unstable_pattern } = args;
   let tuples = matches.flatMap(
     (m) => m.route.middleware ? m.route.middleware.map((fn) => [m.route.id, fn]) : []
   );
@@ -4324,7 +4328,7 @@ async function runMiddlewarePipeline(args, handler, processResult, isResult, err
       request,
       params,
       context,
-      unstable_pattern: getRoutePattern(matches.map((m) => m.route.path))
+      unstable_pattern
     },
     tuples,
     handler,