boreal-ui 0.0.52 → 0.0.54

package/dist/next/{link-lNk_lOdS.cjs → link-B1N-q38H.cjs}

@@ -965,6 +965,9 @@ function requireSegment() {
       DEFAULT_SEGMENT_KEY: function() {
         return DEFAULT_SEGMENT_KEY;
       },
+      NOT_FOUND_SEGMENT_KEY: function() {
+        return NOT_FOUND_SEGMENT_KEY;
+      },
       PAGE_SEGMENT_KEY: function() {
         return PAGE_SEGMENT_KEY;
       },
@@ -1030,6 +1033,7 @@ function requireSegment() {
     }
     const PAGE_SEGMENT_KEY = "__PAGE__";
     const DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+    const NOT_FOUND_SEGMENT_KEY = "/_not-found";
   })(segment);
   return segment;
 }
@@ -1984,9 +1988,6 @@ function requireConstants() {
       RSC_MOD_REF_PROXY_ALIAS: function() {
         return RSC_MOD_REF_PROXY_ALIAS;
       },
-      RSC_PREFETCH_SUFFIX: function() {
-        return RSC_PREFETCH_SUFFIX;
-      },
       RSC_SEGMENTS_DIR_SUFFIX: function() {
         return RSC_SEGMENTS_DIR_SUFFIX;
       },
@@ -2041,7 +2042,6 @@ function requireConstants() {
     const MATCHED_PATH_HEADER = "x-matched-path";
     const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
     const PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
-    const RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
     const RSC_SEGMENTS_DIR_SUFFIX = ".segments";
     const RSC_SEGMENT_SUFFIX = ".segment.rsc";
     const RSC_SUFFIX = ".rsc";
@@ -2289,6 +2289,7 @@ function requireParseLoaderTree() {
   })(parseLoaderTree);
   return parseLoaderTree;
 }
+var app = {};
 var getSegmentParam = {};
 var hasRequiredGetSegmentParam;
 function requireGetSegmentParam() {
@@ -2325,20 +2326,20 @@ function requireGetSegmentParam() {
         return {
           // TODO-APP: Optional catchall does not currently work with parallel routes,
           // so for now aren't handling a potential interception marker.
-          type: "optional-catchall",
-          param: segment2.slice(5, -2)
+          paramType: "optional-catchall",
+          paramName: segment2.slice(5, -2)
         };
       }
       if (segment2.startsWith("[...") && segment2.endsWith("]")) {
         return {
-          type: interceptionMarker ? `catchall-intercepted-${interceptionMarker}` : "catchall",
-          param: segment2.slice(4, -1)
+          paramType: interceptionMarker ? `catchall-intercepted-${interceptionMarker}` : "catchall",
+          paramName: segment2.slice(4, -1)
         };
       }
       if (segment2.startsWith("[") && segment2.endsWith("]")) {
         return {
-          type: interceptionMarker ? `dynamic-intercepted-${interceptionMarker}` : "dynamic",
-          param: segment2.slice(1, -1)
+          paramType: interceptionMarker ? `dynamic-intercepted-${interceptionMarker}` : "dynamic",
+          paramName: segment2.slice(1, -1)
         };
       }
       return null;
@@ -2370,6 +2371,251 @@ function requireGetSegmentParam() {
   })(getSegmentParam);
   return getSegmentParam;
 }
+var hasRequiredApp;
+function requireApp() {
+  if (hasRequiredApp) return app;
+  hasRequiredApp = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      isInterceptionAppRoute: function() {
+        return isInterceptionAppRoute;
+      },
+      isNormalizedAppRoute: function() {
+        return isNormalizedAppRoute;
+      },
+      parseAppRoute: function() {
+        return parseAppRoute;
+      },
+      parseAppRouteSegment: function() {
+        return parseAppRouteSegment;
+      }
+    });
+    const _invarianterror = requireInvariantError();
+    const _getsegmentparam = requireGetSegmentParam();
+    const _interceptionroutes = requireInterceptionRoutes();
+    function parseAppRouteSegment(segment2) {
+      if (segment2 === "") {
+        return null;
+      }
+      const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment2.startsWith(m));
+      const param = (0, _getsegmentparam.getSegmentParam)(segment2);
+      if (param) {
+        return {
+          type: "dynamic",
+          name: segment2,
+          param,
+          interceptionMarker
+        };
+      } else if (segment2.startsWith("(") && segment2.endsWith(")")) {
+        return {
+          type: "route-group",
+          name: segment2,
+          interceptionMarker
+        };
+      } else if (segment2.startsWith("@")) {
+        return {
+          type: "parallel-route",
+          name: segment2,
+          interceptionMarker
+        };
+      } else {
+        return {
+          type: "static",
+          name: segment2,
+          interceptionMarker
+        };
+      }
+    }
+    function isNormalizedAppRoute(route) {
+      return route.normalized;
+    }
+    function isInterceptionAppRoute(route) {
+      return route.interceptionMarker !== void 0 && route.interceptingRoute !== void 0 && route.interceptedRoute !== void 0;
+    }
+    function parseAppRoute(pathname, normalized) {
+      const pathnameSegments = pathname.split("/").filter(Boolean);
+      const segments = [];
+      let interceptionMarker;
+      let interceptingRoute;
+      let interceptedRoute;
+      for (const segment2 of pathnameSegments) {
+        const appSegment = parseAppRouteSegment(segment2);
+        if (!appSegment) {
+          continue;
+        }
+        if (normalized && (appSegment.type === "route-group" || appSegment.type === "parallel-route")) {
+          throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group or parallel route segment.`), "__NEXT_ERROR_CODE", {
+            value: "E923",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        segments.push(appSegment);
+        if (appSegment.interceptionMarker) {
+          const parts = pathname.split(appSegment.interceptionMarker);
+          if (parts.length !== 2) {
+            throw Object.defineProperty(new Error(`Invalid interception route: ${pathname}`), "__NEXT_ERROR_CODE", {
+              value: "E924",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          interceptingRoute = normalized ? parseAppRoute(parts[0], true) : parseAppRoute(parts[0], false);
+          interceptedRoute = normalized ? parseAppRoute(parts[1], true) : parseAppRoute(parts[1], false);
+          interceptionMarker = appSegment.interceptionMarker;
+        }
+      }
+      const dynamicSegments = segments.filter((segment2) => segment2.type === "dynamic");
+      return {
+        normalized,
+        pathname,
+        segments,
+        dynamicSegments,
+        interceptionMarker,
+        interceptingRoute,
+        interceptedRoute
+      };
+    }
+  })(app);
+  return app;
+}
+var resolveParamValue = {};
+var interceptionPrefixFromParamType = {};
+var hasRequiredInterceptionPrefixFromParamType;
+function requireInterceptionPrefixFromParamType() {
+  if (hasRequiredInterceptionPrefixFromParamType) return interceptionPrefixFromParamType;
+  hasRequiredInterceptionPrefixFromParamType = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "interceptionPrefixFromParamType", {
+      enumerable: true,
+      get: function() {
+        return interceptionPrefixFromParamType2;
+      }
+    });
+    function interceptionPrefixFromParamType2(paramType) {
+      switch (paramType) {
+        case "catchall-intercepted-(..)(..)":
+        case "dynamic-intercepted-(..)(..)":
+          return "(..)(..)";
+        case "catchall-intercepted-(.)":
+        case "dynamic-intercepted-(.)":
+          return "(.)";
+        case "catchall-intercepted-(..)":
+        case "dynamic-intercepted-(..)":
+          return "(..)";
+        case "catchall-intercepted-(...)":
+        case "dynamic-intercepted-(...)":
+          return "(...)";
+        case "catchall":
+        case "dynamic":
+        case "optional-catchall":
+        default:
+          return null;
+      }
+    }
+  })(interceptionPrefixFromParamType);
+  return interceptionPrefixFromParamType;
+}
+var hasRequiredResolveParamValue;
+function requireResolveParamValue() {
+  if (hasRequiredResolveParamValue) return resolveParamValue;
+  hasRequiredResolveParamValue = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "resolveParamValue", {
+      enumerable: true,
+      get: function() {
+        return resolveParamValue2;
+      }
+    });
+    const _invarianterror = requireInvariantError();
+    const _interceptionprefixfromparamtype = requireInterceptionPrefixFromParamType();
+    function getParamValueFromSegment(pathSegment, params, paramType) {
+      if (pathSegment.type === "dynamic") {
+        return params[pathSegment.param.paramName];
+      }
+      const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
+      if (interceptionPrefix === pathSegment.interceptionMarker) {
+        return pathSegment.name.replace(pathSegment.interceptionMarker, "");
+      }
+      return pathSegment.name;
+    }
+    function resolveParamValue2(paramName, paramType, depth, route, params) {
+      switch (paramType) {
+        case "catchall":
+        case "optional-catchall":
+        case "catchall-intercepted-(..)(..)":
+        case "catchall-intercepted-(.)":
+        case "catchall-intercepted-(..)":
+        case "catchall-intercepted-(...)":
+          const processedSegments = [];
+          for (let index = depth; index < route.segments.length; index++) {
+            const pathSegment = route.segments[index];
+            if (pathSegment.type === "static") {
+              let value = pathSegment.name;
+              const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
+              if (interceptionPrefix && index === depth && interceptionPrefix === pathSegment.interceptionMarker) {
+                value = value.replace(pathSegment.interceptionMarker, "");
+              }
+              processedSegments.push(value);
+            } else {
+              if (!params.hasOwnProperty(pathSegment.param.paramName)) {
+                if (pathSegment.param.paramType === "optional-catchall") {
+                  break;
+                }
+                return void 0;
+              }
+              const paramValue = params[pathSegment.param.paramName];
+              if (Array.isArray(paramValue)) {
+                processedSegments.push(...paramValue);
+              } else {
+                processedSegments.push(paramValue);
+              }
+            }
+          }
+          if (processedSegments.length > 0) {
+            return processedSegments;
+          } else if (paramType === "optional-catchall") {
+            return void 0;
+          } else {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
+              value: "E931",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        case "dynamic":
+        case "dynamic-intercepted-(..)(..)":
+        case "dynamic-intercepted-(.)":
+        case "dynamic-intercepted-(..)":
+        case "dynamic-intercepted-(...)":
+          if (depth < route.segments.length) {
+            const pathSegment = route.segments[depth];
+            if (pathSegment.type === "dynamic" && !params.hasOwnProperty(pathSegment.param.paramName)) {
+              return void 0;
+            }
+            return getParamValueFromSegment(pathSegment, params, paramType);
+          }
+          return void 0;
+      }
+    }
+  })(resolveParamValue);
+  return resolveParamValue;
+}
 var hasRequiredGetDynamicParam;
 function requireGetDynamicParam() {
   if (hasRequiredGetDynamicParam) return getDynamicParam;
@@ -2403,7 +2649,8 @@ function requireGetDynamicParam() {
     });
     const _invarianterror = requireInvariantError();
     const _parseloadertree = requireParseLoaderTree();
-    const _getsegmentparam = requireGetSegmentParam();
+    const _app = requireApp();
+    const _resolveparamvalue = requireResolveParamValue();
     function getParamValue(interpolatedParams, segmentKey, fallbackRouteParams) {
       let value = interpolatedParams[segmentKey];
       if (fallbackRouteParams == null ? void 0 : fallbackRouteParams.has(segmentKey)) {
@@ -2424,53 +2671,33 @@ function requireGetDynamicParam() {
           depth: 0
         }
       ];
-      const pathSegments = pagePath.split("/").slice(1);
+      const route = (0, _app.parseAppRoute)(pagePath, true);
       while (stack.length > 0) {
         const { tree, depth } = stack.pop();
         const { segment: segment2, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
-        const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment2);
-        if (segmentParam && !interpolated.hasOwnProperty(segmentParam.param) && // If the param is in the fallback route params, we don't need to
+        const appSegment = (0, _app.parseAppRouteSegment)(segment2);
+        if ((appSegment == null ? void 0 : appSegment.type) === "dynamic" && !interpolated.hasOwnProperty(appSegment.param.paramName) && // If the param is in the fallback route params, we don't need to
         // interpolate it because it's already marked as being unknown.
-        !(fallbackRouteParams == null ? void 0 : fallbackRouteParams.has(segmentParam.param))) {
-          switch (segmentParam.type) {
-            case "catchall":
-            case "optional-catchall":
-            case "catchall-intercepted-(..)(..)":
-            case "catchall-intercepted-(.)":
-            case "catchall-intercepted-(..)":
-            case "catchall-intercepted-(...)":
-              const remainingSegments = pathSegments.slice(depth);
-              const processedSegments = remainingSegments.flatMap((pathSegment) => {
-                const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
-                return param ? interpolated[param.param] : pathSegment;
-              }).filter((s) => s !== void 0);
-              if (processedSegments.length > 0) {
-                interpolated[segmentParam.param] = processedSegments;
-              }
-              break;
-            case "dynamic":
-            case "dynamic-intercepted-(..)(..)":
-            case "dynamic-intercepted-(.)":
-            case "dynamic-intercepted-(..)":
-            case "dynamic-intercepted-(...)":
-              if (depth < pathSegments.length) {
-                const pathSegment = pathSegments[depth];
-                const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
-                interpolated[segmentParam.param] = param ? interpolated[param.param] : pathSegment;
-              }
-              break;
-            default:
-              segmentParam.type;
+        !(fallbackRouteParams == null ? void 0 : fallbackRouteParams.has(appSegment.param.paramName))) {
+          const { paramName, paramType } = appSegment.param;
+          const paramValue = (0, _resolveparamvalue.resolveParamValue)(paramName, paramType, depth, route, interpolated);
+          if (paramValue !== void 0) {
+            interpolated[paramName] = paramValue;
+          } else if (paramType !== "optional-catchall") {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`), "__NEXT_ERROR_CODE", {
+              value: "E932",
+              enumerable: false,
+              configurable: true
+            });
           }
         }
         let nextDepth = depth;
-        const isRouteGroup = segment2.startsWith("(") && segment2.endsWith(")");
-        if (!isRouteGroup && segment2 !== "") {
+        if (appSegment && appSegment.type !== "route-group" && appSegment.type !== "parallel-route") {
           nextDepth++;
         }
-        for (const route of Object.values(parallelRoutes)) {
+        for (const parallelRoute of Object.values(parallelRoutes)) {
           stack.push({
-            tree: route,
+            tree: parallelRoute,
             depth: nextDepth
           });
         }
@@ -3825,4 +4052,4 @@ exports.requireSegment = requireSegment;
 exports.requireUseMergedRef = requireUseMergedRef;
 exports.require_interop_require_default = require_interop_require_default;
 exports.require_interop_require_wildcard = require_interop_require_wildcard;
-//# sourceMappingURL=link-lNk_lOdS.cjs.map
+//# sourceMappingURL=link-B1N-q38H.cjs.map