vike 0.4.219 → 0.4.220-commit-9a798ce

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

@@ -65,6 +65,8 @@ const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
 const executeHook_js_1 = require("../../shared/hooks/executeHook.js");
 const getConfigValueBuildTime_js_1 = require("../../shared/page-configs/getConfigValueBuildTime.js");
 const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
+const context_js_1 = require("./context.js");
+const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -84,16 +86,20 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
 }
 async function runPrerenderFromAutoRun(viteConfig) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
+    return { prerenderContextPublic };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    (0, context_js_1.setContextIsPrerendering)();
     checkOutdatedOptions(options);
     (0, utils_js_1.onSetupPrerender)();
     (0, globalContext_js_1.setGlobalContext_isPrerendering)();
@@ -107,7 +113,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
     const { outDirClient } = (0, utils_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    const prerenderConfig = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfig)(vikeConfig.global.config.prerender);
     validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         (0, utils_js_1.assert)(standaloneTrigger);
@@ -120,43 +126,48 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     globalContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    (0, utils_js_1.objectAssign)(prerenderContext, {
-        _urlHandler: null,
-        _noExtraDir: noExtraDir ?? false,
+    const prerenderContext = {
+        noExtraDir: noExtraDir ?? false,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null
-    });
+        pageContextInit: options.pageContextInit ?? null,
+        prerenderedPageContexts: {},
+        output: []
+    };
     const doNotPrerenderList = [];
     await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext);
-    const prerenderedPageContexts = {};
     let prerenderedCount = 0;
+    // Write files as soon as pages finish rendering (instead of writing all files at once only after all pages have rendered).
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
         if (htmlFile.pageId) {
-            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+            prerenderContext.prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
         }
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
     await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
-    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, prerenderContext, onComplete);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
-    return { viteConfig };
+    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
-        const configValue = (0, getConfigValueBuildTime_js_1.getConfigValueBuildTime)(pageConfig, configName, 'boolean');
-        if (configValue?.value === false) {
-            const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData);
+        const configValue = (0, getConfigValueBuildTime_js_1.getConfigValueBuildTime)(pageConfig, configName);
+        if (!configValue)
+            return;
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(configValue, 'value', 'array'));
+        if (configValue.value[0] === false) {
+            (0, utils_js_1.assert)((0, utils_js_1.isArray)(configValue.definedAtData));
+            const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData[0]);
             (0, utils_js_1.assert)(configValueFilePathToShowToUser);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
@@ -339,7 +350,7 @@ function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -425,17 +436,20 @@ async function callOnPrerenderStartHook(prerenderContext) {
     const docLink = 'https://vike.dev/i18n#pre-rendering';
     // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
     const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
-    let result = await (0, executeHook_js_1.executeHook)(() => hookFn({
-        pageContexts: prerenderContext.pageContexts,
+    let result = await (0, executeHook_js_1.executeHook)(() => {
+        const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
-        get prerenderPageContexts() {
-            (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                showStackTrace: true,
-                onlyOnce: true
-            });
-            return prerenderContext.pageContexts;
-        }
-    }), onPrerenderStartHook, null);
+        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
+            get() {
+                (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+        return hookFn(prerenderContextPublic);
+    }, onPrerenderStartHook, null);
     restoreEnumerable();
     if (result === null || result === undefined) {
         return;
@@ -542,7 +556,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -577,8 +591,8 @@ function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial)
         (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#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(prerenderedPageContexts, prerenderContext, onComplete) {
-    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderContext, onComplete) {
+    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit);
@@ -601,22 +615,23 @@ async function prerender404(prerenderedPageContexts, prerenderContext, onComplet
         }
     }
 }
-async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
     (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
     let fileUrl;
-    if (fileExtension === '.html') {
+    if (fileType === 'HTML') {
         fileUrl = (0, utils_js_1.urlToFile)(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
+        (0, utils_js_1.assert)(fileType === 'JSON');
         fileUrl = (0, getPageContextRequestUrl_js_1.getPageContextRequestUrl)(urlOriginal);
     }
     (0, utils_js_1.assertPosixPath)(fileUrl);
@@ -628,6 +643,12 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    output.push({
+        filePath,
+        fileType,
+        fileContent,
+        pageContext
+    });
     if (onPagePrerender) {
         const prerenderPageContext = {};
         (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
@@ -796,3 +817,9 @@ prerenderConfig) {
         (0, utils_js_1.assertUsage)(false, `Setting ${picocolors_1.default.cyan(`prerender.${prop}`)} ${errMsg}`);
     }
 }
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

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

@@ -22,9 +22,9 @@ __exportStar(require("../../utils/projectInfo.js"), exports);
 __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("../plugin/getOutDirs.js"), exports);
 __exportStar(require("../../utils/isPropertyGetter.js"), exports);
-__exportStar(require("../../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../../utils/toPosixPath.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/isPlainObject.js"), exports);
 __exportStar(require("../../utils/assertSetup.js"), exports);
@@ -33,3 +33,4 @@ __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
+__exportStar(require("../../utils/makePublicCopy.js"), exports);

package/dist/cjs/node/runtime/globalContext.js

@@ -8,7 +8,6 @@ exports.getGlobalContextAsync = getGlobalContextAsync;
 exports.getGlobalContext = getGlobalContext;
 exports.getViteDevServer = getViteDevServer;
 exports.getViteConfig = getViteConfig;
-exports.getRuntimeManifest = getRuntimeManifest;
 exports.initGlobalContext_renderPage = initGlobalContext_renderPage;
 exports.initGlobalContext_runPrerender = initGlobalContext_runPrerender;
 exports.initGlobalContext_getGlobalContextAsync = initGlobalContext_getGlobalContextAsync;
@@ -19,14 +18,13 @@ exports.setGlobalContext_isViteDev = setGlobalContext_isViteDev;
 exports.setGlobalContext_isPrerendering = setGlobalContext_isPrerendering;
 exports.setGlobalContext_buildEntry = setGlobalContext_buildEntry;
 exports.clearGlobalContext = clearGlobalContext;
+exports.assertBuildInfo = assertBuildInfo;
+exports.getViteConfigRuntime = getViteConfigRuntime;
 const utils_js_1 = require("./utils.js");
 const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
 const virtualFileImportUserCode_js_1 = require("../shared/virtual-files/virtualFileImportUserCode.js");
 const getPageFiles_js_1 = require("../../shared/getPageFiles/getPageFiles.js");
-const assertPluginManifest_js_1 = require("../shared/assertPluginManifest.js");
-const assertRuntimeManifest_js_1 = require("../shared/assertRuntimeManifest.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const resolveBase_js_1 = require("../shared/resolveBase.js");
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
@@ -53,28 +51,8 @@ async function getGlobalContextAsync(isProduction) {
     return makePublic(globalContext);
 }
 function makePublic(globalContext) {
-    const globalContextPublic = {
-        // TODO/now: add viteConfig and vikeConfig
-        assetsManifest: globalContext.assetsManifest
-    };
-    // Add internals (and prepended _ prefix to their keys)
-    {
-        const publicKeys = Object.keys(globalContextPublic);
-        (0, utils_js_1.objectKeys)(globalContext)
-            .filter((key) => !publicKeys.includes(key))
-            .forEach((key) => {
-            const keyPublic = `_${key}`;
-            Object.defineProperty(globalContextPublic, keyPublic, {
-                enumerable: true,
-                get() {
-                    (0, utils_js_1.assertWarning)(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
-                        onlyOnce: true
-                    });
-                    return globalContext[key];
-                }
-            });
-        });
-    }
+    // TODO/now: add viteConfig and vikeConfig
+    const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', ['assetsManifest']);
     return globalContextPublic;
 }
 function setGlobalContext_viteDevServer(viteDevServer) {
@@ -164,7 +142,7 @@ async function initGlobalContext(isProduction) {
         (0, utils_js_1.assert)(viteDevServer);
         (0, utils_js_1.assert)(!isPrerendering);
         const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
+        const viteConfigRuntime = getViteConfigRuntime(viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
@@ -175,20 +153,14 @@ async function initGlobalContext(isProduction) {
                 global: globalConfig
             },
             ...userFiles,
-            baseServer: pluginManifest.baseServer,
-            baseAssets: pluginManifest.baseAssets,
-            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            trailingSlash: pluginManifest.trailingSlash,
-            disableUrlNormalization: pluginManifest.disableUrlNormalization
+            viteConfigRuntime
         };
     }
     else {
         const buildEntry = await getBuildEntry(globalObject.outDirRoot, isPrerendering);
-        const { assetsManifest, pluginManifest } = buildEntry;
+        const { assetsManifest, buildInfo } = buildEntry;
         (0, getPageFiles_js_1.setPageFiles)(buildEntry.pageFiles);
         const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        assertViteManifest(assetsManifest);
-        (0, assertPluginManifest_js_1.assertPluginManifest)(pluginManifest);
         const globalContext = {
             isProduction: true,
             assetsManifest,
@@ -197,12 +169,8 @@ async function initGlobalContext(isProduction) {
             },
             ...userFiles,
             viteDevServer: null,
-            baseServer: pluginManifest.baseServer,
-            baseAssets: pluginManifest.baseAssets,
-            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            trailingSlash: pluginManifest.trailingSlash,
-            usesClientRouter: pluginManifest.usesClientRouter,
-            disableUrlNormalization: pluginManifest.disableUrlNormalization
+            viteConfigRuntime: buildInfo.viteConfigRuntime,
+            usesClientRouter: buildInfo.usesClientRouter
         };
         if (isPrerendering) {
             (0, utils_js_1.assert)(viteConfig);
@@ -237,19 +205,6 @@ async function getPageRuntimeInfo(isProduction) {
     pageConfigs.length > 0, pageFilesAll);
     return { userFiles, globalConfig };
 }
-function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
-    const { includeAssetsImportedByServer, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
-    const { baseServer, baseAssets } = (0, resolveBase_js_1.resolveBaseFromResolvedConfig)(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
-    const manifest = {
-        baseServer,
-        baseAssets,
-        includeAssetsImportedByServer,
-        trailingSlash,
-        disableUrlNormalization
-    };
-    (0, assertRuntimeManifest_js_1.assertRuntimeManifest)(manifest);
-    return manifest;
-}
 function assertViteManifest(manifest) {
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -282,17 +237,48 @@ async function getBuildEntry(outDir, isPrerendering) {
         (0, utils_js_1.assert)(globalObject.buildEntry);
     }
     const { buildEntry } = globalObject;
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildEntry));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'pageFiles', 'object'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'assetsManifest', 'object'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'pluginManifest', 'object'));
+    assertBuildEntry(buildEntry);
     return buildEntry;
 }
 function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
+    assertBuildEntry(buildEntry);
     globalObject.buildEntry = buildEntry;
     globalObject.buildEntryPrevious = buildEntry;
 }
+function assertBuildEntry(buildEntry) {
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildEntry));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'pageFiles', 'object'));
+    const { pageFiles } = buildEntry;
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'assetsManifest', 'object'));
+    const { assetsManifest } = buildEntry;
+    assertViteManifest(assetsManifest);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'buildInfo', 'object'));
+    const { buildInfo } = buildEntry;
+    assertBuildInfo(buildInfo);
+    (0, utils_js_1.checkType)({ pageFiles, assetsManifest, buildInfo });
+}
+function assertBuildInfo(buildInfo) {
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildInfo));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'versionAtBuildTime', 'string'));
+    assertVersionAtBuildTime(buildInfo.versionAtBuildTime);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'viteConfigRuntime', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, '_baseViteOriginal', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'usesClientRouter', 'boolean'));
+    (0, utils_js_1.checkType)({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
+}
+function assertVersionAtBuildTime(versionAtBuildTime) {
+    const versionAtRuntime = utils_js_1.projectInfo.projectVersion;
+    const pretty = (version) => picocolors_1.default.bold(`vike@${version}`);
+    (0, utils_js_1.assertUsage)(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
+}
+function getViteConfigRuntime(viteConfig) {
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(viteConfig, '_baseViteOriginal', 'string'));
+    const viteConfigRuntime = {
+        _baseViteOriginal: viteConfig._baseViteOriginal
+    };
+    return viteConfigRuntime;
+}
 function initDevEntry() {
     (0, getPageFiles_js_1.setPageFilesAsync)(getPageFilesExports);
 }

package/dist/cjs/node/runtime/page-files/setup.js

@@ -1,3 +1,3 @@
 "use strict";
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 // This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

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

@@ -23,6 +23,7 @@ const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePa
 const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
+const resolveBase_js_1 = require("../../shared/resolveBase.js");
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -119,14 +120,16 @@ function getPageContextInitEnhanced(pageContextInit, { ssr: { urlRewrite, urlHan
 } } = {}) {
     (0, utils_js_1.assert)(pageContextInit.urlOriginal);
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const { baseServer, baseAssets } = (0, resolveBase_js_1.resolveBaseRuntime)();
     const pageContextInitEnhanced = {};
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
         // The following is defined on `pageContext` because we can eventually make these non-global
-        _baseServer: globalContext.baseServer,
-        _baseAssets: globalContext.baseAssets,
-        _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
+        _baseServer: baseServer,
+        _baseAssets: baseAssets,
+        // TODO/now: add meta.default
+        _includeAssetsImportedByServer: globalContext.vikeConfig.global.config.includeAssetsImportedByServer ?? true,
         // TODO: use GloablContext instead
         _pageFilesAll: globalContext.pageFilesAll,
         _pageConfigs: globalContext.pageConfigs,

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectsErrPrefix = void 0;
 exports.resolveRedirects = resolveRedirects;
 exports.resolveRouteStringRedirect = resolveRouteStringRedirect;
 const assertIsNotBrowser_js_1 = require("../../../utils/assertIsNotBrowser.js");
@@ -11,8 +12,8 @@ const resolveUrlPathname_js_1 = require("../../../shared/route/resolveUrlPathnam
 const resolveRouteString_js_1 = require("../../../shared/route/resolveRouteString.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
-// TODO/next-major-release: update
-const configSrc = '[vite.config.js > vike({ redirects })]';
+const redirectsErrPrefix = '[+redirects]';
+exports.redirectsErrPrefix = redirectsErrPrefix;
 function resolveRedirects(redirectsAll, urlPathname) {
     const redirects = merge(redirectsAll);
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
@@ -23,9 +24,9 @@ function resolveRedirects(redirectsAll, urlPathname) {
     return null;
 }
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
-    (0, resolveRouteString_js_1.assertRouteString)(urlSource, `${configSrc} Invalid`);
+    (0, resolveRouteString_js_1.assertRouteString)(urlSource, `${redirectsErrPrefix} Invalid`);
     // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-    (0, utils_js_1.assertUsageUrlRedirectTarget)(urlTarget, `${configSrc} The URL redirection target`, true);
+    (0, utils_js_1.assertUsageUrlRedirectTarget)(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
     assertParams(urlSource, urlTarget);
     const match = (0, resolveRouteString_js_1.resolveRouteString)(urlSource, urlPathname);
     if (!match)
@@ -41,7 +42,7 @@ function assertParams(urlSource, urlTarget) {
     routeSegments.forEach((routeSegment) => {
         if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
             const segments = urlSource.split('/');
-            (0, utils_js_1.assertUsage)(segments.includes(routeSegment), `${configSrc} The redirection source URL ${picocolors_1.default.string(urlSource)} is missing the URL parameter ${picocolors_1.default.string(routeSegment)} used by the redirection target URL ${picocolors_1.default.string(urlTarget)}`);
+            (0, utils_js_1.assertUsage)(segments.includes(routeSegment), `${redirectsErrPrefix} The redirection source URL ${picocolors_1.default.string(urlSource)} is missing the URL parameter ${picocolors_1.default.string(routeSegment)} used by the redirection target URL ${picocolors_1.default.string(urlTarget)}`);
         }
     });
 }

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

@@ -23,6 +23,7 @@ const error_page_js_1 = require("../../shared/error-page.js");
 const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
 const loadUserFilesServerSide_js_1 = require("./renderPage/loadUserFilesServerSide.js");
 const resolveRedirects_js_1 = require("./renderPage/resolveRedirects.js");
+const resolveBase_js_1 = require("../shared/resolveBase.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -342,14 +343,16 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.code('renderPage(pageContextInit)')} called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${picocolors_1.default.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${picocolors_1.default.cyan('createDevMiddleware()')} middleware is executed *before* the ${picocolors_1.default.cyan('renderPage()')} middleware, see ${picocolors_1.default.underline('https://vike.dev/renderPage')}`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization, baseServer } = (0, globalContext_js_1.getGlobalContext)();
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const { baseServer } = (0, resolveBase_js_1.resolveBaseRuntime)();
+    const { trailingSlash, disableUrlNormalization } = globalContext.vikeConfig.global.config;
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
     const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     if (isPageContextRequest)
         return null;
-    const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash, baseServer);
+    const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash ?? false, baseServer);
     if (!urlNormalized)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -360,7 +363,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 }
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
-    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, globalContext.baseServer);
+    const { baseServer } = (0, resolveBase_js_1.resolveBaseRuntime)();
+    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
@@ -391,8 +395,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         }
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
+        const { baseServer } = (0, resolveBase_js_1.resolveBaseRuntime)();
         if (!originChanged)
-            urlTarget = (0, utils_js_1.prependBase)(urlTarget, globalContext.baseServer);
+            urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
         (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
@@ -457,7 +462,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
     return { pageContextAbort };
 }
 function assertBaseUrl(pageContextInit) {
-    const { baseServer } = (0, globalContext_js_1.getGlobalContext)();
+    const { baseServer } = (0, resolveBase_js_1.resolveBaseRuntime)();
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     const { hasBaseServer } = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, baseServer);

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

@@ -41,8 +41,8 @@ __exportStar(require("../../utils/compareString.js"), exports);
 __exportStar(require("../../utils/isObjectWithKeys.js"), exports);
 __exportStar(require("../../utils/stringifyStringArray.js"), exports);
 __exportStar(require("../../utils/unique.js"), exports);
-__exportStar(require("../../utils/filesystemPathHandling.js"), exports);
-__exportStar(require("../../utils/getOutDirs.js"), exports);
+__exportStar(require("../../utils/toPosixPath.js"), exports);
+__exportStar(require("../plugin/getOutDirs.js"), exports);
 __exportStar(require("../../utils/capitalizeFirstLetter.js"), exports);
 __exportStar(require("../../utils/debugGlob.js"), exports);
 __exportStar(require("../../utils/isSameErrorMessage.js"), exports);
@@ -76,3 +76,4 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
+__exportStar(require("../../utils/makePublicCopy.js"), exports);

package/dist/cjs/node/shared/resolveBase.js

@@ -4,14 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveBase = resolveBase;
+exports.resolveBaseRuntime = resolveBaseRuntime;
 exports.resolveBaseFromResolvedConfig = resolveBaseFromResolvedConfig;
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const globalContext_js_1 = require("../runtime/globalContext.js");
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     let baseViteOriginal = config._baseViteOriginal;
     (0, utils_js_1.assert)(baseViteOriginal === null || typeof baseViteOriginal == 'string');
     return resolveBase(baseViteOriginal, baseServer, baseAssets);
 }
+function resolveBaseRuntime() {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
+    const baseServerUnresolved = globalContext.vikeConfig.global.config.baseServer ?? null;
+    const baseAssetsUnresolved = globalContext.vikeConfig.global.config.baseAssets ?? null;
+    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
+}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;

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

@@ -68,11 +68,11 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     (0, utils_js_1.assert)(!('default' in exports));
     (0, utils_js_1.assert)(!('default' in exportsAll));
     const pageContextExports = {
+        config: config,
         from,
         source,
         sources,
         // TODO/eventually: deprecate/remove every prop below
-        config,
         configEntries,
         exports,
         exportsAll,
@@ -156,7 +156,7 @@ function getPageConfigUserFriendlyNew(pageConfig) {
         });
     });
     return {
-        config,
+        config: config,
         configEntries,
         exportsAll,
         source,

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

@@ -9,7 +9,11 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const configValuesLoaded = await moduleExports;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!configValuesLoaded)
+        (0, utils_js_1.assert)(false, { moduleExports, configValuesLoaded, moduleId });
     const configValues = (0, parsePageConfigs_js_1.parseConfigValuesSerialized)(configValuesLoaded.configValuesSerialized);
     Object.assign(pageConfig.configValues, configValues);
     (0, utils_js_1.objectAssign)(pageConfig, { isAllLoaded: true });

package/dist/cjs/shared/utils.js

@@ -32,7 +32,7 @@ __exportStar(require("../utils/isPlainObject.js"), exports);
 __exportStar(require("../utils/compareString.js"), exports);
 __exportStar(require("../utils/isNotNullish.js"), exports);
 __exportStar(require("../utils/stringifyStringArray.js"), exports);
-__exportStar(require("../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../utils/toPosixPath.js"), exports);
 __exportStar(require("../utils/cast.js"), exports);
 __exportStar(require("../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../utils/isPromise.js"), exports);

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.219';
+exports.PROJECT_VERSION = '0.4.220-commit-9a798ce';