vike 0.4.144 → 0.4.145-commit-2520555

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -6,11 +6,12 @@ const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
-const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
+const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
 const getConfigValueSourcesRelevant_js_1 = require("../../../shared/getConfigValueSourcesRelevant.js");
-const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
+const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
-async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, isDev, configVike) {
+const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
+async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
     (0, utils_js_1.assert)(result);
     /* This assertion fails when using includeAssetsImportedByServer
@@ -20,16 +21,17 @@ async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, is
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, outDirRoot, isDev, configVike.extensions, true);
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config, isDev, true);
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     (0, utils_js_1.assert)(pageConfig);
+    const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
     (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
 exports.getVirtualFilePageConfigValuesAll = getVirtualFilePageConfigValuesAll;
 function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
-    const configValue = (0, utils_js_2.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
+    const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
     const isClientRouting = configValue?.value ?? false;
     const lines = [];
     const importStatements = [];
@@ -41,7 +43,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
             return;
         if (configValueSource.valueIsFilePath)
             return;
-        if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+        if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false }))
             return;
         const whitespace = '  ';
         lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -11,18 +11,26 @@ const stringify_1 = require("@brillout/json-serializer/stringify");
 const helpers_js_1 = require("./helpers.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
-const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
-const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
+const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
+const helpers_js_2 = require("../../../../../shared/page-configs/helpers.js");
 const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
-async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
-    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, outDirRoot, isDev, configVike.extensions, true);
-    return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
+    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(config, isDev, true);
+    return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 exports.getVirtualFilePageConfigs = getVirtualFilePageConfigs;
-function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
     const lines = [];
     const importStatements = [];
     const varCounterContainer = { varCounter: 0 };
+    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer));
+    const code = [...importStatements, ...lines].join('\n');
+    (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer) {
+    const lines = [];
     lines.push('export const pageConfigsSerialized = [');
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
@@ -35,7 +43,7 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         lines.push(`    configValuesSerialized: {`);
         Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
             const { value, configEnv } = configValuesComputed;
-            if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+            if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true }))
                 return;
             if (pageConfig.configValueSources[configName])
                 return;
@@ -50,7 +58,8 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
             if (configValue) {
                 const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig.configValueSources, configName);
                 (0, utils_js_1.assert)(configEnv, configName);
-                if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+                const isEnvMatch = (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true });
+                if (!isEnvMatch)
                     return;
                 const { value, definedAt } = configValue;
                 const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
@@ -75,6 +84,11 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         lines.push(`  },`);
     });
     lines.push('];');
+    const code = lines.join('\n');
+    return code;
+}
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer) {
+    const lines = [];
     lines.push('export const pageConfigGlobalSerialized = {');
     /* Nothing (yet)
     lines.push(`  configValuesSerialized: {`)
@@ -101,23 +115,31 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
     });
     lines.push(`  ],`);
     lines.push('};');
-    const code = [...importStatements, ...lines].join('\n');
-    (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    const code = lines.join('\n');
     return code;
 }
 function getConfigValueSerialized(value, configName, definedAt) {
     const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
     let configValueSerialized;
     try {
-        configValueSerialized = (0, stringify_1.stringify)(value, { valueName });
+        configValueSerialized = (0, stringify_1.stringify)(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
-        const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)({ definedAt });
+        let serializationErrMsg = '';
+        if ((0, stringify_1.isJsonSerializerError)(err)) {
+            serializationErrMsg = err.messageCore;
+        }
+        else {
+            // When a property getter throws an error
+            console.error('Serialization error:');
+            console.error(err);
+            serializationErrMsg = 'see serialization error printed above';
+        }
+        const configValueFilePathToShowToUser = (0, helpers_js_2.getConfigValueFilePathToShowToUser)({ definedAt });
         (0, utils_js_1.assert)(configValueFilePathToShowToUser);
         (0, utils_js_1.assertUsage)(false, [
             `The value of the config ${picocolors_1.default.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because the value isn't serializable: ${err.messageCore}.)`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/helpers.js

@@ -7,20 +7,7 @@ function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
-    if (configValueSource) {
-        return configValueSource.configEnv;
-    }
-    else {
-        // In case of effect/computed config values, there isn't any configValueSource
-        // TODO: make it work for custom config definitions
-        //  - Ideally set configValueSource also for effect/computed config values?
-        (0, utils_js_1.assert)(false, 'TODO');
-        /*
-        const configDef = configDefinitionsBuiltIn[configName as keyof typeof configDefinitionsBuiltIn]
-        if (!configDef) return null
-        return configDef.env
-        */
-    }
+    return configValueSource.configEnv;
 }
 exports.getConfigEnv = getConfigEnv;
 function isConfigSet(configValueSources, configName) {

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/isRuntimeEnvMatch.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeEnvMatch = void 0;
+function isRuntimeEnvMatch(configEnv, runtime) {
+    const { isForClientSide, isClientRouting, isEager } = runtime;
+    if (configEnv === 'config-only')
+        return false;
+    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
+        return false;
+    if (configEnv === '_routing-eager' || configEnv === '_routing-lazy') {
+        if (isForClientSide && !isClientRouting)
+            return false;
+        if (isEager !== (configEnv === '_routing-eager'))
+            return false;
+    }
+    return true;
+}
+exports.isRuntimeEnvMatch = isRuntimeEnvMatch;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/transpileAndExecuteFile.js

@@ -13,7 +13,6 @@ const utils_js_1 = require("../../../utils.js");
 const replaceImportStatements_js_1 = require("./replaceImportStatements.js");
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 require("source-map-support/register.js");
-const getFilePathToShowToUser_js_1 = require("./getFilePathToShowToUser.js");
 const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
@@ -23,9 +22,9 @@ async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
 }
 exports.transpileAndExecuteFile = transpileAndExecuteFile;
 async function transpileFile(filePath, isValueFile, userRootDir) {
-    const { filePathAbsolute } = filePath;
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
-    getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = filePath;
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
     let fileImports = null;
     {
@@ -39,14 +38,13 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
 }
 function transpileImports(codeOriginal, filePath, isValueFile) {
     // Do we need to remove the imports?
-    const { filePathAbsolute } = filePath;
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
-    const isHeader = isHeaderFile(filePathAbsolute);
+    const { filePathAbsoluteFilesystem, filePathToShowToUser } = filePath;
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     const isPageConfigFile = !isValueFile;
     if (!isHeader && !isPageConfigFile) {
         return null;
     }
-    const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath);
     (0, utils_js_1.assertWarning)(isPageConfigFile, `${filePathToShowToUser} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
     // Remove the imports
     const res = (0, replaceImportStatements_js_1.replaceImportStatements)(codeOriginal, filePathToShowToUser);
@@ -63,7 +61,7 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     return { code, fileImports };
 }
 async function transpileWithEsbuild(filePath, bundle, userRootDir) {
-    const entryFilePath = filePath.filePathAbsolute;
+    const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path_1.default.posix.dirname(entryFilePath);
     const options = {
         platform: 'node',
@@ -128,8 +126,8 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
             (0, utils_js_1.assertPosixPath)(userRootDir);
-            const filePathAbsolute = path_1.default.posix.join(userRootDir, filePathRelative);
-            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsolute);
+            const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
+            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
         });
     }
     const code = result.outputFiles[0].text;
@@ -137,10 +135,10 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     return code;
 }
 async function executeFile(filePath, code, fileImports, isValueFile) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = filePath;
+    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
-    const filePathTmp = getFilePathTmp(filePathAbsolute);
+    const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
     fs_1.default.writeFileSync(filePathTmp, code);
     const clean = () => fs_1.default.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -163,7 +161,7 @@ async function executeFile(filePath, code, fileImports, isValueFile) {
     fileExports = { ...fileExports };
     if (fileImports && !isValueFile) {
         (0, utils_js_1.assert)(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsoluteFilesystem;
         assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
     }
     return { fileExports };
@@ -234,11 +232,11 @@ function assertImportsAreReExported(fileImports, fileExports, filePathToShowToUs
     const importStatements = (0, utils_js_1.unique)(fileImportsUnused.map((fi) => fi.importStatementCode));
     const importNamesUnused = fileImportsUnused.map((fi) => picocolors_1.default.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
-    (0, utils_js_1.assertUsage)(fileImportsUnused.length === 0, [
+    (0, utils_js_1.assertWarning)(fileImportsUnused.length === 0, [
         `${filePathToShowToUser} imports the following:`,
         ...importStatements.map((s) => picocolors_1.default.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${picocolors_1.default.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
-    ].join('\n'));
+    ].join('\n'), { onlyOnce: true });
 }
 function getExportedStrings(obj) {
     const exportedStrings = [];
@@ -279,7 +277,7 @@ function triggerPrepareStackTrace(err) {
 function getErrIntroMsg(operation, filePath) {
     const msg = [
         picocolors_1.default.red(`Failed to ${operation}`),
-        picocolors_1.default.bold(picocolors_1.default.red((0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath))),
+        picocolors_1.default.bold(picocolors_1.default.red(filePath.filePathToShowToUser)),
         picocolors_1.default.red(`because:`)
     ].join(' ');
     return msg;

package/dist/cjs/node/plugin/plugins/previewConfig.js

@@ -18,6 +18,7 @@ function previewConfig() {
         apply: 'serve',
         config(config) {
             return {
+                appType: 'custom',
                 build: {
                     outDir: (0, utils_js_1.resolveOutDir)(config)
                 }
@@ -28,12 +29,20 @@ function previewConfig() {
             configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
         },
         configurePreviewServer(server) {
+            /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+               - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+            config.appType = 'mpa'
+            */
             (0, utils_js_1.markEnvAsPreview)();
             return () => {
                 assertDist();
-                if (!configVike.prerender) {
-                    (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares);
+                /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
+                if (!configVike.prerender || configVike.prerender.partial) {
+                  addSsrMiddleware(server.middlewares)
                 }
+                /*/
+                (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares);
+                //*/
                 addStatic404Middleware(server.middlewares);
             };
         }

package/dist/cjs/node/prerender/runPrerender.js

@@ -41,7 +41,7 @@ const getConfigVike_js_1 = require("../shared/getConfigVike.js");
 const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const getPageContextRequestUrl_js_1 = require("../../shared/getPageContextRequestUrl.js");
 const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.js");
-const utils_js_2 = require("../../shared/page-configs/utils.js");
+const helpers_js_1 = require("../../shared/page-configs/helpers.js");
 const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const addUrlComputedProps_js_1 = require("../../shared/addUrlComputedProps.js");
@@ -49,6 +49,8 @@ const assertPathIsFilesystemAbsolute_js_1 = require("../../utils/assertPathIsFil
 const abort_js_1 = require("../../shared/route/abort.js");
 const loadPageFilesServerSide_js_1 = require("../runtime/renderPage/loadPageFilesServerSide.js");
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
+const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
+const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js");
 async function prerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
 }
@@ -95,7 +97,8 @@ async function runPrerender(options, manuallyTriggered) {
         pageContextInit: options.pageContextInit ?? null
     });
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(renderContext, doNotPrerenderList, concurrencyLimit);
+    const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig, false);
+    await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
@@ -110,12 +113,13 @@ async function runPrerender(options, manuallyTriggered) {
     await Promise.all(htmlFiles.map((htmlFile) => writeHtmlFile(htmlFile, root, outDirClient, concurrencyLimit, options.onPagePrerender, logLevel)));
     warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial);
 }
-async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concurrencyLimit) {
-    renderContext.pageConfigs.forEach((pageConfig) => {
+async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
+    // V1 design
+    pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
-        const configValue = (0, utils_js_2.getConfigValue)(pageConfig, configName, 'boolean');
+        const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
-            const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
+            const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue);
             (0, utils_js_1.assert)(configValueFilePathToShowToUser);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
@@ -125,6 +129,8 @@ async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concu
             });
         }
     });
+    // Old design
+    // TODO/v1-release: remove
     await Promise.all(renderContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
@@ -173,11 +179,11 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
-        const configValue = (0, utils_js_2.getConfigValue)(pageConfigLoaded, hookName);
+        const configValue = (0, helpers_js_1.getConfigValue)(pageConfigLoaded, hookName);
         if (!configValue)
             return;
         const hookFn = configValue.value;
-        const hookFilePath = (0, utils_js_2.getHookFilePathToShowToUser)(configValue);
+        const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
         (0, utils_js_1.assert)(hookFilePath);
         (0, getHook_js_1.assertHookFn)(hookFn, { hookName, hookFilePath });
         onBeforePrerenderStartHooks.push({
@@ -272,7 +278,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             _providedByHook: null,
             routeParams,
             _pageId: pageId,
-            _routeMatches: [
+            _debugRouteMatches: [
                 {
                     pageId,
                     routeType: pageRoute.routeType,
@@ -313,8 +319,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         const configValue = pageConfigGlobal.configValues.onPrerenderStart;
         if (configValue?.value) {
             const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
-            const hookFilePath = (0, utils_js_2.getHookFilePathToShowToUser)(configValue);
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
+            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
             (0, utils_js_1.assert)(hookFilePath);
             onPrerenderStartHook = {
                 hookFn,
@@ -371,7 +377,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             enumerable: false,
             configurable: true
         });
-        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'url'));
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
         (0, utils_js_1.assert)(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
@@ -410,7 +416,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     prerenderContext.pageContexts = result.prerenderContext.pageContexts;
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TODO/v1-release: remove
-        if (!(0, utils_js_1.hasPropertyGetter)(pageContext, 'url') && pageContext.url) {
+        if (pageContext.url && !(0, utils_js_1.isPropertyGetter)(pageContext, 'url')) {
             (0, utils_js_1.assertWarning)(false, msgPrefix +
                 ' provided pageContext.url but it should provide pageContext.urlOriginal instead, see https://vike.dev/migration/0.4.23', { onlyOnce: true });
             pageContext.urlOriginal = pageContext.url;
@@ -435,10 +441,9 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
         const { urlOriginal } = pageContext;
         (0, utils_js_1.assert)(urlOriginal);
-        const routeResult = await (0, index_js_1.route)(pageContext);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(routeResult.pageContextAddendum, '_pageId', 'null') ||
-            (0, utils_js_1.hasProp)(routeResult.pageContextAddendum, '_pageId', 'string'));
-        if (routeResult.pageContextAddendum._pageId === null) {
+        const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'string'));
+        if (pageContextFromRoute._pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -451,17 +456,17 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             if (hookName) {
                 (0, utils_js_1.assert)(hookFilePath);
-                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that doesn't match any of your page routes. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
+                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that ${noRouteMatch_js_1.noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
             }
             else {
                 // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
-                (0, utils_js_1.assert)(routeResult.pageContextAddendum._routingProvidedByOnBeforeRouteHook);
+                (0, utils_js_1.assert)(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
                 // Abort since the URL doesn't correspond to any page
                 return;
             }
         }
-        (0, utils_js_1.assert)(routeResult.pageContextAddendum._pageId);
-        (0, utils_js_1.objectAssign)(pageContext, routeResult.pageContextAddendum);
+        (0, utils_js_1.assert)(pageContextFromRoute._pageId);
+        (0, utils_js_1.objectAssign)(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
         (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageFilesServerSide_js_1.loadPageFilesServerSide)(pageContext));
         let usesClientRouter;
@@ -469,7 +474,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             if (pageContext._pageConfigs.length > 0) {
                 const pageConfig = pageContext._pageConfigs.find((p) => p.pageId === pageId);
                 (0, utils_js_1.assert)(pageConfig);
-                usesClientRouter = (0, utils_js_2.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+                usesClientRouter = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
                 usesClientRouter = globalContext.pluginManifest.usesClientRouter;
@@ -515,15 +520,18 @@ function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList)
 }
 function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
-    const hookName = isV1 ? 'prerender' : 'onBeforePrerenderStart';
-    const getPageAt = isV1 ? (pageId) => `defined at ${pageId}` : (pageId) => `\`${pageId}.page.*\``;
+    const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
+    /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
+    const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
+    const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
+    */
     renderContext.allPageIds
         .filter((pageId) => !prerenderPageIds[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
-        const pageAt = getPageAt(pageId);
-        (0, utils_js_1.assertWarning)(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, and no ${hookName}() hook returned (an) URL(s) matching the page's route. Either use a ${hookName}() hook to pre-render the page, or use the option ${picocolors_1.default.cyan('prerender.partial')} to suppress this warning, see https://vike.dev/prerender-config`, { onlyOnce: true });
+        const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
+        (0, utils_js_1.assertWarning)(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender-config#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
 async function prerender404(htmlFiles, renderContext, prerenderContext) {

package/dist/cjs/node/prerender/utils.js

@@ -23,7 +23,7 @@ __exportStar(require("../../utils/objectAssign.js"), exports);
 __exportStar(require("../../utils/isObjectWithKeys.js"), exports);
 __exportStar(require("../../utils/isCallable.js"), exports);
 __exportStar(require("../../utils/getOutDirs.js"), exports);
-__exportStar(require("../../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../../utils/filesystemPathHandling.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../shared/hooks/executeHook.js"), exports);

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -50,19 +50,33 @@ function serializePageContextClientSide(pageContext) {
             catch (err) {
                 hasWarned = true;
                 propsNonSerializable.push(prop);
-                (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
-                (0, utils_js_1.assertWarning)(false, [
+                let msg = [
                     `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
-                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`,
-                    `Serialization error: ${err.messageCore}.`
-                ].join(' '), { onlyOnce: false });
+                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`
+                ].join(' ');
+                if ((0, stringify_1.isJsonSerializerError)(err)) {
+                    msg = `${msg} Serialization error: ${err.messageCore}.`;
+                }
+                else {
+                    // When a property getter throws an error
+                    console.warn('Serialization error:');
+                    console.warn(err);
+                    msg = `${msg} The serialization failed because of the error printed above.`;
+                }
+                // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
+                (0, utils_js_1.assertWarning)(false, msg, { onlyOnce: false });
             }
         });
         (0, utils_js_1.assert)(hasWarned);
         propsNonSerializable.forEach((prop) => {
             pageContextClient[prop] = notSerializable_js_1.notSerializable;
         });
-        pageContextSerialized = serialize(pageContextClient);
+        try {
+            pageContextSerialized = serialize(pageContextClient);
+        }
+        catch (err) {
+            (0, utils_js_1.assert)(false);
+        }
     }
     return pageContextSerialized;
 }

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

@@ -11,7 +11,7 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     const padding = '   - ';
     debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
     debug(`URL:`, pageContext.urlOriginal);
-    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._routeMatches));
+    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._debugRouteMatches));
     debug(`pageId:`, pageContext._pageId);
     debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
     debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
@@ -21,14 +21,14 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     debug('Client-side entries:', clientEntries);
     debug('Client-side dependencies:', clientDependencies);
     return;
-    function printRouteMatches(routeMatches) {
-        if (routeMatches === 'ROUTE_ERROR') {
+    function printRouteMatches(debugRouteMatches) {
+        if (debugRouteMatches === 'ROUTING_ERROR') {
             return 'Routing Failed';
         }
-        if (routeMatches === 'CUSTOM_ROUTE') {
+        if (debugRouteMatches === 'CUSTOM_ROUTING') {
             return 'Custom Routing';
         }
-        return routeMatches;
+        return debugRouteMatches;
     }
     function printPageFiles(pageFiles, genericPageFilesLast = false) {
         if (pageFiles.length === 0) {