vike 0.4.146-commit-701e2e5 → 0.4.147-commit-2fa53b2

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

@@ -7,10 +7,11 @@ const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
 const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
-const getConfigValueSourcesRelevant_js_1 = require("../../../shared/getConfigValueSourcesRelevant.js");
+const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfigValueSourcesNotOverriden.js");
 const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
+const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
     (0, utils_js_1.assert)(result);
@@ -31,27 +32,52 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
 }
 exports.getVirtualFilePageConfigValuesAll = getVirtualFilePageConfigValuesAll;
 function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
-    const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
-    const isClientRouting = configValue?.value ?? false;
     const lines = [];
     const importStatements = [];
-    lines.push('export default [');
-    const varCounterContainer = { varCounter: 0 };
-    (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
-        if (!valueIsImportedAtRuntime)
-            return;
-        if (configValueSource.valueIsFilePath)
-            return;
-        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));
-    });
+    const isClientRouting = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+    lines.push('export const configValuesImported = [');
+    lines.push(getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements));
     lines.push('];');
+    lines.push('export const configValuesSerialized = {');
+    lines.push((0, getConfigValuesSerialized_js_1.getConfigValuesSerialized)(pageConfig, (configEnv, configValueSource) => isEnvMatch(configEnv, !configValueSource ? false : checkWhetherIsImport(configValueSource), {
+        isImport: false,
+        isForClientSide,
+        isClientRouting
+    })));
+    lines.push('};');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {
-        lines.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, false))}'`);
+        importStatements.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, false))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
+function getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements) {
+    const lines = [];
+    const varCounterContainer = { varCounter: 0 };
+    (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
+        if (!isEnvMatch(configValueSource.configEnv, checkWhetherIsImport(configValueSource), {
+            isImport: true,
+            isForClientSide,
+            isClientRouting
+        }))
+            return;
+        const whitespace = '  ';
+        lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configValueSource.configName, whitespace, varCounterContainer, importStatements));
+    });
+    const code = lines.join('\n');
+    return code;
+}
+function checkWhetherIsImport(configValueSource) {
+    const { valueIsImportedAtRuntime, valueIsFilePath } = configValueSource;
+    return valueIsImportedAtRuntime && !valueIsFilePath;
+}
+function isEnvMatch(configEnv, isImport, runtime) {
+    // Whether config value is imported or serialized
+    if (isImport !== runtime.isImport)
+        return false;
+    // Runtime match
+    const { isForClientSide, isClientRouting } = runtime;
+    if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false }))
+        return false;
+    return true;
+}

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

@@ -1,19 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigValueSerialized = exports.getVirtualFilePageConfigs = void 0;
+exports.getVirtualFilePageConfigs = void 0;
 const utils_js_1 = require("../../../utils.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const debug_js_1 = require("./debug.js");
-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 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");
+const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 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);
@@ -23,15 +17,18 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const lines = [];
     const importStatements = [];
     const varCounterContainer = { varCounter: 0 };
+    lines.push('export const pageConfigsSerialized = [');
     lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer));
+    lines.push('];');
+    lines.push('export const pageConfigGlobalSerialized = {');
     lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer));
+    lines.push('};');
     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;
         const virtualFileIdPageConfigValuesAll = (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide);
@@ -39,35 +36,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: async () => (await import(${JSON.stringify(virtualFileIdPageConfigValuesAll)})).default,`);
+        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        // Serialized config values
         lines.push(`    configValuesSerialized: {`);
-        Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
-            const { value, configEnv } = configValuesComputed;
-            if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true }))
-                return;
-            if (pageConfig.configValueSources[configName])
-                return;
-            const configValue = pageConfig.configValues[configName];
-            (0, utils_js_1.assert)(configValue);
-            const { definedAt } = configValue;
-            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-            (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
-        });
-        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
-            const configValue = pageConfig.configValues[configName];
-            if (configValue) {
-                const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig.configValueSources, configName);
-                (0, utils_js_1.assert)(configEnv, configName);
-                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);
-                (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
-            }
-        });
+        lines.push((0, getConfigValuesSerialized_js_1.getConfigValuesSerialized)(pageConfig, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true })));
         lines.push(`    },`);
-        let whitespace = '    ';
+        // Imported config values
+        const whitespace = '    ';
         lines.push(`${whitespace}configValuesImported: [`);
         Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
             const configValue = pageConfig.configValues[configName];
@@ -75,21 +50,18 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
                 return;
             const configValueSource = sources[0];
             (0, utils_js_1.assert)(configValueSource);
-            if (configValueSource.configEnv !== '_routing-eager')
+            if (!configValueSource.configEnv.eager)
                 return;
             lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);
-        // pageConfig end
         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: {`)
     lines.push(`  },`)
@@ -114,36 +86,6 @@ function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, is
         lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push(`  ],`);
-    lines.push('};');
     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, 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';
-        }
-        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 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(' '));
-    }
-    configValueSerialized = JSON.stringify(configValueSerialized);
-    return configValueSerialized;
-}
-exports.getConfigValueSerialized = getConfigValueSerialized;

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

@@ -2,17 +2,20 @@
 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)
+    // Runtime
+    if (!runtime.isForClientSide) {
+        if (!configEnv.server)
             return false;
-        if (isEager !== (configEnv === '_routing-eager'))
+    }
+    else {
+        if (!configEnv.client)
+            return false;
+        if (configEnv.client === 'if-client-routing' && !runtime.isClientRouting)
             return false;
     }
+    // Eager
+    if (runtime.isEager !== !!configEnv.eager)
+        return false;
     return true;
 }
 exports.isRuntimeEnvMatch = isRuntimeEnvMatch;

package/dist/cjs/node/plugin/shared/{getConfigValueSourcesRelevant.js → getConfigValueSourcesNotOverriden.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigValueSourcesRelevant = void 0;
+exports.getConfigValueSourcesNotOverriden = void 0;
 const utils_js_1 = require("../../shared/utils.js");
 (0, utils_js_1.assertIsNotBrowser)();
-function getConfigValueSourcesRelevant(pageConfig) {
+function getConfigValueSourcesNotOverriden(pageConfig) {
     const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
         const configValueSource = sources[0];
         (0, utils_js_1.assert)(configValueSource);
@@ -11,4 +11,4 @@ function getConfigValueSourcesRelevant(pageConfig) {
     });
     return configValueSourcesRelevant;
 }
-exports.getConfigValueSourcesRelevant = getConfigValueSourcesRelevant;
+exports.getConfigValueSourcesNotOverriden = getConfigValueSourcesNotOverriden;

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

@@ -38,3 +38,5 @@ __exportStar(require("../../utils/removeEmptyLines.js"), exports);
 __exportStar(require("../../utils/findUserPackageJsonPath.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/mergeCumulativeValues.js"), exports);
+__exportStar(require("../../utils/deepEqual.js"), exports);
+__exportStar(require("../../utils/assertKeys.js"), exports);

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

@@ -99,19 +99,25 @@ async function runPrerender(options, manuallyTriggered) {
     const doNotPrerenderList = [];
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig, false);
     await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderPageIds = {};
-    const htmlFiles = [];
-    await routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds, concurrencyLimit);
-    warnContradictoryNoPrerenderList(prerenderPageIds, 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(prerenderPageIds, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
 }
 async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -173,7 +179,7 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     (0, utils_js_1.assert)(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
     // V1 design
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
@@ -189,7 +195,8 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'onBeforePrerenderStart',
-            hookFilePath
+            hookFilePath,
+            pageId: pageConfig.pageId
         });
     })));
     // 0.4 design
@@ -212,10 +219,14 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'prerender',
-            hookFilePath
+            hookFilePath,
+            pageId: p.pageId
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId }) => concurrencyLimit(async () => {
+        if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
+            return;
+        }
         const prerenderResult = await hookFn();
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
@@ -434,7 +445,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContext);
     });
 }
-async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds, concurrencyLimit) {
+async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     (0, utils_js_1.assert)(globalContext.isPrerendering);
     // Route all URLs
@@ -494,7 +505,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             throw err;
         }
         const { documentHtml, pageContextSerialized } = res;
-        htmlFiles.push({
+        await onComplete({
             urlOriginal,
             pageContext,
             htmlString: documentHtml,
@@ -502,11 +513,10 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             doNotCreateExtraDirectory: prerenderContext._noExtraDir,
             pageId
         });
-        prerenderPageIds[pageId] = pageContext;
     })));
 }
-function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList) {
-    Object.entries(prerenderPageIds).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;
         {
@@ -518,7 +528,7 @@ function warnContradictoryNoPrerenderList(prerenderPageIds, 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(prerenderPageIds, 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)
@@ -526,7 +536,7 @@ function warnMissingPages(prerenderPageIds, 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) => !prerenderPageIds[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) => {
@@ -534,8 +544,8 @@ function warnMissingPages(prerenderPageIds, 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);
@@ -547,7 +557,7 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         if (result) {
             const urlOriginal = '/404';
             const { documentHtml, pageContext } = result;
-            htmlFiles.push({
+            await onComplete({
                 urlOriginal,
                 pageContext,
                 htmlString: documentHtml,
@@ -558,59 +568,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/index-common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPageRenderer = exports._injectAssets = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
+exports.createPageRenderer = exports._injectAssets = exports.version = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
 var renderPage_js_1 = require("./renderPage.js");
 Object.defineProperty(exports, "renderPage", { enumerable: true, get: function () { return renderPage_js_1.renderPage; } });
 var renderHtml_js_1 = require("./html/renderHtml.js");
@@ -11,6 +11,8 @@ Object.defineProperty(exports, "pipeWebStream", { enumerable: true, get: functio
 Object.defineProperty(exports, "pipeNodeStream", { enumerable: true, get: function () { return stream_js_1.pipeNodeStream; } });
 Object.defineProperty(exports, "pipeStream", { enumerable: true, get: function () { return stream_js_1.pipeStream; } });
 Object.defineProperty(exports, "stampPipe", { enumerable: true, get: function () { return stream_js_1.stampPipe; } });
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
 // TODO/v1-release: remove
 var injectAssets__public_js_1 = require("./html/injectAssets/injectAssets__public.js");
 Object.defineProperty(exports, "_injectAssets", { enumerable: true, get: function () { return injectAssets__public_js_1.injectAssets__public; } });

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

@@ -31,8 +31,8 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           if (configElement.importPath) {
             const { env } = configElement
             assert(env)
-            const onlyAssets = env === 'server-only'
-            const eagerlyImported = env === '_routing-eager'
+            const onlyAssets = env === { server: true }
+            const eagerlyImported = env === { server: true, client: 'if-client-routing', eager: true }
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
                 id: configElement.importPath,

package/dist/cjs/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.js

@@ -9,21 +9,21 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalObject = (0, utils_js_1.getGlobalObject)('assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
-    if (urlRedirectOriginal.startsWith('http')) {
-        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+    if (urlRedirectTarget.startsWith('http')) {
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
-        //    // URL origin is usually missing
+        //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    (0, utils_js_1.assert)(urlRedirectOriginal.startsWith('/'));
-    (0, utils_js_1.assert)(urlRedirectPathnameLogical.startsWith('/'));
+    (0, utils_js_1.assert)(urlRedirectTarget.startsWith('/'));
+    (0, utils_js_1.assert)(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
-    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
-    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
+    graph[urlRedirectTarget].add(urlLogical);
     validate(graph);
     globalObject.redirectGraph = graph;
 }
@@ -32,6 +32,9 @@ function copy(G) {
     return Object.fromEntries(Object.entries(G).map(([key, val]) => [key, new Set(val)]));
 }
 // Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}
 function check(G, n, path) {
     if (path.includes(n)) {
         const cycle = path.slice(path.indexOf(n)).concat(n);
@@ -39,6 +42,3 @@ function check(G, n, path) {
     }
     G[n]?.forEach((node) => check(G, node, [...path, n]));
 }
-function validate(G) {
-    Object.keys(G).forEach((n) => check(G, n, []));
-}

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

@@ -35,9 +35,9 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
 }
 exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
 function createHttpResponseObjectRedirect({ url, statusCode }, 
-// The URL pathname we assume the redirect to be logically based on
-urlPathnameLogical) {
-    (0, assertNoInfiniteHttpRedirect_js_1.assertNoInfiniteHttpRedirect)(url, urlPathnameLogical);
+// The URL we assume the redirect to be logically based on
+urlLogical) {
+    (0, assertNoInfiniteHttpRedirect_js_1.assertNoInfiniteHttpRedirect)(url, urlLogical);
     (0, utils_js_1.assert)(url);
     (0, utils_js_1.assert)(statusCode);
     (0, utils_js_1.assert)(300 <= statusCode && statusCode <= 399);

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

@@ -14,8 +14,7 @@ const assertHookReturnedObject_js_1 = require("../../../shared/assertHookReturne
 const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function executeOnRenderHtmlHook(pageContext) {
-    const hookFound = getRenderHook(pageContext);
-    const { renderHook, hookFn } = hookFound;
+    const { renderHook, hookFn } = getRenderHook(pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { _renderHook: renderHook });
     (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
     const hookReturnValue = await (0, utils_js_1.executeHook)(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);