vike 0.4.142 → 0.4.143-commit-dc6fea0

package/dist/cjs/node/runtime/renderPage/loadPageFilesServerSide.js

@@ -9,7 +9,7 @@ const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
 const globalContext_js_1 = require("../globalContext.js");
-const loadPageCode_js_1 = require("../../../shared/page-configs/loadPageCode.js");
+const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
 async function loadPageFilesServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ config, configEntries, exports, exportsAll, pageExports, pageFilesLoaded, pageConfigLoaded }] = await Promise.all([
@@ -85,7 +85,7 @@ async function loadPageFilesServerSide(pageContext) {
 exports.loadPageFilesServerSide = loadPageFilesServerSide;
 async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await (0, loadPageCode_js_1.loadPageCode)(pageConfig, isDev);
+    const pageConfigLoaded = !pageConfig ? null : await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
     const { config, configEntries, exports, exportsAll, pageExports } = (0, getPageFiles_js_1.getExports)(pageFilesServerSide, pageConfigLoaded);
     return {

package/dist/cjs/node/runtime/renderPage/log404/index.js

@@ -72,8 +72,8 @@ function getPagesAndRoutesInfo(pageRoutes) {
         ...entries
     ];
     const terminalWidth = (0, utils_js_1.getTerminalWidth)() || 134;
-    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => routeTypeSrc.length));
-    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => routeDefinedBy.length));
+    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => (0, utils_js_1.stripAnsi)(routeTypeSrc).length));
+    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => (0, utils_js_1.stripAnsi)(routeDefinedBy).length));
     let width1 = terminalWidth - width3 - width2 - 10;
     linesContent.forEach((lineContent) => {
         let { routeStr } = lineContent;
@@ -88,9 +88,9 @@ function getPagesAndRoutesInfo(pageRoutes) {
     });
     width1 = Math.max(...linesContent.map(({ routeStr }) => (0, utils_js_1.stripAnsi)(routeStr).length));
     let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
-        let cell1 = routeStr.padEnd(width1 + (routeStr.length - (0, utils_js_1.stripAnsi)(routeStr).length), ' ');
-        let cell2 = routeTypeSrc.padEnd(width2, ' ');
-        let cell3 = routeDefinedBy.padEnd(width3, ' ');
+        let cell1 = padEnd(routeStr, width1 + ((0, utils_js_1.stripAnsi)(routeStr).length - (0, utils_js_1.stripAnsi)(routeStr).length));
+        let cell2 = padEnd(routeTypeSrc, width2);
+        let cell3 = padEnd(routeDefinedBy, width3);
         const isHeader = i === 0;
         if (isHeader) {
             cell1 = picocolors_1.default.dim(cell1);
@@ -125,6 +125,11 @@ function truncateRouteFunction(routeStr, lenMax) {
     routeStr = (0, utils_js_1.truncateString)(routeStr, lenMax, (s) => picocolors_1.default.dim(s));
     return routeStr;
 }
+/** Same as String.prototype.padEnd but with stripAnsi() */
+function padEnd(str, width) {
+    const padWidth = Math.max(0, width - (0, utils_js_1.stripAnsi)(str).length);
+    return str + ''.padEnd(padWidth, ' ');
+}
 function removeNonAscii(str) {
     // https://stackoverflow.com/questions/20856197/remove-non-ascii-character-in-string/20856346#20856346
     return str.replace(/[^\x00-\x7F]/g, '');

package/dist/cjs/node/shared/virtual-files/virtualFilePageConfigValuesAll.js

@@ -7,7 +7,7 @@ const idBase = 'virtual:vike:pageConfigValuesAll:';
 const idBaseClient = `${idBase}client:`;
 const idBaseServer = `${idBase}server:`;
 function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
-    const id = `${(isForClientSide ? idBaseClient : idBaseServer)}${pageId}`;
+    const id = `${isForClientSide ? idBaseClient : idBaseServer}${pageId}`;
     return id;
 }
 exports.getVirtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll;

package/dist/cjs/shared/error-page.js

@@ -32,7 +32,7 @@ function isErrorPage(pageId, pageConfigs) {
     if (pageConfigs.length > 0) {
         const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
         (0, utils_js_1.assert)(pageConfig);
-        return pageConfig.isErrorPage;
+        return !!pageConfig.isErrorPage;
     }
     else {
         return isErrorPageId(pageId, false);

package/dist/cjs/shared/getPageFiles/assertPageConfigs.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertPageConfigGlobal = exports.assertPageConfigs = void 0;
+exports.assertPageConfigGlobalSerialized = exports.assertPageConfigsSerialized = void 0;
 const utils_js_1 = require("../utils.js");
-function assertPageConfigs(pageConfigs) {
-    (0, utils_js_1.assert)(Array.isArray(pageConfigs));
-    pageConfigs.forEach((pageConfig) => {
-        (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageConfig));
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfig, 'pageId', 'string'));
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfig, 'routeFilesystem'));
+function assertPageConfigsSerialized(pageConfigsSerialized) {
+    (0, utils_js_1.assert)(Array.isArray(pageConfigsSerialized));
+    pageConfigsSerialized.forEach((pageConfigSerialized) => {
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageConfigSerialized));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'pageId', 'string'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'routeFilesystem'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesSerialized'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesImported'));
     });
 }
-exports.assertPageConfigs = assertPageConfigs;
-function assertPageConfigGlobal(pageConfigGlobal) {
-    (0, utils_js_1.assert)(pageConfigGlobal);
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobal, 'onBeforeRoute'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobal, 'onPrerenderStart'));
+exports.assertPageConfigsSerialized = assertPageConfigsSerialized;
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobalSerialized, 'configValuesImported'));
 }
-exports.assertPageConfigGlobal = assertPageConfigGlobal;
+exports.assertPageConfigGlobalSerialized = assertPageConfigGlobalSerialized;

package/dist/cjs/shared/getPageFiles/getExports.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExports = exports.getExportUnion = void 0;
 const isScriptFile_js_1 = require("../../utils/isScriptFile.js");
 const utils_js_1 = require("../utils.js");
-const assertExports_js_1 = require("./assertExports.js");
+const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
 const utils_js_2 = require("../page-configs/utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function getExports(pageFiles, pageConfig) {
@@ -102,7 +102,7 @@ function getExportValues(pageFile) {
             else {
                 (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportValue), `The ${picocolors_1.default.cyan('export default')} of ${filePath} should be an object.`);
                 Object.entries(exportValue).forEach(([defaultExportName, defaultExportValue]) => {
-                    (0, assertExports_js_1.assertDefaultExports)(defaultExportName, filePath);
+                    (0, assert_exports_old_design_js_1.assertDefaultExports)(defaultExportName, filePath);
                     exportValues.push({
                         exportName: defaultExportName,
                         exportValue: defaultExportValue,
@@ -119,7 +119,7 @@ function getExportValues(pageFile) {
         });
     });
     exportValues.forEach(({ exportName, isFromDefaultExport }) => {
-        (0, utils_js_1.assert)(!(isFromDefaultExport && assertExports_js_1.forbiddenDefaultExports.includes(exportName)));
+        (0, utils_js_1.assert)(!(isFromDefaultExport && assert_exports_old_design_js_1.forbiddenDefaultExports.includes(exportName)));
     });
     return exportValues;
 }

package/dist/cjs/shared/getPageFiles/parseGlobResults.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGlobResults = void 0;
 const utils_js_1 = require("../utils.js");
-const assertExports_js_1 = require("./assertExports.js");
+const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
 const getPageFileObject_js_1 = require("./getPageFileObject.js");
 const fileTypes_js_1 = require("./fileTypes.js");
 const assertPageConfigs_js_1 = require("./assertPageConfigs.js");
+const parsePageConfigsSerialized_js_1 = require("./parsePageConfigsSerialized.js");
 function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'isGeneratedFile'));
     (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -17,12 +18,12 @@ function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.client') || (0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.server'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesList', 'string[]'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigs'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobal'));
-    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
-    (0, assertPageConfigs_js_1.assertPageConfigs)(pageConfigs);
-    parsePageConfigs(pageConfigs);
-    (0, assertPageConfigs_js_1.assertPageConfigGlobal)(pageConfigGlobal);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigsSerialized'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+    (0, assertPageConfigs_js_1.assertPageConfigsSerialized)(pageConfigsSerialized);
+    (0, assertPageConfigs_js_1.assertPageConfigGlobalSerialized)(pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = (0, parsePageConfigsSerialized_js_1.parsePageConfigsSerialized)(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
@@ -31,7 +32,7 @@ function parseGlobResults(pageFilesExports) {
         pageFile.loadFile = async () => {
             if (!('fileExports' in pageFile)) {
                 pageFile.fileExports = await loadModule();
-                (0, assertExports_js_1.assertExportValues)(pageFile);
+                (0, assert_exports_old_design_js_1.assertExportValues)(pageFile);
             }
         };
     });
@@ -90,38 +91,3 @@ function parseGlobResult(globObject) {
 function assertLoadModule(globValue) {
     (0, utils_js_1.assert)((0, utils_js_1.isCallable)(globValue));
 }
-function parsePageConfigs(pageConfigs) {
-    // TODO: remove
-    /*
-    pageConfigs.forEach((pageConfig) => {
-      Object.entries(pageConfig.configElements).forEach(([configName, configElement]) => {
-        {
-          const { configValueSerialized } = configElement
-          if (configValueSerialized !== undefined) {
-            configElement.configValue = parse(configValueSerialized)
-          }
-        }
-        if (configName === 'route') {
-          assertRouteConfigValue(configElement)
-        }
-      })
-    })
-    */
-}
-// TODO: use again
-// function assertRouteConfigValue(configElement: ConfigElement) {
-//   assert(hasProp(configElement, 'configValue')) // route files are eagerly loaded
-//   const { configValue } = configElement
-//   const configValueType = typeof configValue
-//   assertUsage(
-//     configValueType === 'string' || isCallable(configValue),
-//     `${configElement.configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`
-//   )
-//   /* We don't do that to avoid unnecessarily bloating the client-side bundle when using Server Routing
-//    *  - When using Server Routing, this file is loaded as well
-//    *  - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
-//   if (typeof configValue === 'string') {
-//     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
-//   }
-//   */
-// }

package/dist/cjs/shared/getPageFiles/parsePageConfigsSerialized.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePageConfigsSerialized = void 0;
+const parse_1 = require("@brillout/json-serializer/parse");
+const parseConfigValuesImported_js_1 = require("../page-configs/parseConfigValuesImported.js");
+const utils_js_1 = require("../utils.js");
+function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
+        const configValues = {};
+        {
+            const { configValuesSerialized } = pageConfigSerialized;
+            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+                {
+                    const { valueSerialized, definedAtInfo } = configValueSeriliazed;
+                    (0, utils_js_1.assert)(valueSerialized);
+                    (0, utils_js_1.assert)(!configValues[configName]);
+                    configValues[configName] = {
+                        value: (0, parse_1.parse)(valueSerialized),
+                        definedAtInfo
+                    };
+                }
+            });
+        }
+        {
+            const { configValuesImported } = pageConfigSerialized;
+            const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
+            Object.assign(configValues, configValuesAddendum);
+        }
+        const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
+        assertRouteConfigValue(configValues);
+        return {
+            pageId,
+            isErrorPage,
+            routeFilesystem,
+            configValues,
+            loadConfigValuesAll
+        };
+    });
+    const pageConfigGlobal = { configValues: {} };
+    {
+        const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(pageConfigGlobalSerialized.configValuesImported);
+        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+    }
+    return { pageConfigs, pageConfigGlobal };
+}
+exports.parsePageConfigsSerialized = parsePageConfigsSerialized;
+function assertRouteConfigValue(configValues) {
+    if (!configValues.route)
+        return;
+    const { value, definedAtInfo } = configValues.route;
+    const configValueType = typeof value;
+    (0, utils_js_1.assert)(definedAtInfo);
+    (0, utils_js_1.assertUsage)(configValueType === 'string' || (0, utils_js_1.isCallable)(value), `${definedAtInfo.filePath} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
+    /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
+    * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.
+    * - assertRouteString() is already called on the server-side
+    * - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
+   if (typeof configValue === 'string') {
+     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
+   }
+   */
+}

package/dist/cjs/shared/page-configs/assertExports.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExportsOfConfigFile = exports.assertExportsOfValueFile = void 0;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
+    assertExports(fileExports, filePathToShowToUser, configName);
+}
+exports.assertExportsOfValueFile = assertExportsOfValueFile;
+function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
+    assertExports(fileExports, filePathToShowToUser);
+    const exportDefault = fileExports.default;
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportDefault), `The ${picocolors_1.default.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
+}
+exports.assertExportsOfConfigFile = assertExportsOfConfigFile;
+function assertExports(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
+        // !!configName => isValueFile
+        e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsRelevant.length === 1) {
+            return;
+        }
+        else {
+            (0, utils_js_1.assert)(exportsRelevant.length === 0);
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${picocolors_1.default.cyan('export default')}`;
+            if (configName)
+                errMsg += ` or ${picocolors_1.default.cyan(`export { ${configName} }`)}`;
+            (0, utils_js_1.assertUsage)(false, errMsg);
+        }
+    }
+    else {
+        // !configName => isConfigFile
+        if (!configName) {
+            const exportsInvalidStr = exportsInvalid.join(', ');
+            (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} replace ${picocolors_1.default.cyan(`export { ${exportsInvalidStr} }`)} with ${picocolors_1.default.cyan(`export default { ${exportsInvalidStr} }`)}`);
+        }
+        // !!configName => isValueFile
+        else {
+            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+                return;
+            exportsInvalid.forEach((exportInvalid) => {
+                (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} should have only a single export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
+            });
+        }
+    }
+}

package/dist/cjs/shared/page-configs/loadConfigValues.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigValues = void 0;
+const utils_js_1 = require("../utils.js");
+const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
+async function loadConfigValues(pageConfig, isDev) {
+    if ('isLoaded' in pageConfig &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const configValuesImported = await pageConfig.loadConfigValuesAll();
+    const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
+    Object.assign(pageConfig.configValues, configValuesAddendum);
+    (0, utils_js_1.objectAssign)(pageConfig, { isLoaded: true });
+    return pageConfig;
+}
+exports.loadConfigValues = loadConfigValues;

package/dist/cjs/shared/page-configs/parseConfigValuesImported.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfigValuesImported = void 0;
+const utils_js_1 = require("../utils.js");
+const assertExports_js_1 = require("./assertExports.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function parseConfigValuesImported(configValuesImported) {
+    const configValues = {};
+    const addConfigValue = (configName, value, filePath, exportName) => {
+        configValues[configName] = {
+            value,
+            definedAtInfo: {
+                filePath,
+                fileExportPath: [exportName]
+            }
+        };
+        assertIsNotNull(value, configName, filePath);
+    };
+    configValuesImported.forEach((configValueLoaded) => {
+        if (configValueLoaded.isValueFile) {
+            const { importFileExports, importPath, configName } = configValueLoaded;
+            if (configName !== 'client') {
+                (0, assertExports_js_1.assertExportsOfValueFile)(importFileExports, importPath, configName);
+            }
+            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
+                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
+                const configName = isSideExport ? exportName : configValueLoaded.configName;
+                if (isSideExport && configName in configValues) {
+                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
+                    // Side-exports have the lowest priority.
+                    return;
+                }
+                addConfigValue(configName, exportValue, importPath, exportName);
+            });
+        }
+        else {
+            const { configName, importPath, importFileExportValue, exportName } = configValueLoaded;
+            addConfigValue(configName, importFileExportValue, importPath, exportName);
+        }
+    });
+    return configValues;
+}
+exports.parseConfigValuesImported = parseConfigValuesImported;
+function assertIsNotNull(configValue, configName, importPath) {
+    (0, utils_js_1.assert)(!importPath.includes('+config.'));
+    (0, utils_js_1.assertUsage)(configValue !== null, `Set ${picocolors_1.default.cyan(configName)} to ${picocolors_1.default.cyan('null')} in a +config.h.js file instead of ${importPath}`);
+}

package/dist/cjs/shared/page-configs/utils.js

@@ -55,7 +55,7 @@ function assertConfigValueType(value, type, configName, definedAtInfo) {
     const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
     const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
     const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
-    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: is should be a ${picocolors_1.default.cyan(type)} instead`);
+    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
 }
 function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
     let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)}`;

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -140,19 +140,17 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        if (pageConfigGlobal.onBeforeRoute) {
-            const hookFn = pageConfigGlobal.onBeforeRoute.value;
-            if (hookFn) {
-                (0, utils_js_1.assert)(!pageConfigGlobal.onBeforeRoute.isComputed);
-                const hookFilePath = pageConfigGlobal.onBeforeRoute.definedAtInfo.filePath;
-                (0, utils_js_1.assert)(hookFilePath);
-                (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
-                const onBeforeRouteHook = {
-                    hookFilePath: hookFilePath,
-                    onBeforeRoute: hookFn
-                };
-                return { onBeforeRouteHook, filesystemRoots: null };
-            }
+        if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
+            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onBeforeRoute;
+            // config.onBeforeRoute isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            (0, utils_js_1.assert)(definedAtInfo);
+            const hookFilePath = definedAtInfo.filePath;
+            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+            const onBeforeRouteHook = {
+                hookFilePath: hookFilePath,
+                onBeforeRoute: hookFn
+            };
+            return { onBeforeRouteHook, filesystemRoots: null };
         }
         return { onBeforeRouteHook: null, filesystemRoots: null };
     }

package/dist/cjs/shared/route/resolvePrecedence.js

@@ -35,37 +35,58 @@ function sortMatches(routeMatch1, routeMatch2) {
     if (!routeMatch1.routeString) {
         return 0;
     }
+    /* DEBUG
+    console.log('routeMatch1.routeString', routeMatch1.routeString)
+    console.log('routeMatch2.routeString', routeMatch2.routeString)
+    console.log('parseRouteString(routeMatch1.routeString)', parseRouteString(routeMatch1.routeString))
+    console.log('parseRouteString(routeMatch2.routeString)', parseRouteString(routeMatch2.routeString))
+    //*/
     // Return route with highest number of static path segments at beginning first
     {
-        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticSegmentsBeginning;
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticPartsBeginning;
         const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticPartsBeginning', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticPartsBeginning', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
     // Return route with highest number of static path segments in total first
     {
-        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticSegements;
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticParts;
         const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticParts', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticParts', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return route with most parameter segements first
+    // Return route with least amount of globs first
     {
-        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfParameterSegments;
-        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfGlobs;
+        const result = (0, utils_js_1.lowerFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfGlobs', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfGlobs', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return catch-all routes last
+    // Return route with highest number of parameters first
     {
-        if ((0, resolveRouteString_js_1.analyzeRouteString)(routeMatch2.routeString).isCatchAll) {
-            return -1;
-        }
-        if ((0, resolveRouteString_js_1.analyzeRouteString)(routeMatch1.routeString).isCatchAll) {
-            return 1;
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfParams;
+        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfParams', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfParams', getValue(routeMatch2.routeString))
+            //*/
+            return result;
         }
     }
     return 0;

package/dist/cjs/shared/route/resolveRedirects.js

@@ -10,7 +10,7 @@ const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
 // TODO/v1-release: update
-const configSrc = '[vite.config.js > ssr({ redirects })]';
+const configSrc = '[vite.config.js > vike({ redirects })]';
 function resolveRedirects(redirects, urlPathname) {
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
         const urlResolved = resolveRouteStringRedirect(urlSource, urlTarget, urlPathname);

package/dist/cjs/shared/route/resolveRouteFunction.js

@@ -22,6 +22,7 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
         result = {};
     }
     (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${picocolors_1.default.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    // AFAICT this return interface is superfluous. Should we soft-deprecate it and remove it?
     if ('match' in result) {
         const { match } = result;
         (0, utils_js_1.assertUsage)(typeof match === 'boolean', `The ${picocolors_1.default.cyan('match')} value returned by the Route Function ${routeDefinedAt} should be a boolean.`);