@aeolus-fleet/console 0.34.0 → 0.36.0

package/.next/standalone/node_modules/next/dist/build/static-paths/pages.js

@@ -37,34 +37,18 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     });
     const expectedReturnVal = `Expected: { paths: [], fallback: boolean }\n` + `See here for more info: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`;
     if (!staticPathsResult || typeof staticPathsResult !== 'object' || Array.isArray(staticPathsResult)) {
-        throw Object.defineProperty(new Error(`Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E1004",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`);
     }
     const invalidStaticPathKeys = Object.keys(staticPathsResult).filter((key)=>!(key === 'paths' || key === 'fallback'));
     if (invalidStaticPathKeys.length > 0) {
-        throw Object.defineProperty(new Error(`Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(', ')}) ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E1047",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(', ')}) ${expectedReturnVal}`);
     }
     if (!(typeof staticPathsResult.fallback === 'boolean' || staticPathsResult.fallback === 'blocking')) {
-        throw Object.defineProperty(new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal), "__NEXT_ERROR_CODE", {
-            value: "E1034",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal);
     }
     const toPrerender = staticPathsResult.paths;
     if (!Array.isArray(toPrerender)) {
-        throw Object.defineProperty(new Error(`Invalid \`paths\` value returned from getStaticPaths in ${page}.\n` + `\`paths\` must be an array of strings or objects of shape { params: [key: string]: string }`), "__NEXT_ERROR_CODE", {
-            value: "E83",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invalid \`paths\` value returned from getStaticPaths in ${page}.\n` + `\`paths\` must be an array of strings or objects of shape { params: [key: string]: string }`);
     }
     toPrerender.forEach((entry)=>{
         // For a string-provided path, we must make sure it matches the dynamic
@@ -80,11 +64,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
             }
             const params = _routeMatcher(cleanedEntry);
             if (!params) {
-                throw Object.defineProperty(new Error(`The provided path \`${cleanedEntry}\` does not match the page: \`${page}\`.`), "__NEXT_ERROR_CODE", {
-                    value: "E481",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`The provided path \`${cleanedEntry}\` does not match the page: \`${page}\`.`);
             }
             // If leveraging the string paths variant the entry should already be
             // encoded so we decode the segments ensuring we only escape path
@@ -104,11 +84,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
         } else {
             const invalidKeys = Object.keys(entry).filter((key)=>key !== 'params' && key !== 'locale');
             if (invalidKeys.length) {
-                throw Object.defineProperty(new Error(`Additional keys were returned from \`getStaticPaths\` in page "${page}". ` + `URL Parameters intended for this dynamic route must be nested under the \`params\` key, i.e.:` + `\n\n\treturn { params: { ${routeParameterKeys.map((k)=>`${k}: ...`).join(', ')} } }` + `\n\nKeys that need to be moved: ${invalidKeys.join(', ')}.\n`), "__NEXT_ERROR_CODE", {
-                    value: "E322",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Additional keys were returned from \`getStaticPaths\` in page "${page}". ` + `URL Parameters intended for this dynamic route must be nested under the \`params\` key, i.e.:` + `\n\n\treturn { params: { ${routeParameterKeys.map((k)=>`${k}: ...`).join(', ')} } }` + `\n\nKeys that need to be moved: ${invalidKeys.join(', ')}.\n`);
             }
             const { params = {} } = entry;
             let builtPage = page;
@@ -120,11 +96,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
                     paramValue = [];
                 }
                 if (repeat && !Array.isArray(paramValue) || !repeat && typeof paramValue !== 'string' || typeof paramValue === 'undefined') {
-                    throw Object.defineProperty(new Error(`A required parameter (${validParamKey}) was not provided as ${repeat ? 'an array' : 'a string'} received ${typeof paramValue} in getStaticPaths for ${page}`), "__NEXT_ERROR_CODE", {
-                        value: "E620",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`A required parameter (${validParamKey}) was not provided as ${repeat ? 'an array' : 'a string'} received ${typeof paramValue} in getStaticPaths for ${page}`);
                 }
                 let replaced = `[${repeat ? '...' : ''}${validParamKey}]`;
                 if (optional) {
@@ -137,11 +109,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
                 return;
             }
             if (entry.locale && !(locales == null ? void 0 : locales.includes(entry.locale))) {
-                throw Object.defineProperty(new Error(`Invalid locale returned from getStaticPaths for ${page}, the locale ${entry.locale} is not specified in ${configFileName}`), "__NEXT_ERROR_CODE", {
-                    value: "E358",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid locale returned from getStaticPaths for ${page}, the locale ${entry.locale} is not specified in ${configFileName}`);
             }
             const curLocale = entry.locale || defaultLocale || '';
             const pathname = (0, _utils.normalizePathname)(`${curLocale ? `/${curLocale}` : ''}${curLocale && builtPage === '/' ? '' : builtPage}`);

package/.next/standalone/node_modules/next/dist/build/static-paths/param-matching.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getParamMatchingFallbackMode: null,
+    resolveParamMatching: null,
+    validateParamMatchingCoherence: null,
+    validateParamMatchingParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getParamMatchingFallbackMode: function() {
+        return getParamMatchingFallbackMode;
+    },
+    resolveParamMatching: function() {
+        return resolveParamMatching;
+    },
+    validateParamMatchingCoherence: function() {
+        return validateParamMatchingCoherence;
+    },
+    validateParamMatchingParams: function() {
+        return validateParamMatchingParams;
+    }
+});
+const _appsegments = require("../segment-config/app/app-segments");
+const _fallback = require("../../lib/fallback");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
+async function resolveParamMatching(page, segmentTree, pathnameSegments) {
+    const configuredSegments = [];
+    const nodes = [
+        ...segmentTree
+    ];
+    for(let index = 0; index < nodes.length; index++){
+        const [segment, children] = nodes[index];
+        if (segment.paramMatching !== undefined) configuredSegments.push(segment);
+        nodes.push(...children);
+    }
+    if (configuredSegments.length === 0) return undefined;
+    const routeParamNames = new Set(pathnameSegments.map(({ paramName })=>paramName));
+    const candidates = new Map();
+    const paramsMissingPolicy = new Set();
+    // Start independent generators together, before merging their results down
+    // each branch.
+    const fragments = new Map();
+    await Promise.all(configuredSegments.map(async (segment)=>{
+        const paramMatchingExport = segment.paramMatching;
+        const value = typeof paramMatchingExport === 'function' ? await paramMatchingExport() : paramMatchingExport;
+        for (const paramName of Object.keys(value)){
+            if (!routeParamNames.has(paramName)) {
+                const exportName = typeof paramMatchingExport === 'function' ? 'unstable_generateParamMatching' : 'unstable_paramMatching';
+                throw new Error(`Invalid parameter "${paramName}" in \`${exportName}\` for "${page}". Parameter matching may only configure dynamic parameters in this route.`);
+            }
+        }
+        fragments.set(segment, value);
+    }));
+    function visit([segment, children], inherited, paramNames) {
+        const branchCandidates = new Map(inherited);
+        const fragment = fragments.get(segment);
+        if (fragment) {
+            for (const [paramName, mode] of Object.entries(fragment)){
+                branchCandidates.set(paramName, {
+                    mode,
+                    filePath: segment.filePath
+                });
+            }
+        }
+        if (segment.paramName) paramNames = [
+            ...paramNames,
+            segment.paramName
+        ];
+        if (children.length > 0) {
+            for (const child of children)visit(child, branchCandidates, paramNames);
+            return;
+        }
+        // Compare the effective policies at every leaf, including leaves without
+        // exports. A sibling's override must not erase this branch's inheritance.
+        for (const paramName of paramNames){
+            if (!branchCandidates.has(paramName)) {
+                paramsMissingPolicy.add(paramName);
+            }
+        }
+        for (const [paramName, candidate] of branchCandidates){
+            const parallelCandidates = candidates.get(paramName);
+            if (!parallelCandidates) {
+                candidates.set(paramName, [
+                    candidate
+                ]);
+            } else if (!parallelCandidates.some(({ mode })=>mode === candidate.mode)) {
+                parallelCandidates.push(candidate);
+            }
+        }
+    }
+    for (const root of segmentTree)visit(root, new Map(), []);
+    const policy = {};
+    for (const { paramName } of pathnameSegments){
+        const paramCandidates = candidates.get(paramName);
+        if (!paramCandidates) continue;
+        const mode = paramCandidates[0].mode;
+        if (paramCandidates.some((candidate)=>candidate.mode !== mode)) {
+            const definitions = paramCandidates.map((candidate)=>`${candidate.filePath ?? '<unknown module>'} (${candidate.mode})`).join(', ');
+            throw new Error(`Route "${page}" has conflicting parallel parameter matching modes for parameter "${paramName}": ${definitions}.`);
+        }
+        if (mode === 'not-found' && paramsMissingPolicy.has(paramName)) {
+            throw new Error(`Parameter "${paramName}" in route "${page}" uses "not-found" in one parallel branch, but another branch has no explicit policy. Every parallel branch sharing this parameter must explicitly configure "not-found", either directly or through an inherited layout.`);
+        }
+        policy[paramName] = mode;
+    }
+    let previousPhase = -1;
+    let previousParamName;
+    let unconfiguredPrefixParamName;
+    for (const { paramName } of pathnameSegments){
+        const mode = policy[paramName];
+        if (!mode) {
+            unconfiguredPrefixParamName ??= paramName;
+            continue;
+        }
+        if (mode === 'not-found' && unconfiguredPrefixParamName !== undefined) {
+            throw new Error(`Invalid parameter matching for "${page}": Parameter "${unconfiguredPrefixParamName}" must explicitly configure "not-found" before parameter "${paramName}" uses "not-found". Configure the preceding parameter directly or in an inherited layout; it cannot be closed by inference.`);
+        }
+        const currentPhase = _appsegments.PARAM_MATCHING_MODES.indexOf(mode);
+        if (currentPhase < previousPhase) {
+            throw new Error(`Invalid parameter matching for "${page}": parameter "${paramName}" uses "${mode}" after parameter "${previousParamName}" uses a later matching phase. Expected parameters in this order: "not-found", "blocking", "fallback", then "dynamic".`);
+        }
+        previousPhase = currentPhase;
+        previousParamName = paramName;
+    }
+    return policy;
+}
+function validateParamMatchingCoherence(paramMatchingByRoute) {
+    const parameters = new Map();
+    for (const [appPath, paramMatching] of [
+        ...paramMatchingByRoute
+    ].sort(([a], [b])=>a.localeCompare(b))){
+        const route = (0, _apppaths.normalizeAppPath)(appPath);
+        let prefix = '';
+        for (const segment of route.split('/')){
+            if (!segment) continue;
+            prefix += `/${segment}`;
+            const param = (0, _getsegmentparam.getSegmentParam)(segment);
+            if (!param) continue;
+            const notFound = (paramMatching == null ? void 0 : paramMatching[param.paramName]) === 'not-found';
+            const previous = parameters.get(prefix);
+            if (previous === undefined) {
+                parameters.set(prefix, [
+                    route,
+                    notFound
+                ]);
+            } else if (previous[1] !== notFound) {
+                const closedRoute = notFound ? route : previous[0];
+                const openRoute = notFound ? previous[0] : route;
+                throw new Error(`Parameter "${param.paramName}" at "${prefix}" uses "not-found" in route "${closedRoute}". Route "${openRoute}" must explicitly configure "not-found" for this parameter, either directly or through an inherited layout.`);
+            }
+        }
+    }
+}
+function getParamMatchingFallbackMode(paramMatching, fallbackRouteParams, inferredFallbackMode, rootParamKeys) {
+    let hasInferredBlockingRoot = false;
+    for (const { paramName } of fallbackRouteParams){
+        switch(paramMatching[paramName]){
+            case undefined:
+                if (rootParamKeys.has(paramName)) hasInferredBlockingRoot = true;
+                break;
+            case 'not-found':
+                return _fallback.FallbackMode.NOT_FOUND;
+            case 'blocking':
+                return _fallback.FallbackMode.BLOCKING_STATIC_RENDER;
+            case 'fallback':
+            case 'dynamic':
+                return hasInferredBlockingRoot ? _fallback.FallbackMode.BLOCKING_STATIC_RENDER : _fallback.FallbackMode.PRERENDER;
+        }
+    }
+    // Root parameters retain their existing blocking inference. Keep walking
+    // above so a later explicit not-found can still reject the whole match.
+    return hasInferredBlockingRoot ? _fallback.FallbackMode.BLOCKING_STATIC_RENDER : inferredFallbackMode;
+}
+function validateParamMatchingParams(page, paramMatching, generatedParamNames, missingParamNames, pathnameSegments, output) {
+    let dynamicParamName;
+    for (const { paramName } of pathnameSegments){
+        const mode = paramMatching[paramName];
+        if (mode === 'dynamic') dynamicParamName = paramName;
+        if (dynamicParamName && generatedParamNames.has(paramName)) {
+            throw new Error(`Route "${page}" cannot prerender parameter "${paramName}" because parameter "${dynamicParamName}" is configured as "dynamic".`);
+        }
+        if (mode === 'not-found' && missingParamNames.has(paramName)) {
+            throw new Error(`Route "${page}" configures parameter "${paramName}" as "not-found", but generateStaticParams returned a result without that parameter.`);
+        }
+        if (output === 'export' && mode !== 'not-found') {
+            throw new Error(`Route "${page}" must configure parameter "${paramName}" as "not-found" when using parameter matching with "output: export".`);
+        }
+    }
+}
+
+//# sourceMappingURL=param-matching.js.map