vike 0.4.226 → 0.4.227-commit-c9cc081

package/dist/esm/node/plugin/plugins/fileEnv.js

@@ -1,3 +1,4 @@
+import { getResolvedConfig } from '../shared/getResolvedConfig.js';
 export { fileEnv };
 import { assert, assertUsage, assertWarning, capitalizeFirstLetter, joinEnglish } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
@@ -7,16 +8,20 @@ import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
+import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 function fileEnv() {
-    let config;
+    let vite5Config;
     let viteDevServer;
     return {
         name: 'vike:fileEnv',
         load(id, options) {
+            const config = getResolvedConfig(this.environment?.config, vite5Config);
             // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
             if (!viteDevServer)
                 return;
-            if (skip(id))
+            if (!isV1Design(config))
+                return;
+            if (skip(config, id))
                 return;
             // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
             if (id.endsWith('?direct'))
@@ -26,24 +31,25 @@ function fileEnv() {
             const importers = Array.from(moduleInfo.importers)
                 .map((m) => m.id)
                 .filter((id) => id !== null);
-            assertFileEnv(id, !!options?.ssr, importers, 
+            assertFileEnv(config, id, !!options?.ssr, importers, 
             // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
             true);
         },
         // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
         async transform(code, id, options) {
+            const config = getResolvedConfig(this.environment?.config, vite5Config);
             id = normalizeId(id);
             // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
             if (viteDevServer)
                 return;
-            if (skip(id))
+            if (skip(config, id))
                 return;
             const isServerSide = !!options?.ssr;
             if (!isWrongEnv(id, isServerSide))
                 return;
             const { importers } = this.getModuleInfo(id);
             // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code splitted.
-            const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+            const errMsg = getErrorMessage(config, id, isServerSide, importers, false, true);
             // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
             const { exportNames } = await getExportNames(code);
             return sourceMapRemove([
@@ -52,8 +58,9 @@ function fileEnv() {
             ].join('\n'));
         },
         generateBundle() {
+            const config = getResolvedConfig(this.environment?.config, vite5Config);
             Array.from(this.getModuleIds())
-                .filter((id) => !skip(id))
+                .filter((id) => !skip(config, id))
                 .forEach((moduleId) => {
                 const mod = this.getModuleInfo(moduleId);
                 const { importers } = mod;
@@ -64,20 +71,20 @@ function fileEnv() {
                     */
                     return;
                 }
-                assertFileEnv(moduleId, !!config.build.ssr, importers, false);
+                assertFileEnv(config, moduleId, !!config.build.ssr, importers, false);
             });
         },
         configResolved(config_) {
-            config = config_;
+            vite5Config = config_;
         },
         configureServer(viteDevServer_) {
             viteDevServer = viteDevServer_;
         }
     };
-    function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
+    function assertFileEnv(config, moduleId, isServerSide, importers, onlyWarn) {
         if (!isWrongEnv(moduleId, isServerSide))
             return;
-        const errMsg = getErrorMessage(moduleId, isServerSide, importers, onlyWarn, false);
+        const errMsg = getErrorMessage(config, moduleId, isServerSide, importers, onlyWarn, false);
         if (onlyWarn) {
             assertWarning(false, errMsg, { onlyOnce: true });
         }
@@ -85,7 +92,7 @@ function fileEnv() {
             assertUsage(false, errMsg);
         }
     }
-    function getErrorMessage(moduleId, isServerSide, importers, onlyWarn, noColor) {
+    function getErrorMessage(config, moduleId, isServerSide, importers, onlyWarn, noColor) {
         const modulePath = getModulePath(moduleId);
         const envActual = isServerSide ? 'server' : 'client';
         const envExpect = isServerSide ? 'client' : 'server';
@@ -110,7 +117,7 @@ function fileEnv() {
         const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
         return modulePath.includes(suffixWrong);
     }
-    function skip(id) {
+    function skip(config, id) {
         // TODO/v1-release: remove
         if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
             return true;

package/dist/esm/node/plugin/plugins/importUserCode/index.js

@@ -1,3 +1,4 @@
+import { getResolvedConfig } from '../../shared/getResolvedConfig.js';
 export { importUserCode };
 import { normalizePath } from 'vite';
 import { getVirtualFilePageConfigValuesAll } from './v1-design/virtual-files/getVirtualFilePageConfigValuesAll.js';
@@ -13,16 +14,16 @@ import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
 import { updateUserFiles } from '../../../runtime/globalContext.js';
 import { isPlusFile } from './v1-design/getVikeConfig/crawlPlusFiles.js';
 function importUserCode() {
-    let config;
+    let vite5Config;
     let vikeConfig;
     return {
         name: 'vike:importUserCode',
         async configResolved(config_) {
             vikeConfig = await getVikeConfig(config_);
-            config = config_;
+            vite5Config = config_;
             // TODO/v1-release: remove
-            if (!isV1Design(config))
-                config.experimental.importGlobRestoreExtension = true;
+            if (!isV1Design(vite5Config))
+                vite5Config.experimental.importGlobRestoreExtension = true;
         },
         resolveId(id) {
             if (isVirtualFileId(id)) {
@@ -31,7 +32,7 @@ function importUserCode() {
         },
         async handleHotUpdate(ctx) {
             try {
-                return await handleHotUpdate(ctx, config);
+                return await handleHotUpdate(ctx, vite5Config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -40,6 +41,7 @@ function importUserCode() {
             }
         },
         async load(id, options) {
+            const config = getResolvedConfig(this.environment?.config, vite5Config);
             if (!isVirtualFileId(id))
                 return undefined;
             id = getVirtualFileId(id);
@@ -55,7 +57,7 @@ function importUserCode() {
             }
         },
         configureServer(server) {
-            handleFileAddRemove(server, config);
+            handleFileAddRemove(server, vite5Config);
         }
     };
 }

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

@@ -896,7 +896,7 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
     if (configNamesKnownAll.includes(configName)) {
         assertUsage(false, `${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`, { exitOnError });
     }
-    const errMsg = `${sourceName} sets an unknown config ${configNameColored}`;
+    const errMsg = `${sourceName} sets an unknown Vike config, see ${pc.underline('https://vike.dev/cli')} for the list of CLI options.`;
     // Missing vike-{react,vue,solid} installation
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];

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

@@ -33,20 +33,24 @@ function previewConfig() {
             config.appType = 'mpa'
             */
             return () => {
-                assertDist();
+                const prerenderConfigGlobal = resolvePrerenderConfigGlobal(config._vikeConfigObject);
+                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = prerenderConfigGlobal;
+                assertDist(isPrerenderingEnabledForAllPages);
                 // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
                 addStaticAssetsMiddleware(server.middlewares);
-                const prerenderConfigGlobal = resolvePrerenderConfigGlobal(config._vikeConfigObject);
-                if (!prerenderConfigGlobal.isPrerenderingEnabledForAllPages) {
-                    addSsrMiddleware(server.middlewares, config, true, prerenderConfigGlobal.isPrerenderingEnabled);
+                if (!isPrerenderingEnabledForAllPages) {
+                    addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
                 }
                 addStatic404Middleware(server.middlewares);
             };
         }
     };
-    function assertDist() {
+    function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
-        [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
+        const dirS = [outDirRoot, outDirClient];
+        if (!isPrerenderingEnabledForAllPages)
+            dirS.push(outDirServer);
+        dirS.forEach((outDirAny) => {
             assertUsage(fs.existsSync(outDirAny), `Cannot run ${pc.cyan('$ vike preview')}: your app isn't built (the build directory ${pc.cyan(outDirAny)} is missing). Make sure to run ${pc.cyan('$ vike build')} before running ${pc.cyan('$ vike preview')}.`);
         });
     }

package/dist/esm/node/plugin/shared/getResolvedConfig.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedConfig } from 'vite';
+export declare function getResolvedConfig(vite6Config: ResolvedConfig | undefined, vite5Config: ResolvedConfig): ResolvedConfig;

package/dist/esm/node/plugin/shared/getResolvedConfig.js

@@ -0,0 +1,3 @@
+export function getResolvedConfig(vite6Config, vite5Config) {
+    return vite6Config ?? vite5Config;
+}

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -5,6 +5,7 @@ import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.j
 declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
     partial: boolean;
     noExtraDir: boolean;
+    keepDistServer: boolean;
     parallel: number | boolean;
     disableAutoRun: boolean;
 } & {

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -10,6 +10,7 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderConfigGlobal = {
         partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
         noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        keepDistServer: pickFirst(prerenderSettings.map((c) => c.keepDistServer)) ?? false,
         parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
         disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
     };

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -46,7 +46,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, config: ResolvedConfig): Promise<{
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
     forceExit: boolean;
 }>;
 declare function runPrerender_forceExit(): void;

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

@@ -31,6 +31,7 @@ import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
 import { getVikeConfigPublic } from '../plugin/plugins/commonConfig.js';
+import fs from 'node:fs';
 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.
@@ -50,11 +51,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
     assert(false);
 }
-async function runPrerenderFromAutoRun(viteConfig, config) {
-    let prerenderContextPublic;
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
-        const ret = await runPrerender({ viteConfig });
-        prerenderContextPublic = ret.prerenderContextPublic;
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -62,8 +61,6 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         logErrorHint(err);
         process.exit(1);
     }
-    const vike = getVikeConfigPublic(config);
-    vike.prerenderContext = prerenderContextPublic;
     const forceExit = isVikeCli() || isViteCliCall();
     return { forceExit };
 }
@@ -80,7 +77,9 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
-    const { outDirClient } = getOutDirs(viteConfig);
+    const vike = getVikeConfigPublic(viteConfig);
+    assert(vike.prerenderContext.isPrerenderingEnabled);
+    const { outDirClient, outDirServer } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
     validatePrerenderConfig(prerenderConfigGlobal);
@@ -123,7 +122,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
-    return { viteConfig, prerenderContextPublic };
+    objectAssign(vike.prerenderContext, prerenderContextPublic);
+    if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
+        fs.rmSync(outDirServer, { recursive: true });
+    }
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
@@ -592,6 +595,12 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);
+    objectAssign(pageContext, {
+        _prerenderResult: {
+            filePath,
+            fileContent
+        }
+    });
     output.push({
         filePath,
         fileType,
@@ -599,15 +608,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
         pageContext
     });
     if (onPagePrerender) {
-        const prerenderPageContext = {};
-        objectAssign(prerenderPageContext, pageContext);
-        objectAssign(prerenderPageContext, {
-            _prerenderResult: {
-                filePath,
-                fileContent
-            }
-        });
-        await onPagePrerender(prerenderPageContext);
+        await onPagePrerender(pageContext);
     }
     else {
         const { promises } = await import('fs');

package/dist/esm/shared/page-configs/Config.d.ts

@@ -308,6 +308,16 @@ type ConfigBuiltIn = {
          * @default true
          */
         enable?: boolean | null;
+        /**
+         * If you pre-render all your pages then Vike removes the `dist/server/` directory after pre-rendering has finished.
+         *
+         * If you set this setting to `true` then Vike won't remove the `dist/server/` directory.
+         *
+         * https://vike.dev/prerender#keepDistServer
+         *
+         * @default false
+         */
+        keepDistServer?: boolean;
     };
     /**
      * Install Vike extensions.

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.226";
+export declare const PROJECT_VERSION: "0.4.227-commit-c9cc081";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.226';
+export const PROJECT_VERSION = '0.4.227-commit-c9cc081';

package/dist/esm/utils/assert.js

@@ -93,12 +93,9 @@ function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
     if (onlyOnce) {
         const { alreadyLogged } = globalObject;
         const key = onlyOnce === true ? msg : onlyOnce;
-        if (alreadyLogged.has(key)) {
+        if (alreadyLogged.has(key))
             return;
-        }
-        else {
-            alreadyLogged.add(key);
-        }
+        alreadyLogged.add(key);
     }
     globalObject.onBeforeLog?.();
     if (showStackTrace) {

package/dist/esm/utils/assertSingleInstance.js

@@ -11,13 +11,24 @@ import { PROJECT_VERSION } from './PROJECT_VERSION.js';
 /* Use original assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertWarning } from './assert.js'
 */
-const globalObject = getGlobalObject('utils/assertSingleInstance.ts', {
-    instances: [],
-    alreadyLogged: new Set()
-});
+let globalObject;
+// getGlobalObjectSafe() can be called before this line
+globalObject ?? (globalObject = genGlobalConfig());
+function genGlobalConfig() {
+    return getGlobalObject('utils/assertSingleInstance.ts', {
+        instances: [],
+        alreadyLogged: new Set()
+    });
+}
+// We need getGlobalObjectSafe() because globalObject is `undefined` when exported functions are called before globalObject is initialized
+function getGlobalObjectSafe() {
+    globalObject ?? (globalObject = genGlobalConfig());
+    return globalObject;
+}
 const clientRuntimesClonflict = 'Client runtime of both Server Routing and Client Routing loaded https://vike.dev/client-runtimes-conflict';
 const clientNotSingleInstance = 'Client runtime loaded twice https://vike.dev/client-runtime-duplicated';
 function assertSingleInstance() {
+    const globalObject = getGlobalObjectSafe();
     {
         const versions = unique(globalObject.instances);
         assertWarning(versions.length <= 1, 
@@ -34,6 +45,7 @@ function assertSingleInstance() {
     }
 }
 function assertSingleInstance_onClientEntryServerRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== true, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -48,6 +60,7 @@ function assertSingleInstance_onClientEntryServerRouting(isProduction) {
     assertSingleInstance();
 }
 function assertSingleInstance_onClientEntryClientRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== false, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -63,10 +76,12 @@ function assertSingleInstance_onClientEntryClientRouting(isProduction) {
 }
 // Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
 function assertSingleInstance_onAssertModuleLoad() {
+    const globalObject = getGlobalObjectSafe();
     globalObject.instances.push(PROJECT_VERSION);
     assertSingleInstance();
 }
 function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    const globalObject = getGlobalObjectSafe();
     if (condition) {
         return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.226",
+  "version": "0.4.227-commit-c9cc081",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -129,6 +129,7 @@
     "es-module-lexer": "^1.0.0",
     "esbuild": "^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0",
     "json5": "^2.0.0",
+    "magic-string": "^0.30.17",
     "picomatch": "^4.0.2",
     "semver": "^7.0.0",
     "sirv": "^3.0.1",