@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/build/entries.js

@@ -63,14 +63,63 @@ const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path"
 const _apppaths = require("../shared/lib/router/utils/app-paths");
 const _nextmiddlewareloader = require("./webpack/loaders/next-middleware-loader");
 const _isapprouteroute = require("../lib/is-app-route-route");
+const _isapppageroute = require("../lib/is-app-page-route");
 const _nextrouteloader = require("./webpack/loaders/next-route-loader");
 const _isinternalcomponent = require("../lib/is-internal-component");
 const _routekind = require("../server/route-kind");
 const _utils1 = require("./webpack/loaders/utils");
 const _normalizecatchallroutes = require("./normalize-catchall-routes");
 const _pagetypes = require("../lib/page-types");
+const _unmatchedapppageserror = require("../shared/lib/errors/unmatched-app-pages-error");
+const _missingcanonicalinterceptionrouteserror = require("../shared/lib/errors/missing-canonical-interception-routes-error");
+const _incompatibleparallelrouteslotserror = require("../shared/lib/errors/incompatible-parallel-route-slots-error");
+const _interceptionroutes = require("../shared/lib/router/utils/interception-routes");
+const _findpagefile = require("../server/lib/find-page-file");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
+const _strictroutematchingconfig = require("../server/lib/router-utils/strict-route-matching-config");
 const _getstaticinfoincludinglayouts = require("./get-static-info-including-layouts");
 const _routediscovery = require("./route-discovery");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir }) {
     if (absolutePagePath.startsWith(_constants.PAGES_DIR_ALIAS) && pagesDir) {
         return absolutePagePath.replace(_constants.PAGES_DIR_ALIAS, pagesDir);
@@ -268,25 +317,83 @@ function runDependingOnPageType(params) {
     return;
 }
 async function createEntrypoints(params) {
-    const { config, pages, pagesDir, isDev, rootDir, rootPaths, appDir, appPaths, pageExtensions, deferredEntriesFilter } = params;
+    const { config, pages, pagesDir, isDev, rootDir, rootPaths, appDir, appPaths, appDefaultPaths, pageExtensions, deferredEntriesFilter } = params;
     const deferredEntries = config.experimental.deferredEntries;
     const edgeServer = {};
     const server = {};
     const client = {};
+    const entrySourceDirectories = new Set();
     let middlewareMatchers = undefined;
     let appPathsPerRoute = {};
     if (appDir && appPaths) {
+        const appPageFiles = new Map();
         for(const pathname in appPaths){
             const normalizedPath = (0, _apppaths.normalizeAppPath)(pathname);
             const actualPath = appPaths[pathname];
             if (!appPathsPerRoute[normalizedPath]) {
                 appPathsPerRoute[normalizedPath] = [];
             }
-            appPathsPerRoute[normalizedPath].push(// TODO-APP: refactor to pass the page path from createPagesMapping instead.
-            (0, _routediscovery.getPageFromPath)(actualPath, pageExtensions).replace(_constants.APP_DIR_ALIAS, ''));
+            // TODO-APP: refactor to pass the page path from createPagesMapping instead.
+            const appPath = (0, _routediscovery.getPageFromPath)(actualPath, pageExtensions).replace(_constants.APP_DIR_ALIAS, '');
+            appPathsPerRoute[normalizedPath].push(appPath);
+            appPageFiles.set(appPath, actualPath);
         }
         // TODO: find a better place to do this
-        (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPathsPerRoute);
+        const { unmatchedAppPages, incompatibleParallelRouteSlots } = (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPathsPerRoute, {
+            strictRouteMatching: config.experimental.strictRouteMatching,
+            defaultAppPaths: Object.keys(appDefaultPaths ?? {})
+        });
+        // Only App Router pages can make an intercepted URL directly renderable.
+        // Route handlers and metadata routes may share the pathname, but they
+        // cannot provide the canonical page shown by an initial request.
+        const appPagePathsPerRoute = Object.fromEntries(Object.entries(appPathsPerRoute).flatMap(([route, routeAppPaths])=>{
+            const pageAppPaths = routeAppPaths.filter(_isapppageroute.isAppPageRoute);
+            return pageAppPaths.length > 0 ? [
+                [
+                    route,
+                    pageAppPaths
+                ]
+            ] : [];
+        }));
+        const missingCanonicalInterceptionRoutes = config.experimental.strictRouteMatching ? (0, _interceptionroutes.findMissingCanonicalInterceptionRoutes)(appPagePathsPerRoute) : [];
+        const routeMatchingErrors = [];
+        if (missingCanonicalInterceptionRoutes.length > 0) {
+            routeMatchingErrors.push(new _missingcanonicalinterceptionrouteserror.MissingCanonicalInterceptionRoutesError(missingCanonicalInterceptionRoutes));
+        }
+        if (incompatibleParallelRouteSlots.length > 0) {
+            routeMatchingErrors.push(new _incompatibleparallelrouteslotserror.IncompatibleParallelRouteSlotsError(await Promise.all(incompatibleParallelRouteSlots.map(async (incompatibleRoute)=>{
+                const layoutPagePath = _path.posix.join(incompatibleRoute.layoutPath, 'layout');
+                const layoutFile = await (0, _findpagefile.findPageFile)(appDir, layoutPagePath, pageExtensions, true);
+                return {
+                    ...incompatibleRoute,
+                    layoutFile: (0, _path.relative)(rootDir, layoutFile ? (0, _path.join)(appDir, layoutFile) : (0, _path.join)(appDir, layoutPagePath))
+                };
+            }))));
+        }
+        if (unmatchedAppPages.length > 0) {
+            routeMatchingErrors.push(new _unmatchedapppageserror.UnmatchedAppPagesError(unmatchedAppPages.map((appPath)=>{
+                const absolutePagePath = appPageFiles.get(appPath);
+                if (!absolutePagePath) return appPath;
+                return (0, _path.relative)(rootDir, getPageFilePath({
+                    absolutePagePath,
+                    pagesDir,
+                    appDir,
+                    rootDir
+                }));
+            })));
+        }
+        if (routeMatchingErrors.length > 0) {
+            const warning = (0, _strictroutematchingconfig.getStrictRouteMatchingDefaultWarning)(config);
+            if (warning) {
+                _log.warnOnce(warning);
+            }
+        }
+        if (routeMatchingErrors.length === 1) {
+            throw routeMatchingErrors[0];
+        }
+        if (routeMatchingErrors.length > 1) {
+            throw new Error(routeMatchingErrors.map((error)=>error.message).join('\n\n'));
+        }
         // Make sure to sort parallel routes to make the result deterministic.
         appPathsPerRoute = Object.fromEntries(Object.entries(appPathsPerRoute).map(([k, v])=>[
                 k,
@@ -294,6 +401,9 @@ async function createEntrypoints(params) {
             ]));
     }
     const getEntryHandler = (mappings, pagesType)=>async (page)=>{
+            if (pagesType === _pagetypes.PAGE_TYPES.APP && config.experimental.strictRouteMatching && !((0, _apppaths.normalizeAppPath)(page) in appPathsPerRoute)) {
+                return;
+            }
             // Apply deferred entries filter if specified
             if (deferredEntriesFilter) {
                 const isDeferred = isDeferredEntry(page, deferredEntries);
@@ -317,6 +427,10 @@ async function createEntrypoints(params) {
                 appDir,
                 rootDir
             });
+            // A deferred-entry callback may materialize source beside this route.
+            // Keep the owning directory so the bundler can invalidate that subtree
+            // without discarding filesystem cache entries for the rest of the app.
+            entrySourceDirectories.add((0, _path.dirname)(pageFilePath));
             const isInsideAppDir = !!appDir && (absolutePagePath.startsWith(_constants.APP_DIR_ALIAS) || absolutePagePath.startsWith(appDir));
             const staticInfo = await (0, _getstaticinfoincludinglayouts.getStaticInfoIncludingLayouts)({
                 isInsideAppDir,
@@ -339,6 +453,9 @@ async function createEntrypoints(params) {
                 ];
             }
             const isInstrumentation = (0, _utils.isInstrumentationHookFile)(page) && pagesType === _pagetypes.PAGE_TYPES.ROOT;
+            const matchedAppPaths = pagesType === _pagetypes.PAGE_TYPES.APP ? appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)] ?? null : null;
+            const normalizedAppPage = (0, _apppaths.normalizeAppPath)(page);
+            const isFinalRouteMatcher = config.experimental.strictRouteMatching && (matchedAppPaths == null ? void 0 : matchedAppPaths.length) && matchedAppPaths.some((appPath)=>(0, _apppaths.normalizeAppPath)(appPath) === normalizedAppPage) && (0, _apppaths.selectAppPageEntry)(normalizedAppPage, matchedAppPaths) === page;
             runDependingOnPageType({
                 page,
                 pageRuntime: staticInfo.runtime,
@@ -356,7 +473,6 @@ async function createEntrypoints(params) {
                 },
                 onServer: ()=>{
                     if (pagesType === 'app' && appDir) {
-                        const matchedAppPaths = appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)];
                         server[serverBundlePath] = getAppEntry({
                             page,
                             name: serverBundlePath,
@@ -370,7 +486,10 @@ async function createEntrypoints(params) {
                             nextConfigOutput: config.output,
                             preferredRegion: staticInfo.preferredRegion,
                             middlewareConfig: (0, _utils1.encodeToBase64)(staticInfo.middleware || {}),
-                            isGlobalNotFoundEnabled: config.experimental.globalNotFound ? true : undefined
+                            isGlobalNotFoundEnabled: config.experimental.globalNotFound ? true : undefined,
+                            explicitParallelRouteChildren: config.experimental.explicitParallelRouteChildren ? true : undefined,
+                            strictRouteMatching: config.experimental.strictRouteMatching ? true : undefined,
+                            isFinalRouteMatcher: isFinalRouteMatcher ? true : undefined
                         });
                     } else if (isInstrumentation) {
                         server[serverBundlePath.replace('src/', '')] = getInstrumentationEntry({
@@ -429,7 +548,6 @@ async function createEntrypoints(params) {
                         });
                     } else {
                         if (pagesType === 'app') {
-                            const matchedAppPaths = appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)];
                             appDirLoader = getAppEntry({
                                 name: serverBundlePath,
                                 page,
@@ -445,7 +563,10 @@ async function createEntrypoints(params) {
                                 // Still passing it here for consistency.
                                 preferredRegion: staticInfo.preferredRegion,
                                 middlewareConfig: Buffer.from(JSON.stringify(staticInfo.middleware || {})).toString('base64'),
-                                isGlobalNotFoundEnabled: config.experimental.globalNotFound ? true : undefined
+                                isGlobalNotFoundEnabled: config.experimental.globalNotFound ? true : undefined,
+                                explicitParallelRouteChildren: config.experimental.explicitParallelRouteChildren ? true : undefined,
+                                strictRouteMatching: config.experimental.strictRouteMatching ? true : undefined,
+                                isFinalRouteMatcher: isFinalRouteMatcher ? true : undefined
                             }).import;
                         }
                         edgeServer[serverBundlePath] = getEdgeServerEntry({
@@ -485,6 +606,9 @@ async function createEntrypoints(params) {
         client,
         server,
         edgeServer,
+        entrySourceDirectories: [
+            ...entrySourceDirectories
+        ].sort(),
         middlewareMatchers
     };
 }

package/app/node_modules/next/dist/build/get-babel-loader-config.js

@@ -30,11 +30,7 @@ function getReactCompiler() {
     try {
         return require.resolve('babel-plugin-react-compiler');
     } catch  {
-        throw Object.defineProperty(new Error('Failed to load the `babel-plugin-react-compiler`. It is required to use the React Compiler. Please install it.'), "__NEXT_ERROR_CODE", {
-            value: "E78",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Failed to load the `babel-plugin-react-compiler`. It is required to use the React Compiler. Please install it.');
     }
 }
 const getReactCompilerPlugins = (maybeOptions, isServer, isDev, cwd)=>{
@@ -58,12 +54,16 @@ const getReactCompilerPlugins = (maybeOptions, isServer, isDev, cwd)=>{
     } catch  {
     // react/package.json not resolvable — skip target detection
     }
+    const options = typeof maybeOptions === 'boolean' ? {} : maybeOptions;
+    const { environment: userEnvironment, ...compilerOptions } = options;
     const environment = {
-        enableNameAnonymousFunctions: isDev
+        enableNameAnonymousFunctions: isDev,
+        ...(userEnvironment == null ? void 0 : userEnvironment.enablePreserveExistingMemoizationGuarantees) !== undefined ? {
+            enablePreserveExistingMemoizationGuarantees: userEnvironment.enablePreserveExistingMemoizationGuarantees
+        } : {}
     };
-    const options = typeof maybeOptions === 'boolean' ? {} : maybeOptions;
-    const compilerOptions = {
-        ...options,
+    const resolvedCompilerOptions = {
+        ...compilerOptions,
         ...target ? {
             target
         } : {},
@@ -72,7 +72,7 @@ const getReactCompilerPlugins = (maybeOptions, isServer, isDev, cwd)=>{
     return [
         [
             getReactCompiler(),
-            compilerOptions
+            resolvedCompilerOptions
         ]
     ];
 };

package/app/node_modules/next/dist/build/get-convention-file-base-name.js

@@ -0,0 +1,29 @@
+/**
+ * Extract the convention base name (e.g. `"proxy"`, `"middleware"`,
+ * `"instrumentation"`) from a filename.
+ *
+ * Returns the segment before the first dot — NOT what `path.parse().name`
+ * returns. The stdlib only strips the last extension, which is wrong here:
+ * with a compound `pageExtensions` entry like `"page.ts"` the file
+ * `proxy.page.ts` has `path.parse().name === "proxy.page"`, but its
+ * convention base name is `"proxy"`.
+ *
+ * This must stay in lockstep with the Rust `convention_file_base_name`
+ * helper used by the Turbopack build path (see
+ * `crates/next-api/src/path_utils.rs`). Any change here needs the same
+ * change there.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getConventionFileBaseName", {
+    enumerable: true,
+    get: function() {
+        return getConventionFileBaseName;
+    }
+});
+function getConventionFileBaseName(fileBase) {
+    return fileBase.split('.', 1)[0];
+}
+
+//# sourceMappingURL=get-convention-file-base-name.js.map

package/app/node_modules/next/dist/build/get-static-info-including-layouts.js

@@ -71,7 +71,6 @@ async function getStaticInfoIncludingLayouts({ isInsideAppDir, pageExtensions, p
     const config = (0, _utils.reduceAppConfig)(segments);
     return {
         ...pageStaticInfo,
-        config,
         runtime: config.runtime,
         preferredRegion: config.preferredRegion,
         maxDuration: config.maxDuration

package/app/node_modules/next/dist/build/handle-externals.js

@@ -215,11 +215,7 @@ function makeExternalHandler({ config, optOutBundlingPackageRegex, transpiledPac
         // ESM externals can only be imported (and not required).
         // Make an exception in loose mode.
         if (!isEsmRequested && isEsm && !looseEsmExternals && !isLocal) {
-            throw Object.defineProperty(new Error(`ESM packages (${request}) need to be imported. Use 'import' to reference the package instead. https://nextjs.org/docs/messages/import-esm-externals`), "__NEXT_ERROR_CODE", {
-                value: "E310",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`ESM packages (${request}) need to be imported. Use 'import' to reference the package instead. https://nextjs.org/docs/messages/import-esm-externals`);
         }
         const externalType = isEsm ? 'module' : 'commonjs';
         // Default pages have to be transpiled

package/app/node_modules/next/dist/build/load-jsconfig.js

@@ -95,11 +95,7 @@ function parseJsonFile(filePath) {
             message: err.message,
             color: true
         });
-        throw Object.defineProperty(new Error(`Failed to parse "${filePath}":\n${codeFrame ?? err.message}`), "__NEXT_ERROR_CODE", {
-            value: "E1087",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Failed to parse "${filePath}":\n${codeFrame ?? err.message}`);
     }
 }
 async function loadJsConfig(dir, config) {

package/app/node_modules/next/dist/build/lockfile.js

@@ -118,12 +118,8 @@ class Lockfile {
             } catch (e) {
                 // this happens if there's an IO error (e.g. `ENOENT`), which is
                 // different than if we just didn't acquire the lock
-                throw Object.defineProperty(new Error('An IO error occurred while attempting to create and acquire the lockfile', {
+                throw new Error('An IO error occurred while attempting to create and acquire the lockfile', {
                     cause: e
-                }), "__NEXT_ERROR_CODE", {
-                    value: "E859",
-                    enumerable: false,
-                    configurable: true
                 });
             }
             if (nativeLockfile != null) {

package/app/node_modules/next/dist/build/next-config-ts/transpile-config.js

@@ -93,12 +93,8 @@ async function transpileConfig({ nextConfigPath, dir }) {
             compilerOptions
         });
     } catch (cause) {
-        throw Object.defineProperty(new Error(`Failed to transpile "${_nodepath.default.basename(nextConfigPath)}".`, {
+        throw new Error(`Failed to transpile "${_nodepath.default.basename(nextConfigPath)}".`, {
             cause
-        }), "__NEXT_ERROR_CODE", {
-            value: "E797",
-            enumerable: false,
-            configurable: true
         });
     }
 }

package/app/node_modules/next/dist/build/nft.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    mapNftFileEntries: null,
+    resolveNftOutputPath: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    mapNftFileEntries: function() {
+        return mapNftFileEntries;
+    },
+    resolveNftOutputPath: function() {
+        return resolveNftOutputPath;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function invalid(message) {
+    throw new Error(`Invalid NFT metadata: ${message}`);
+}
+function isRelativePathInside(relative) {
+    return relative === '' || !_path.default.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${_path.default.sep}`);
+}
+function relativePathIfInside(root, candidate) {
+    const relative = _path.default.relative(root, candidate);
+    return isRelativePathInside(relative) ? relative : undefined;
+}
+function mapBasePath(traceFileDirectory, baseRoot, relativePath) {
+    const source = _path.default.resolve(traceFileDirectory, relativePath);
+    return {
+        source,
+        destination: _path.default.relative(baseRoot, source)
+    };
+}
+function mapBasePathInsideRoot(traceFileDirectory, baseRoot, relativePath) {
+    const mapped = mapBasePath(traceFileDirectory, baseRoot, relativePath);
+    if (!isRelativePathInside(mapped.destination)) {
+        invalid(`path ${JSON.stringify(relativePath)} escapes the base root`);
+    }
+    return mapped;
+}
+function mapAdditionalRootPath(traceFileDirectory, root, relativePath) {
+    const rootPath = _path.default.resolve(traceFileDirectory, root.path);
+    const source = _path.default.resolve(rootPath, relativePath);
+    if (relativePathIfInside(rootPath, source) === undefined) {
+        invalid(`path ${JSON.stringify(relativePath)} escapes additional root ${root.name}`);
+    }
+    return {
+        source,
+        destination: _path.default.join('next_additional_roots', root.name, relativePath)
+    };
+}
+function mapNftFileEntries(nft, traceFilePath, baseRoot, options) {
+    const traceFileDirectory = _path.default.dirname(traceFilePath);
+    const roots = nft.additionalRoots ?? [];
+    const result = [];
+    const mapList = (list, currentRootIndex)=>{
+        // The list of symlinks is always in sorted order (by file index)
+        const { files, fileHashes } = list;
+        const symlinks = list.symlinks ?? [];
+        let symlinkCursor = 0;
+        let nextSymlink = symlinks[symlinkCursor];
+        for(let fileIndex = 0; fileIndex < files.length; fileIndex++){
+            const file = files[fileIndex];
+            let symlink;
+            if ((nextSymlink == null ? void 0 : nextSymlink[0]) === fileIndex) {
+                symlink = nextSymlink;
+                nextSymlink = symlinks[++symlinkCursor];
+            }
+            // a currentRootIndex of -1 denotes a path relative to the *.nft.json file
+            // (i.e. not an additional root)
+            const mapped = currentRootIndex === -1 ? mapBasePath(traceFileDirectory, baseRoot, file) : mapAdditionalRootPath(traceFileDirectory, roots[currentRootIndex], file);
+            if (currentRootIndex === -1 && (options == null ? void 0 : options.skipBaseRootEscapes) && !isRelativePathInside(mapped.destination)) {
+                options.onBaseRootEscape == null ? void 0 : options.onBaseRootEscape.call(options, mapped.source);
+                continue;
+            }
+            let symlinkTarget;
+            let symlinkCrossesRoot = false;
+            if (symlink !== undefined) {
+                const [, target, rootIndex] = symlink;
+                symlinkCrossesRoot = rootIndex !== undefined;
+                const targetRootIndex = rootIndex ?? currentRootIndex;
+                symlinkTarget = targetRootIndex === -1 ? ((options == null ? void 0 : options.skipBaseRootEscapes) ? mapBasePathInsideRoot(traceFileDirectory, baseRoot, target) : mapBasePath(traceFileDirectory, baseRoot, target)).destination : mapAdditionalRootPath(traceFileDirectory, roots[targetRootIndex], target).destination;
+            }
+            result.push({
+                source: mapped.source,
+                destination: mapped.destination,
+                hash: fileHashes == null ? void 0 : fileHashes[fileIndex],
+                symlinkTarget,
+                symlinkCrossesRoot
+            });
+        }
+    };
+    mapList(nft, -1);
+    for(let rootIndex = 0; rootIndex < roots.length; rootIndex++){
+        mapList(roots[rootIndex], rootIndex);
+    }
+    return result;
+}
+function resolveNftOutputPath(outputRoot, destination) {
+    const outputPath = _path.default.resolve(outputRoot, destination);
+    if (relativePathIfInside(outputRoot, outputPath) === undefined) {
+        invalid(`output path ${JSON.stringify(destination)} escapes the deployment root`);
+    }
+    return outputPath;
+}
+
+//# sourceMappingURL=nft.js.map

package/app/node_modules/next/dist/build/normalize-catchall-routes.js

@@ -2,75 +2,27 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "normalizeCatchAllRoutes", {
-    enumerable: true,
-    get: function() {
-        return normalizeCatchAllRoutes;
-    }
+0 && (module.exports = {
+    findIncompatibleParallelRouteSlots: null,
+    normalizeCatchAllRoutes: null
 });
-const _interceptionroutes = require("../shared/lib/router/utils/interception-routes");
-const _apppathnamenormalizer = require("../server/normalizers/built/app/app-pathname-normalizer");
-function normalizeCatchAllRoutes(appPaths, normalizer = new _apppathnamenormalizer.AppPathnameNormalizer()) {
-    const catchAllRoutes = [
-        ...new Set(Object.values(appPaths).flat().filter(isCatchAllRoute)// Sorting is important because we want to match the most specific path.
-        .sort((a, b)=>b.split('/').length - a.split('/').length))
-    ];
-    // interception routes should only be matched by a single entrypoint
-    // we don't want to push a catch-all route to an interception route
-    // because it would mean the interception would be handled by the wrong page component
-    const filteredAppPaths = Object.keys(appPaths).filter((route)=>!(0, _interceptionroutes.isInterceptionRouteAppPath)(route));
-    for (const appPath of filteredAppPaths){
-        for (const catchAllRoute of catchAllRoutes){
-            const normalizedCatchAllRoute = normalizer.normalize(catchAllRoute);
-            const normalizedCatchAllRouteBasePath = normalizedCatchAllRoute.slice(0, normalizedCatchAllRoute.search(catchAllRouteRegex));
-            if (// check if the appPath could match the catch-all
-            appPath.startsWith(normalizedCatchAllRouteBasePath) && // check if there's not already a slot value that could match the catch-all
-            !appPaths[appPath].some((path)=>hasMatchedSlots(path, catchAllRoute))) {
-                // optional catch-all routes are not currently supported, but leaving this logic in place
-                // for when they are eventually supported.
-                if (isOptionalCatchAll(catchAllRoute)) {
-                    // optional catch-all routes should match both the root segment and any segment after it
-                    // for example, `/[[...slug]]` should match `/` and `/foo` and `/foo/bar`
-                    appPaths[appPath].push(catchAllRoute);
-                } else if (isCatchAll(catchAllRoute)) {
-                    // regular catch-all (single bracket) should only match segments after it
-                    // for example, `/[...slug]` should match `/foo` and `/foo/bar` but not `/`
-                    if (normalizedCatchAllRouteBasePath !== appPath) {
-                        appPaths[appPath].push(catchAllRoute);
-                    }
-                }
-            }
-        }
-    }
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
 }
-function hasMatchedSlots(path1, path2) {
-    const slots1 = path1.split('/').filter(isMatchableSlot);
-    const slots2 = path2.split('/').filter(isMatchableSlot);
-    // if the catch-all route does not have the same number of slots as the app path, it can't match
-    if (slots1.length !== slots2.length) return false;
-    // compare the slots in both paths. For there to be a match, each slot must be the same
-    for(let i = 0; i < slots1.length; i++){
-        if (slots1[i] !== slots2[i]) return false;
+_export(exports, {
+    findIncompatibleParallelRouteSlots: function() {
+        return _normalizecatchallroutes.findIncompatibleParallelRouteSlots;
+    },
+    normalizeCatchAllRoutes: function() {
+        return normalizeCatchAllRoutes;
     }
-    return true;
-}
-/**
- * Returns true for slots that should be considered when checking for match compatibility.
- * Excludes children slots because these are similar to having a segment-level `page`
- * which would cause a slot length mismatch when comparing it to a catch-all route.
- */ function isMatchableSlot(segment) {
-    return segment.startsWith('@') && segment !== '@children';
-}
-const catchAllRouteRegex = /\[?\[\.\.\./;
-function isCatchAllRoute(pathname) {
-    // Optional catch-all slots are not currently supported, and as such they are not considered when checking for match compatability.
-    return !isOptionalCatchAll(pathname) && isCatchAll(pathname);
-}
-function isOptionalCatchAll(pathname) {
-    return pathname.includes('[[...');
-}
-function isCatchAll(pathname) {
-    return pathname.includes('[...');
+});
+const _normalizecatchallroutes = require("../server/lib/router-utils/normalize-catchall-routes");
+function normalizeCatchAllRoutes(appPaths, options = {}) {
+    return (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPaths, undefined, options);
 }
 
 //# sourceMappingURL=normalize-catchall-routes.js.map