failproofai 1.0.11-beta.1 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/build/segment-config/app/app-segments.js

@@ -2,9 +2,21 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "collectSegments", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    PARAM_MATCHING_MODES: null,
+    collectSegments: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PARAM_MATCHING_MODES: function() {
+        return PARAM_MATCHING_MODES;
+    },
+    collectSegments: function() {
         return collectSegments;
     }
 });
@@ -14,9 +26,35 @@ const _checks = require("../../../server/route-modules/checks");
 const _clientandserverreferences = require("../../../lib/client-and-server-references");
 const _getsegmentparam = require("../../../shared/lib/router/utils/get-segment-param");
 const _appdirmodule = require("../../../server/lib/app-dir-module");
+const _ensurestatic = require("../../../server/app-render/segment-config/ensure-static");
+const _instantconfig = require("../../../server/app-render/instant-validation/instant-config");
+const _isplainobject = require("../../../shared/lib/is-plain-object");
+const PARAM_MATCHING_MODES = [
+    'not-found',
+    'blocking',
+    'fallback',
+    'dynamic'
+];
+function validateParamMatchingExport(route, filePath, exportName, value, visibleParamNames) {
+    if (!(0, _isplainobject.isPlainObject)(value)) {
+        const valueType = value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+        throw new Error(`Invalid value from \`${exportName}\` for "${route}". Expected an object, but received ${valueType}.`);
+    }
+    const paramMatching = {};
+    for (const [paramName, mode] of Object.entries(value)){
+        if (!visibleParamNames.includes(paramName)) {
+            throw new Error(`Invalid parameter "${paramName}" in \`${exportName}\` for "${route}". The export in "${filePath}" may only configure parameters defined at or above its segment.`);
+        }
+        if (!PARAM_MATCHING_MODES.includes(mode)) {
+            throw new Error(`Invalid mode for parameter "${paramName}" in \`${exportName}\` for "${route}". Expected "not-found", "blocking", "fallback", or "dynamic", but received ${JSON.stringify(mode)}.`);
+        }
+        paramMatching[paramName] = mode;
+    }
+    return paramMatching;
+}
 /**
  * Parses the app config and attaches it to the segment.
- */ function attach(segment, userland, route) {
+ */ function attach(segment, userland, route, visibleParamNames) {
     // If the userland is not an object, then we can't do anything with it.
     if (typeof userland !== 'object' || userland === null) {
         return;
@@ -39,11 +77,26 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
         }
         // Validate that `generateStaticParams` makes sense in this context.
         if (((_segment_config = segment.config) == null ? void 0 : _segment_config.runtime) === 'edge') {
-            throw Object.defineProperty(new Error('Edge runtime is not supported with `generateStaticParams`.'), "__NEXT_ERROR_CODE", {
-                value: "E502",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Edge runtime is not supported with `generateStaticParams`.');
+        }
+    }
+    const hasStaticParamMatching = 'unstable_paramMatching' in userland;
+    const hasGeneratedParamMatching = 'unstable_generateParamMatching' in userland;
+    if (hasStaticParamMatching || hasGeneratedParamMatching) {
+        if (hasStaticParamMatching && hasGeneratedParamMatching) {
+            throw new Error(`Route "${route}" cannot export both \`unstable_paramMatching\` and \`unstable_generateParamMatching\`.`);
+        }
+        if (hasStaticParamMatching) {
+            segment.paramMatching = validateParamMatchingExport(route, segment.filePath, 'unstable_paramMatching', userland.unstable_paramMatching, visibleParamNames);
+        } else {
+            const generate = userland.unstable_generateParamMatching;
+            if (typeof generate !== 'function') {
+                throw new Error(`Route "${route}" must export \`unstable_generateParamMatching\` as a function.`);
+            }
+            const { filePath } = segment;
+            // Retain the module's scope without evaluating user code until static
+            // path generation has established its work store and cache context.
+            segment.paramMatching = async ()=>validateParamMatchingExport(route, filePath, 'unstable_generateParamMatching', await generate(), visibleParamNames);
         }
     }
 }
@@ -52,32 +105,53 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
  *
  * @param routeModule the app page route module
  * @returns the segments for the app page route module
- */ async function collectAppPageSegments(routeModule) {
+ */ async function collectAppPageSegments(routeModule, config) {
     // We keep track of unique segments, since with parallel routes, it's possible
     // to see the same segment multiple times.
     const segments = [];
+    const segmentTree = [];
+    const rootLoaderTree = routeModule.userland.loaderTree;
+    // `ensureStatic` needs to be validated against the tree structure,
+    // so we cannot compute it easily in `reduceAppConfig` after the tree
+    // is turned into an array of segments
+    const routeHasPartialPrefetching = ((config == null ? void 0 : config.partialPrefetching) ?? false) || await (0, _instantconfig.anySegmentHasPartialPrefetchingEnabled)(rootLoaderTree);
+    const prefetchConfig = routeHasPartialPrefetching ? 'partial' : 'auto';
+    const ensureStatic = await (0, _ensurestatic.resolveEnsureStaticConfig)(rootLoaderTree, routeHasPartialPrefetching);
     // Queue will store loader trees.
     const queue = [
-        routeModule.userland.loaderTree
+        {
+            loaderTree: rootLoaderTree,
+            visibleParamNames: [],
+            parentChildren: segmentTree
+        }
     ];
     while(queue.length > 0){
-        const loaderTree = queue.shift();
+        const { loaderTree, visibleParamNames, parentChildren } = queue.shift();
         const [name, parallelRoutes] = loaderTree;
         // Process current node
         const { mod: userland, filePath } = await (0, _appdirmodule.getLayoutOrPageModule)(loaderTree);
         const isClientComponent = userland && (0, _clientandserverreferences.isClientReference)(userland);
         const param = (0, _getsegmentparam.getSegmentParam)(name);
+        const currentVisibleParamNames = param ? [
+            ...visibleParamNames,
+            param.paramName
+        ] : visibleParamNames;
         const segment = {
             name,
             paramName: param == null ? void 0 : param.paramName,
             paramType: param == null ? void 0 : param.paramType,
             filePath,
             config: undefined,
+            paramMatching: undefined,
             generateStaticParams: undefined
         };
         // Only server components can have app segment configurations
         if (!isClientComponent) {
-            attach(segment, userland, routeModule.definition.pathname);
+            attach(segment, userland, routeModule.definition.pathname, currentVisibleParamNames);
+            if (segment.config) {
+                segment.config.prefetch = prefetchConfig;
+                segment.config.ensureStatic = ensureStatic;
+            }
         }
         // If this segment doesn't already exist, then add it to the segments array.
         // The list of segments is short so we just use a list traversal to check
@@ -85,12 +159,24 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
         if (segments.every((s)=>s.name !== segment.name || s.paramName !== segment.paramName || s.paramType !== segment.paramType || s.filePath !== segment.filePath)) {
             segments.push(segment);
         }
+        const children = [];
+        parentChildren.push([
+            segment,
+            children
+        ]);
         // Add all parallel routes to the queue
         for (const parallelRoute of Object.values(parallelRoutes)){
-            queue.push(parallelRoute);
+            queue.push({
+                loaderTree: parallelRoute,
+                visibleParamNames: currentVisibleParamNames,
+                parentChildren: children
+            });
         }
     }
-    return segments;
+    return {
+        segments,
+        segmentTree
+    };
 }
 /**
  * Collects the segments for a given app route module.
@@ -104,11 +190,7 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
     // Get the pathname parts, slice off the first element (which is empty).
     const parts = routeModule.definition.pathname.split('/').slice(1);
     if (parts.length === 0) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected at least one segment'), "__NEXT_ERROR_CODE", {
-            value: "E580",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Expected at least one segment');
     }
     // Generate all the segments.
     const segments = parts.map((name)=>{
@@ -119,6 +201,7 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
             paramType: param == null ? void 0 : param.paramType,
             filePath: undefined,
             config: undefined,
+            paramMatching: undefined,
             generateStaticParams: undefined
         };
     });
@@ -127,21 +210,29 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
     const segment = segments[segments.length - 1];
     segment.filePath = routeModule.definition.filename;
     // Extract the segment config from the userland module.
-    attach(segment, routeModule.userland, routeModule.definition.pathname);
-    return segments;
+    attach(segment, routeModule.userland, routeModule.definition.pathname, []);
+    let segmentTree = [];
+    for(let index = segments.length - 1; index >= 0; index--){
+        segmentTree = [
+            [
+                segments[index],
+                segmentTree
+            ]
+        ];
+    }
+    return {
+        segments,
+        segmentTree
+    };
 }
-function collectSegments(routeModule) {
+function collectSegments(routeModule, config) {
     if ((0, _checks.isAppRouteRouteModule)(routeModule)) {
         return collectAppRouteSegments(routeModule);
     }
     if ((0, _checks.isAppPageRouteModule)(routeModule)) {
-        return collectAppPageSegments(routeModule);
+        return collectAppPageSegments(routeModule, config);
     }
-    throw Object.defineProperty(new _invarianterror.InvariantError('Expected a route module to be one of app route or page'), "__NEXT_ERROR_CODE", {
-        value: "E568",
-        enumerable: false,
-        configurable: true
-    });
+    throw new _invarianterror.InvariantError('Expected a route module to be one of app route or page');
 }
 
 //# sourceMappingURL=app-segments.js.map

package/.next/standalone/node_modules/next/dist/build/segment-config/app/collect-root-param-keys.js

@@ -42,11 +42,7 @@ function collectRootParamKeys(routeModule) {
     if ((0, _checks.isAppPageRouteModule)(routeModule)) {
         return collectAppPageRootParamKeys(routeModule);
     }
-    throw Object.defineProperty(new _invarianterror.InvariantError('Expected a route module to be one of app route or page'), "__NEXT_ERROR_CODE", {
-        value: "E568",
-        enumerable: false,
-        configurable: true
-    });
+    throw new _invarianterror.InvariantError('Expected a route module to be one of app route or page');
 }
 
 //# sourceMappingURL=collect-root-param-keys.js.map

package/.next/standalone/node_modules/next/dist/build/static-paths/app/extract-pathname-route-param-segments-from-loader-tree.js

@@ -56,7 +56,7 @@ const _resolveparamvalue = require("../../../shared/lib/router/utils/resolve-par
     return true;
 }
 function extractPathnameRouteParamSegmentsFromLoaderTree(loaderTree, route) {
-    const pathnameRouteParamSegments = [];
+    const segmentsByDepth = new Map();
     const params = {};
     // BFS traversal with depth and path tracking
     const queue = [
@@ -103,7 +103,7 @@ function extractPathnameRouteParamSegmentsFromLoaderTree(loaderTree, route) {
                     // the target pathname. This prevents false matches like extracting
                     // [slug] from "/news/[slug]" when the tree has "/blog/[slug]"
                     if (validatePrefixMatch(currentPath, route)) {
-                        pathnameRouteParamSegments.push({
+                        segmentsByDepth.set(depth, {
                             name: segment,
                             paramName,
                             paramType
@@ -128,6 +128,12 @@ function extractPathnameRouteParamSegmentsFromLoaderTree(loaderTree, route) {
             });
         }
     }
+    // Parallel slots can repeat a parameter, and route groups can make loader
+    // tree traversal encounter deeper URL parameters before shallower ones.
+    // Consumers need each parameter once, in URL order, not tree traversal order.
+    const pathnameRouteParamSegments = [
+        ...segmentsByDepth
+    ].sort(([a], [b])=>a - b).map(([, segment])=>segment);
     return {
         pathnameRouteParamSegments,
         params