vike 0.4.143 → 0.4.144-commit-e40e9b1

package/dist/cjs/shared/page-configs/serialize/parsePageConfigs.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePageConfigs = void 0;
+const parse_1 = require("@brillout/json-serializer/parse");
+const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
+const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../utils.js");
+function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
+        const configValues = {};
+        {
+            const { configValuesSerialized } = pageConfigSerialized;
+            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+                {
+                    const { valueSerialized, definedAt } = configValueSeriliazed;
+                    (0, utils_js_1.assert)(valueSerialized);
+                    (0, utils_js_1.assert)(!configValues[configName]);
+                    configValues[configName] = {
+                        value: (0, parse_1.parse)(valueSerialized),
+                        definedAt
+                    };
+                }
+            });
+        }
+        {
+            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.parsePageConfigs = parsePageConfigs;
+function assertRouteConfigValue(configValues) {
+    const configName = 'route';
+    const configValue = configValues[configName];
+    if (!configValue)
+        return;
+    const { value } = configValue;
+    const configValueType = typeof value;
+    const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
+    (0, utils_js_1.assertUsage)(configValueType === 'string' || (0, utils_js_1.isCallable)(value), `${configDefinedAt} 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/serialize/serializeConfigValue.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeConfigValueImported = exports.serializeConfigValue = void 0;
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with:
+//   - vike/shared/page-configs/serialize/parsePageConfigs.ts
+//   - vike/shared/page-configs/serialize/parseConfigValuesImported.ts
+// Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
+const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+const path_1 = __importDefault(require("path"));
+const utils_js_1 = require("../../utils.js");
+const generateEagerImport_js_1 = require("../../../node/plugin/plugins/importUserCode/generateEagerImport.js");
+function serializeConfigValue(lines, configName, configValueSerialized) {
+    let whitespace = '      ';
+    lines.push(`${whitespace}['${configName}']: {`);
+    whitespace += '  ';
+    Object.entries(configValueSerialized).forEach(([key, val]) => {
+        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
+        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
+    });
+    whitespace = whitespace.slice(2);
+    lines.push(`${whitespace}},`);
+}
+exports.serializeConfigValue = serializeConfigValue;
+function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
+    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
+    (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
+    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    (0, utils_js_1.assert)(valueIsImportedAtRuntime);
+    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
+    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
+    (0, utils_js_1.assertPosixPath)(importPath);
+    const fileName = path_1.default.posix.basename(importPath);
+    const isValueFile = fileName.startsWith('+');
+    if (isValueFile)
+        (0, utils_js_1.assert)(exportName === undefined);
+    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importPath, varCounterContainer.varCounter++, exportName);
+    importStatements.push(importStatement);
+    const lines = [];
+    lines.push(`  {`);
+    lines.push(`    configName: '${configName}',`);
+    lines.push(`    importPath: '${importPath}',`);
+    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
+    if (isValueFile) {
+        lines.push(`    exportValues: ${importName},`);
+    }
+    else {
+        lines.push(`    exportValue: ${importName},`);
+        (0, utils_js_1.assert)(exportName);
+        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
+    }
+    lines.push(`  },`);
+    return lines;
+}
+exports.serializeConfigValueImported = serializeConfigValueImported;

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefinedAtString = exports.getConfigDefinedAtInfo = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
+exports.getHookFilePathToShowToUser = exports.getConfigValueFilePathToShowToUser = exports.getDefinedAtString = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getExportPath_js_1 = require("./getExportPath.js");
@@ -12,33 +12,30 @@ function getConfigValue(pageConfig, configName, type) {
     const configValue = getConfigValueEntry(pageConfig, configName);
     if (configValue === null)
         return null;
-    const { value, definedAtInfo } = configValue;
+    const { value, definedAt } = configValue;
     if (type)
-        assertConfigValueType(value, type, configName, definedAtInfo);
-    return { value };
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
 }
 exports.getConfigValue = getConfigValue;
-function getConfigDefinedAtInfo(pageConfig, configName) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    // We assume the caller to have ensured that the config value exists prior to calling getConfigDefinedAtInfo()
-    (0, utils_js_1.assert)(configValue);
-    const { definedAtInfo } = configValue;
-    // definedAtInfo is available only for config values that aren't:
-    //  - computed, nor
-    //  - cumulative
-    (0, utils_js_1.assert)(definedAtInfo);
-    return definedAtInfo;
+function assertConfigValueType(value, type, configName, definedAt) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    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, { definedAt }, true);
+    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
 }
-exports.getConfigDefinedAtInfo = getConfigDefinedAtInfo;
 function getConfigValueEntry(pageConfig, configName) {
     const configValue = pageConfig.configValues[configName];
     if (!configValue)
         return null;
-    const { value, definedAtInfo } = configValue;
     // Enable users to suppress global config values by setting the local config value to null
-    if (value === null)
+    if (configValue.value === null)
         return null;
-    return { value, definedAtInfo };
+    return configValue;
 }
 function getPageConfig(pageId, pageConfigs) {
     const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
@@ -47,34 +44,60 @@ function getPageConfig(pageId, pageConfigs) {
     return pageConfig;
 }
 exports.getPageConfig = getPageConfig;
-function assertConfigValueType(value, type, configName, definedAtInfo) {
-    (0, utils_js_1.assert)(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    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}: 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)}`;
-    if (definedAtInfo !== null) {
-        configDefinedAt = `${configDefinedAt} defined at ${getDefinedAtString(definedAtInfo, append)}`;
-    }
+function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
+    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)} defined ${getSourceString(definedAt, configName)}`;
     return configDefinedAt;
 }
 exports.getConfigDefinedAtString = getConfigDefinedAtString;
-function getDefinedAtString(definedAtInfo, append) {
-    const { filePath, fileExportPath } = definedAtInfo;
-    let definedAt = filePath;
-    const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
-    if (exportPath) {
-        definedAt = `${definedAt} > ${picocolors_1.default.cyan(exportPath)}`;
+function getSourceString(definedAt, configName) {
+    if (definedAt.isComputed) {
+        return 'internally';
     }
-    if (append) {
-        definedAt = `${definedAt} > (${picocolors_1.default.blue(append)})`;
+    let files;
+    if (definedAt.isCumulative) {
+        files = definedAt.files;
     }
-    return definedAt;
+    else {
+        files = [definedAt.file];
+    }
+    (0, utils_js_1.assert)(files.length >= 1);
+    const sourceString = files
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPath } = source;
+        let s = filePathToShowToUser;
+        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath, configName);
+        if (exportPath) {
+            s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
+        }
+        if (definedAt.isEffect) {
+            s = `${s} > (${picocolors_1.default.blue('effect')})`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return `at ${sourceString}`;
+}
+function getDefinedAtString(configValue, configName) {
+    let sourceString = getSourceString(configValue.definedAt, configName);
+    if (sourceString.startsWith('at '))
+        sourceString = sourceString.slice('at '.length);
+    return sourceString;
 }
 exports.getDefinedAtString = getDefinedAtString;
+function getConfigValueFilePathToShowToUser({ definedAt }) {
+    // A unique file path only exists if the config value isn't cumulative nor computed:
+    //  - cumulative config values have multiple file paths
+    //  - computed values don't have any file path
+    if (definedAt.isComputed || definedAt.isCumulative)
+        return null;
+    const { filePathToShowToUser } = definedAt.file;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getConfigValueFilePathToShowToUser = getConfigValueFilePathToShowToUser;
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getHookFilePathToShowToUser = getHookFilePathToShowToUser;

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

@@ -33,9 +33,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configName = 'route';
                 const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
                 if (configValue) {
-                    const definedAtInfo = (0, utils_js_3.getConfigDefinedAtInfo)(pageConfig, configName);
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(definedAtInfo);
+                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -140,19 +139,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 configValue = pageConfigGlobal.configValues.onBeforeRoute;
+            const { value: hookFn } = configValue;
+            const hookFilePath = (0, utils_js_3.getHookFilePathToShowToUser)(configValue);
+            // TODO: use getConfigDefinedAtString()
+            (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/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.`);

package/dist/cjs/shared/utils.js

@@ -38,7 +38,6 @@ __exportStar(require("../utils/projectInfo.js"), exports);
 __exportStar(require("../utils/hasPropertyGetter.js"), exports);
 __exportStar(require("../utils/isPromise.js"), exports);
 __exportStar(require("../utils/checkType.js"), exports);
-__exportStar(require("../utils/assertDefaultExport.js"), exports);
 __exportStar(require("../utils/objectEntries.js"), exports);
 __exportStar(require("../utils/getValuePrintable.js"), exports);
 __exportStar(require("../utils/escapeRegex.js"), exports);

package/dist/cjs/utils/getOutDirs.js

@@ -3,30 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveOutDir = exports.getOutDirs_prerender = exports.getOutDirs = void 0;
+exports.resolveOutDir = exports.getOutDirs = void 0;
 const viteIsSSR_js_1 = require("./viteIsSSR.js");
 const assert_js_1 = require("./assert.js");
 const path_shim_js_1 = require("./path-shim.js");
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function getOutDirs(config) {
-    const outDir = getOutDirFromResolvedConfig(config);
-    assertOutDirResolved(outDir, config);
-    (0, assert_js_1.assert)(outDir.endsWith('/server') || outDir.endsWith('/client'));
-    (0, assert_js_1.assert)('/client'.length === '/server'.length);
-    const outDirRoot = outDir.slice(0, -1 * '/client'.length);
+    let outDirRoot;
+    {
+        const outDir = getOutDirFromViteResolvedConfig(config);
+        if (isOutDirRoot(outDir)) {
+            outDirRoot = outDir;
+        }
+        else {
+            assertOutDirResolved(outDir, config);
+            (0, assert_js_1.assert)(outDir.endsWith('/server') || outDir.endsWith('/client'));
+            (0, assert_js_1.assert)('/client'.length === '/server'.length);
+            outDirRoot = outDir.slice(0, -1 * '/client'.length);
+        }
+    }
     return getOutDirsAll(outDirRoot, config.root);
 }
 exports.getOutDirs = getOutDirs;
-function getOutDirs_prerender(config) {
-    const outDirRoot = getOutDirFromResolvedConfig(config);
-    (0, assert_js_1.assert)(isOutDirRoot(outDirRoot));
-    return getOutDirsAll(outDirRoot, config.root);
-}
-exports.getOutDirs_prerender = getOutDirs_prerender;
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config) {
-    const outDir = getOutDirFromUserConfig(config) || 'dist';
+    const outDir = getOutDirFromViteUserConfig(config) || 'dist';
     // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
     if (!isOutDirRoot(outDir)) {
         assertOutDirResolved(outDir, config);
@@ -45,6 +47,7 @@ function resolveOutDir(config) {
 exports.resolveOutDir = resolveOutDir;
 function determineOutDirs(outDirRoot) {
     (0, filesystemPathHandling_js_1.assertPosixPath)(outDirRoot);
+    (0, assert_js_1.assert)(!outDirRoot.endsWith('/'));
     (0, assert_js_1.assert)(isOutDirRoot(outDirRoot));
     const outDirClient = (0, path_shim_js_1.pathJoin)(outDirRoot, 'client');
     const outDirServer = (0, path_shim_js_1.pathJoin)(outDirRoot, 'server');
@@ -95,18 +98,22 @@ function assertOutDirResolved(outDir, config) {
         (0, assert_js_1.assertUsage)(outDir.endsWith('/client'), wrongUsage);
     }
 }
-function getOutDirFromUserConfig(config) {
+function getOutDirFromViteUserConfig(config) {
     let outDir = config.build?.outDir;
     if (outDir === undefined)
         return undefined;
-    // I believe Vite normalizes config.build.outDir only if config is ResolvedConfig
-    outDir = (0, filesystemPathHandling_js_1.toPosixPath)(outDir);
+    outDir = normalize(outDir);
     return outDir;
 }
-function getOutDirFromResolvedConfig(config) {
+function getOutDirFromViteResolvedConfig(config) {
     let outDir = config.build.outDir;
-    // Vite seems to be buggy and doesn't always normalize config.build.outDir
+    (0, assert_js_1.assert)(outDir);
+    outDir = normalize(outDir);
+    return outDir;
+}
+function normalize(outDir) {
     outDir = (0, filesystemPathHandling_js_1.toPosixPath)(outDir);
+    outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
     return outDir;
 }
 function outDirIsAbsolutePath(outDir) {

package/dist/cjs/utils/getValuePrintable.js

@@ -4,7 +4,7 @@ exports.getValuePrintable = void 0;
 function getValuePrintable(value) {
     if ([null, undefined].includes(value))
         return String(value);
-    if (['undefined', 'boolean', 'number', 'string'].includes(typeof value))
+    if (['boolean', 'number', 'string'].includes(typeof value))
         return JSON.stringify(value);
     return null;
 }

package/dist/cjs/utils/objectAssign.js

@@ -5,6 +5,8 @@ exports.objectAssign = void 0;
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
 function objectAssign(obj, objAddendum) {
-    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+    if (objAddendum) {
+        Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+    }
 }
 exports.objectAssign = objectAssign;

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.143';
+const PROJECT_VERSION = '0.4.144-commit-e40e9b1';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/cjs/utils/{resolve.js → requireResolve.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolve = void 0;
+exports.requireResolve = void 0;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
@@ -12,7 +12,7 @@ const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 (0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
-function resolve(importPath, cwd) {
+function requireResolve(importPath, cwd) {
     (0, filesystemPathHandling_js_1.assertPosixPath)(cwd);
     const clean = addFileExtensionsToRequireResolve();
     importPath = removeFileExtention(importPath);
@@ -31,7 +31,7 @@ function resolve(importPath, cwd) {
     }
     return importedFile;
 }
-exports.resolve = resolve;
+exports.requireResolve = requireResolve;
 function removeFileExtention(importPath) {
     for (const ext of isScriptFile_js_1.scriptFileExtensionList) {
         const suffix = `.${ext}`;

package/dist/cjs/utils/warnIfErrorIsNotObject.js

@@ -12,7 +12,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 // It would be cleaner to:
 //  - Call assertUsageErrorIsObject() right after calling the user's hook
 //    - Attach the original error: assertUsageError.originalErrorValue = err
-//      - Show the original error in vike's error handling
+//      - Show the original error in Vike's error handling
 //  - Use assertErrorIsObject() throughout Vike's source code
 function warnIfErrorIsNotObject(err) {
     if (!(0, isObject_js_1.isObject)(err)) {

package/dist/esm/__internal/index.d.ts

@@ -1,8 +1,8 @@
 import { route, type PageRoutes } from '../shared/route/index.js';
 import { type PageFile } from '../shared/getPageFiles.js';
-import { PageConfig } from '../shared/page-configs/PageConfig.js';
+import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
 export { route, getPagesAndRoutes };
-export type { PageRoutes, PageFile, PageConfig };
+export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
  * to compute some rewrite rules and extract { isr } configs.
@@ -12,6 +12,6 @@ export type { PageRoutes, PageFile, PageConfig };
 declare function getPagesAndRoutes(): Promise<{
     pageRoutes: PageRoutes;
     pageFilesAll: PageFile[];
-    pageConfigs: PageConfig[];
+    pageConfigs: PageConfigRuntime[];
     allPageIds: string[];
 }>;

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -8,8 +8,8 @@ declare function createPageContext<T extends {
     _baseServer: string;
     _isProduction: boolean;
     _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
-    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobal;
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/route/executeOnBeforeRouteHook.js").OnBeforeRouteHook | null;

package/dist/esm/client/client-routing-runtime/getPageContext.d.ts

@@ -5,7 +5,7 @@ export { isAlreadyServerSideRouted };
 import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
 import type { PageContextUrlComputedPropsInternal } from '../../shared/addUrlComputedProps.js';
 import { PageContextForRoute } from '../../shared/route/index.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import type { PageContextForPassToClientWarning } from '../shared/getPageContextProxyForUser.js';
 type PageContextAddendum = {
     _pageId: string;
@@ -23,7 +23,7 @@ declare function getPageContextErrorPage(pageContext: {
     _allPageIds: string[];
     _isFirstRenderAttempt: boolean;
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 } & PageContextPassThrough): Promise<PageContextAddendum>;
 declare function checkIf404(err: unknown): boolean;
 declare function isAlreadyServerSideRouted(err: unknown): boolean;

package/dist/esm/client/client-routing-runtime/getPageId.d.ts

@@ -2,9 +2,9 @@ export { getPageId };
 declare function getPageId(url: string): Promise<{
     pageId: null;
     pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
 } | {
     pageId: string;
     pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
 }>;

package/dist/esm/client/client-routing-runtime/useClientRouter.js

@@ -103,7 +103,7 @@ function useClientRouter() {
         // Start transition before any await's
         if (renderingNumber > 1) {
             if (isTransitioning === false) {
-                globalObject.onPageTransitionStart?.(pageContextBase);
+                await globalObject.onPageTransitionStart?.(pageContextBase);
                 isTransitioning = true;
             }
         }
@@ -265,7 +265,7 @@ function useClientRouter() {
         else if (renderingNumber === renderingCounter) {
             if (pageContext.exports.onPageTransitionEnd) {
                 assertHook(pageContext, 'onPageTransitionEnd');
-                pageContext.exports.onPageTransitionEnd(pageContext);
+                await pageContext.exports.onPageTransitionEnd(pageContext);
             }
             isTransitioning = false;
         }
@@ -320,7 +320,7 @@ function onBrowserHistoryNavigation(callback) {
         if (isHashNavigation) {
             // - `history.state` is uninitialized (`null`) when:
             //   - The vike app runs `window.location.hash = '#section'`.
-            //   - The user clicks on an anchor link `<a href="#section">Section</a>`. (Because vike's `onLinkClick()` handler skips hash links.)
+            //   - The user clicks on an anchor link `<a href="#section">Section</a>`. (Because Vike's `onLinkClick()` handler skips hash links.)
             // - `history.state` is `null` when uninitialized: https://developer.mozilla.org/en-US/docs/Web/API/History/state
             // - Alternatively, we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
             //   - Problem: we cannot intercept `window.location.hash = '#section'`. (Or maybe we can with the `hashchange` event?)

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -8,7 +8,7 @@ declare function getPageContext(): Promise<{
     _hasPageContextFromClient: boolean;
 } & {
     _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
 } & import("../../shared/getPageFiles/getExports.js").PageContextExports & {
     _pageFilesLoaded: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
 }>;

package/dist/esm/client/shared/executeOnRenderClientHook.d.ts

@@ -1,11 +1,11 @@
 export { executeOnRenderClientHook };
 import type { PageFile, PageContextExports } from '../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 declare function executeOnRenderClientHook<PC extends {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 } & PageContextExports & PageContextForUserConsumptionClientSide>(pageContext: PC, isClientRouting: boolean): Promise<void>;

package/dist/esm/client/shared/loadPageFilesClientSide.d.ts

@@ -1,8 +1,8 @@
 import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 export { loadPageFilesClientSide };
 export { isErrorFetchingStaticAssets };
-declare function loadPageFilesClientSide(pageFilesAll: PageFile[], pageConfigs: PageConfig[], pageId: string): Promise<PageContextExports & {
+declare function loadPageFilesClientSide(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageId: string): Promise<PageContextExports & {
     _pageFilesLoaded: PageFile[];
 }>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/loadPageFilesClientSide.js

@@ -1,6 +1,6 @@
 import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
-import { loadPageCode } from '../../shared/page-configs/loadPageCode.js';
+import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 export { loadPageFilesClientSide };
 export { isErrorFetchingStaticAssets };
 const stamp = '__whileFetchingAssets';
@@ -13,7 +13,7 @@ async function loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId) {
     try {
         // prettier-ignore
         const result = await Promise.all([
-            pageConfig && loadPageCode(pageConfig, isDev),
+            pageConfig && loadConfigValues(pageConfig, isDev),
             ...pageFilesClientSide.map((p) => p.loadFile?.()),
         ]);
         pageConfigLoaded = result[0];