vike 0.4.147 → 0.4.148-commit-7596dcd

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

@@ -53,22 +53,27 @@ function getConfigValueSerialized(value, configName, definedAt) {
         configValueSerialized = (0, stringify_1.stringify)(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        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';
+        /*
+        let serializationErrMsg = ''
+        if (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_1.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 its value isn't serializable: ${serializationErrMsg}.)`,
-            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
+            `The code of ${picocolors_1.default.cyan(configName)} cannot live inside ${configValueFilePathToShowToUser},`,
+            'see https://vike.dev/header-file#runtime-code'
+            /* I guess showing this is more confusing than adding value.
+            `(technically speaking: the value of ${pc.cyan(
+              configName
+            )} isn't serializable (${serializationErrMsg}) and it's therefore runtime code that needs to be imported).`
+            //*/
         ].join(' '));
     }
     configValueSerialized = JSON.stringify(configValueSerialized);

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

@@ -76,6 +76,9 @@ const configDefinitionsBuiltIn = {
     onBeforeRenderEnv: {
         env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
+    },
+    hooksTimeout: {
+        env: { server: true, client: true }
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;

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

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crawlPlusFiles = void 0;
+const utils_js_1 = require("../../../../utils.js");
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execA = (0, util_1.promisify)(child_process_1.exec);
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPosixPath)(outDirAbsoluteFilesystem);
+    (0, utils_js_1.assert)(outDirAbsoluteFilesystem.startsWith(userRootDir));
+    const outDir = path_1.default.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    (0, utils_js_1.assert)(!outDir.startsWith('.'));
+    const timeBase = new Date().getTime();
+    let files = [];
+    const res = await gitLsFiles(userRootDir, outDir);
+    if (res &&
+        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        res.length > 0) {
+        files = res;
+    }
+    else {
+        files = await fastGlob(userRootDir, outDir);
+    }
+    {
+        const time = new Date().getTime() - timeBase;
+        if (isDev) {
+            // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+            (0, utils_js_1.assertWarning)(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
+                onlyOnce: 'slow-page-files-search'
+            });
+        }
+    }
+    const plusFiles = files.map((p) => {
+        p = (0, utils_js_1.toPosixPath)(p);
+        (0, utils_js_1.assert)(!p.startsWith(userRootDir));
+        const filePathRelativeToUserRootDir = path_1.default.posix.join('/', p);
+        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, p);
+        return {
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem
+        };
+    });
+    return plusFiles;
+}
+exports.crawlPlusFiles = crawlPlusFiles;
+// Same as fastGlob() but using `$ git ls-files`
+async function gitLsFiles(userRootDir, outDir) {
+    // Test if Git is installed
+    {
+        let stdout;
+        try {
+            const res = await execA('git --version', { cwd: userRootDir });
+            stdout = res.stdout;
+        }
+        catch {
+            return null;
+        }
+        (0, utils_js_1.assert)(stdout.startsWith('git version '));
+    }
+    const cmd = [
+        'git ls-files',
+        ...utils_js_1.scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        ...getIgnorePatterns(outDir).map((pattern) => `--exclude="${pattern}"`),
+        // --others lists untracked files only (but using .gitignore because --exclude-standard)
+        // --cached adds the tracked files to the output
+        '--others --cached --exclude-standard'
+    ].join(' ');
+    let stdout;
+    try {
+        const res = await execA(cmd, { cwd: userRootDir });
+        stdout = res.stdout;
+    }
+    catch (err) {
+        if (err.message.includes('not a git repository'))
+            return null;
+        throw err;
+    }
+    let files = stdout.split('\n').filter(Boolean);
+    (0, utils_js_1.assert)(!outDir.startsWith('/'));
+    files = files.filter(
+    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+    (file) => getIgnoreFilter(file, outDir));
+    return files;
+}
+// Same as gitLsFiles() but using fast-glob
+async function fastGlob(userRootDir, outDir) {
+    const files = await (0, fast_glob_1.default)(`**/+*.${utils_js_1.scriptFileExtensions}`, {
+        ignore: getIgnorePatterns(outDir),
+        cwd: userRootDir,
+        dot: false
+    });
+    return files;
+}
+// Same as getIgnoreFilter() but as glob pattern
+function getIgnorePatterns(outDir) {
+    return [
+        '**/node_modules/**',
+        `${outDir}/**`,
+        // Allow:
+        // ```
+        // +Page.js
+        // +Page.telefunc.js
+        // ```
+        '**/*.telefunc.*'
+    ];
+}
+// Same as getIgnorePatterns() but for Array.filter()
+function getIgnoreFilter(file, outDir) {
+    return !file.includes('node_modules/') && !file.includes('.telefunc.') && !file.startsWith(`${outDir}/`);
+}

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

@@ -7,7 +7,6 @@ exports.isVikeConfigFile = exports.vikeConfigDependencies = exports.reloadVikeCo
 const utils_js_1 = require("../../../utils.js");
 const path_1 = __importDefault(require("path"));
 const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
-const fast_glob_1 = __importDefault(require("fast-glob"));
 const filesystemRouting_js_1 = require("./getVikeConfig/filesystemRouting.js");
 const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
 const replaceImportStatements_js_1 = require("./replaceImportStatements.js");
@@ -20,6 +19,7 @@ const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
 const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
 const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
+const crawlPlusFiles_js_1 = require("./getVikeConfig/crawlPlusFiles.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -75,7 +75,7 @@ async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, exten
 }
 exports.getVikeConfig = getVikeConfig;
 async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
-    const plusFiles = await findPlusFiles(userRootDir, [outDirRoot], isDev, extensions);
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, extensions);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -127,6 +127,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             interfaceFilesByLocationId[locationId].push(interfaceFile);
         }
     }));
+    assertAllConfigsAreKnown(interfaceFilesByLocationId);
     return interfaceFilesByLocationId;
 }
 function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
@@ -180,6 +181,18 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     });
     return interfaceFile;
 }
+/** Show error message upon unknown config */
+function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
+    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        interfaceFiles.forEach((interfaceFile) => {
+            Object.keys(interfaceFile.configMap).forEach((configName) => {
+                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
+            });
+        });
+    });
+}
 async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
@@ -270,18 +283,23 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
         };
         return pageConfig;
     }));
-    // Show error message upon unknown config
-    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
-        interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.configMap).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
-            });
-        });
-    });
+    assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal, globalVikeConfig };
 }
+function assertPageConfigs(pageConfigs) {
+    pageConfigs.forEach((pageConfig) => {
+        assertOnBeforeRenderEnv(pageConfig);
+    });
+}
+function assertOnBeforeRenderEnv(pageConfig) {
+    const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
+    if (!onBeforeRenderConfig)
+        return;
+    const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
+    const isClientRouting = !!pageConfig.configValues.clientRouting?.value;
+    // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
+    (0, utils_js_1.assertUsage)(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${picocolors_1.default.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
+}
 function interfacefileIsAlreaydLoaded(interfaceFile) {
     const configMapValues = Object.values(interfaceFile.configMap);
     const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
@@ -781,39 +799,9 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
-    const timeBase = new Date().getTime();
-    (0, utils_js_1.assertPosixPath)(userRootDir);
-    const ignorePatterns = [];
-    for (const dir of ignoreDirs) {
-        (0, utils_js_1.assertPosixPath)(dir);
-        ignorePatterns.push(`${path_1.default.posix.relative(userRootDir, dir)}/**`);
-    }
-    const result = await (0, fast_glob_1.default)(`**/+*.${utils_js_1.scriptFileExtensions}`, {
-        ignore: [
-            '**/node_modules/**',
-            // Allow:
-            // ```
-            // +Page.js
-            // +Page.telefunc.js
-            // ```
-            '**/*.telefunc.*',
-            ...ignorePatterns
-        ],
-        cwd: userRootDir,
-        dot: false
-    });
-    const time = new Date().getTime() - timeBase;
-    if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-        (0, utils_js_1.assertWarning)(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
-            onlyOnce: 'slow-page-files-search'
-        });
-    }
-    const plusFiles = result.map((p) => {
-        p = (0, utils_js_1.toPosixPath)(p);
-        const filePathRelativeToUserRootDir = path_1.default.posix.join('/', p);
-        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, p);
+async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
+    const files = await (0, crawlPlusFiles_js_1.crawlPlusFiles)(userRootDir, outDirRoot, isDev);
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
         return {
             filePathRelativeToUserRootDir,
             filePathAbsoluteVite: filePathRelativeToUserRootDir,

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

@@ -102,16 +102,22 @@ async function runPrerender(options, manuallyTriggered) {
     await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderedPages = {};
-    const htmlFiles = [];
-    await routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages, concurrencyLimit);
-    warnContradictoryNoPrerenderList(prerenderedPages, doNotPrerenderList);
-    await prerender404(htmlFiles, renderContext, prerenderContext);
+    const prerenderedPageContexts = {};
+    let prerenderedCount = 0;
+    const onComplete = async (htmlFile) => {
+        prerenderedCount++;
+        if (htmlFile.pageId) {
+            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+        }
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+    };
+    await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
+    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
     if (logLevel === 'info') {
-        console.log(`${picocolors_1.default.green(`✓`)} ${htmlFiles.length} HTML documents pre-rendered.`);
+        console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    await Promise.all(htmlFiles.map((htmlFile) => writeHtmlFile(htmlFile, root, outDirClient, concurrencyLimit, options.onPagePrerender, logLevel)));
-    warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
 }
 async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -179,18 +185,16 @@ 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, helpers_js_1.getConfigValue)(pageConfigLoaded, hookName);
-        if (!configValue)
+        const hook = (0, getHook_js_1.getHookFromPageConfig)(pageConfigLoaded, hookName);
+        if (!hook)
             return;
-        const hookFn = configValue.value;
-        const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
-        (0, utils_js_1.assert)(hookFilePath);
-        (0, getHook_js_1.assertHookFn)(hookFn, { hookName, hookFilePath });
+        const { hookFn, hookFilePath, hookTimeout } = hook;
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'onBeforePrerenderStart',
             hookFilePath,
-            pageId: pageConfig.pageId
+            pageId: pageConfig.pageId,
+            hookTimeout
         });
     })));
     // 0.4 design
@@ -214,14 +218,15 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
             hookFn,
             hookName: 'prerender',
             hookFilePath,
-            pageId: p.pageId
+            pageId: p.pageId,
+            hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerenderStart')
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId, hookTimeout }) => concurrencyLimit(async () => {
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await hookFn();
+        const prerenderResult = await (0, utils_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout });
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -320,23 +325,21 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     let onPrerenderStartHook;
     // V1 design
     if (renderContext.pageConfigs.length > 0) {
-        const { pageConfigGlobal } = renderContext;
-        const configValue = pageConfigGlobal.configValues.onPrerenderStart;
-        if (configValue?.value) {
-            const { value: hookFn } = 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);
+        const hookName = 'onPrerenderStart';
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(renderContext.pageConfigGlobal, hookName);
+        if (hook) {
+            (0, utils_js_1.assert)(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
-                hookFn,
-                hookName: 'onPrerenderStart',
-                hookFilePath
+                ...hook,
+                // Make TypeScript happy
+                hookName
             };
         }
     }
     // Old design
     // TODO/v1-release: remove
     if (renderContext.pageConfigs.length === 0) {
+        const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerender');
         const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
@@ -362,7 +365,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         onPrerenderStartHook = {
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
-            hookName: 'onBeforePrerender'
+            hookName: 'onBeforePrerender',
+            hookTimeout
         };
     }
     if (!onPrerenderStartHook) {
@@ -397,7 +401,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), hookName, hookFilePath);
+    }), onPrerenderStartHook);
     if (result === null || result === undefined) {
         return;
     }
@@ -439,7 +443,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContext);
     });
 }
-async function routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages, concurrencyLimit) {
+async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     (0, utils_js_1.assert)(globalContext.isPrerendering);
     // Route all URLs
@@ -499,7 +503,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages,
             throw err;
         }
         const { documentHtml, pageContextSerialized } = res;
-        htmlFiles.push({
+        await onComplete({
             urlOriginal,
             pageContext,
             htmlString: documentHtml,
@@ -507,11 +511,10 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages,
             doNotCreateExtraDirectory: prerenderContext._noExtraDir,
             pageId
         });
-        prerenderedPages[pageId] = pageContext;
     })));
 }
-function warnContradictoryNoPrerenderList(prerenderedPages, doNotPrerenderList) {
-    Object.entries(prerenderedPages).forEach(([pageId, pageContext]) => {
+function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList) {
+    Object.entries(prerenderedPageContexts).forEach(([pageId, pageContext]) => {
         const doNotPrerenderListEntry = doNotPrerenderList.find((p) => p.pageId === pageId);
         const { urlOriginal, _providedByHook: providedByHook } = pageContext;
         {
@@ -523,7 +526,7 @@ function warnContradictoryNoPrerenderList(prerenderedPages, doNotPrerenderList)
         (0, utils_js_1.assertWarning)(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${picocolors_1.default.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))} or remove the URL ${picocolors_1.default.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, partial) {
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
     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)
@@ -531,7 +534,7 @@ function warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, p
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
     renderContext.allPageIds
-        .filter((pageId) => !prerenderedPages[pageId])
+        .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
@@ -539,8 +542,8 @@ function warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, p
         (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) {
-    if (!htmlFiles.find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
+    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(renderContext, prerenderContext.pageContextInit);
@@ -552,7 +555,7 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         if (result) {
             const urlOriginal = '/404';
             const { documentHtml, pageContext } = result;
-            htmlFiles.push({
+            await onComplete({
                 urlOriginal,
                 pageContext,
                 htmlString: documentHtml,
@@ -563,59 +566,57 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         }
     }
 }
-async function writeHtmlFile({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, concurrencyLimit, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
     (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
     }
     await Promise.all(writeJobs);
 }
-function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel) {
-    return concurrencyLimit(async () => {
-        let fileUrl;
-        if (fileExtension === '.html') {
-            fileUrl = (0, utils_js_1.urlToFile)(urlOriginal, '.html', doNotCreateExtraDirectory);
-        }
-        else {
-            fileUrl = (0, getPageContextRequestUrl_js_1.getPageContextRequestUrl)(urlOriginal);
-        }
-        (0, utils_js_1.assertPosixPath)(fileUrl);
-        (0, utils_js_1.assert)(fileUrl.startsWith('/'));
-        const filePathRelative = fileUrl.slice(1);
-        (0, utils_js_1.assert)(!filePathRelative.startsWith('/'));
-        (0, utils_js_1.assertPosixPath)(outDirClient);
-        (0, utils_js_1.assertPosixPath)(filePathRelative);
-        const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
-        if (onPagePrerender) {
-            const prerenderPageContext = {};
-            (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
-            (0, utils_js_1.objectAssign)(prerenderPageContext, {
-                _prerenderResult: {
-                    filePath,
-                    fileContent
-                }
-            });
-            await onPagePrerender(prerenderPageContext);
-        }
-        else {
-            const { promises } = await Promise.resolve().then(() => __importStar(require('fs')));
-            const { writeFile, mkdir } = promises;
-            await mkdir(path_1.default.posix.dirname(filePath), { recursive: true });
-            await writeFile(filePath, fileContent);
-            if (logLevel === 'info') {
-                (0, utils_js_1.assertPosixPath)(root);
-                (0, utils_js_1.assertPosixPath)(outDirClient);
-                let outDirClientRelative = path_1.default.posix.relative(root, outDirClient);
-                if (!outDirClientRelative.endsWith('/')) {
-                    outDirClientRelative = outDirClientRelative + '/';
-                }
-                console.log(`${picocolors_1.default.dim(outDirClientRelative)}${picocolors_1.default.blue(filePathRelative)}`);
+async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+    let fileUrl;
+    if (fileExtension === '.html') {
+        fileUrl = (0, utils_js_1.urlToFile)(urlOriginal, '.html', doNotCreateExtraDirectory);
+    }
+    else {
+        fileUrl = (0, getPageContextRequestUrl_js_1.getPageContextRequestUrl)(urlOriginal);
+    }
+    (0, utils_js_1.assertPosixPath)(fileUrl);
+    (0, utils_js_1.assert)(fileUrl.startsWith('/'));
+    const filePathRelative = fileUrl.slice(1);
+    (0, utils_js_1.assert)(!filePathRelative.startsWith('/'));
+    (0, utils_js_1.assertPosixPath)(outDirClient);
+    (0, utils_js_1.assertPosixPath)(filePathRelative);
+    const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    if (onPagePrerender) {
+        const prerenderPageContext = {};
+        (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
+        (0, utils_js_1.objectAssign)(prerenderPageContext, {
+            _prerenderResult: {
+                filePath,
+                fileContent
+            }
+        });
+        await onPagePrerender(prerenderPageContext);
+    }
+    else {
+        const { promises } = await Promise.resolve().then(() => __importStar(require('fs')));
+        const { writeFile, mkdir } = promises;
+        await mkdir(path_1.default.posix.dirname(filePath), { recursive: true });
+        await writeFile(filePath, fileContent);
+        if (logLevel === 'info') {
+            (0, utils_js_1.assertPosixPath)(root);
+            (0, utils_js_1.assertPosixPath)(outDirClient);
+            let outDirClientRelative = path_1.default.posix.relative(root, outDirClient);
+            if (!outDirClientRelative.endsWith('/')) {
+                outDirClientRelative = outDirClientRelative + '/';
             }
+            console.log(`${picocolors_1.default.dim(outDirClientRelative)}${picocolors_1.default.blue(filePathRelative)}`);
         }
-    });
+    }
 }
 function normalizeOnPrerenderHookResult(prerenderResult, prerenderHookFile, hookName) {
     if (Array.isArray(prerenderResult)) {

package/dist/cjs/node/runtime/html/injectAssets/injectAssets__public.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectAssets__public = void 0;
 const utils_js_1 = require("../../utils.js");
 const injectAssets_js_1 = require("../injectAssets.js");
-// TODO: remove this on next semver major
+// TODO/v1-release: remove
 async function injectAssets__public(htmlString, pageContext) {
     (0, utils_js_1.assertWarning)(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     (0, utils_js_1.assertUsage)(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });

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

@@ -179,7 +179,7 @@ async function renderTemplate(templateContent, pageContext) {
         };
         (0, utils_js_1.assertUsage)(!(0, utils_js_1.isPromise)(templateVar), getErrMsg('a promise', `Did you forget to ${picocolors_1.default.cyan('await')} the promise?`));
         if (templateVar === undefined || templateVar === null) {
-            (0, utils_js_1.assertWarning)(false, getErrMsg(`${picocolors_1.default.cyan(String(templateVar))} which will be converted to an empty string`, `Pass an empty string instead of ${picocolors_1.default.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
+            (0, utils_js_1.assertWarning)(false, getErrMsg(`${picocolors_1.default.cyan(String(templateVar))} which will be converted to an empty string`, `Pass the empty string ${picocolors_1.default.cyan("''")} instead of ${picocolors_1.default.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
             templateVar = '';
         }
         {