vike 0.4.223-commit-f1089b4 → 0.4.223-commit-33cc798

package/dist/cjs/node/plugin/shared/{viteIsSSR.js → isViteServerBuild.js}

@@ -1,25 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.viteIsSSR = viteIsSSR;
-exports.viteIsServerBuildEnvAny = viteIsServerBuildEnvAny;
-exports.viteIsSSR_options = viteIsSSR_options;
-exports.viteIsSSR_safe = viteIsSSR_safe;
+exports.isViteServerBuild = isViteServerBuild;
+exports.isViteClientBuild = isViteClientBuild;
+exports.isViteServerBuild_options = isViteServerBuild_options;
+exports.isViteServerBuild_safe = isViteServerBuild_safe;
+exports.isViteServerBuild_onlySsrEnv = isViteServerBuild_onlySsrEnv;
 const assert_js_1 = require("../../../utils/assert.js");
-// TODO/now: rename_full viteIsSSR isViteServerBuildEnvSsr
-function viteIsSSR(configGlobal, viteEnv) {
+function isViteServerBuild(configGlobal, viteEnv) {
     const configEnv = viteEnv?.config ?? configGlobal;
     return !!configEnv?.build?.ssr;
 }
-// All server-side environments: not only `ssr` but, for example, also `vercel_edge` and `vercel_node`.
-function viteIsServerBuildEnvAny(configGlobal, viteEnv) {
-    return viteEnv ? viteEnv.name === 'ssr' : viteIsSSR(configGlobal);
+// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
+function isViteServerBuild_onlySsrEnv(configGlobal, viteEnv) {
+    return viteEnv ? viteEnv.name === 'ssr' : isViteServerBuild(configGlobal);
 }
-function viteIsSSR_options(options) {
+function isViteClientBuild(configGlobal, viteEnv) {
+    const yes = !isViteServerBuild(configGlobal, viteEnv);
+    const isVite5 = viteEnv === undefined;
+    if (!isVite5) {
+        const yes2 = viteEnv.name === 'client';
+        (0, assert_js_1.assert)(yes === yes2);
+    }
+    return yes;
+}
+function isViteServerBuild_options(options) {
     return !!options?.ssr;
 }
 // Vite is quite messy about setting `ssr: boolean`, thus we use an extra safe implemention for security purposes.
 // It's used for .client.js and .server.js guarantee thus we use agressive assert() calls for added safety.
-function viteIsSSR_safe(config, options) {
+function isViteServerBuild_safe(config, options) {
     if (config.command === 'build') {
         (0, assert_js_1.assert)(typeof config.build.ssr === 'boolean');
         const val = config.build.ssr;

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.223-commit-f1089b4';
+exports.PROJECT_VERSION = '0.4.223-commit-33cc798';

package/dist/esm/node/plugin/plugins/build/handleAssetsManifest.d.ts

@@ -0,0 +1,18 @@
+export { handleAssetsManifest };
+export { handleAssetsManifest_getBuildConfig };
+export { handleAssetsManifest_isFixEnabled };
+export { handleAssetsManifest_assertUsageCssCodeSplit };
+export { handleAssetsManifest_assertUsageCssTarget };
+import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
+type Bundle = Rollup.OutputBundle;
+type Options = Rollup.NormalizedOutputOptions;
+declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
+declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
+declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig): void;
+declare function handleAssetsManifest_getBuildConfig(config: UserConfig): {
+    readonly ssrEmitAssets: true | undefined;
+    readonly cssMinify: "esbuild" | undefined;
+    readonly manifest: "_temp_manifest.json";
+    readonly copyPublicDir: boolean | undefined;
+};
+declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/build/{pluginAssetsManifest/fixServerAssets.js → handleAssetsManifest.js}

@@ -1,38 +1,29 @@
-// TODO/now: move this file
-// TODO/now: rename_full fixServerAssets handleAssetsManifest
 export { handleAssetsManifest };
-export { fixServerAssets_getBuildConfig };
-export { fixServerAssets_isEnabled };
-export { fixServerAssets_assertUsageCssCodeSplit };
-export { fixServerAssets_assertUsageCssTarget };
-export { writeManifestFile };
+export { handleAssetsManifest_getBuildConfig };
+export { handleAssetsManifest_isFixEnabled };
+export { handleAssetsManifest_assertUsageCssCodeSplit };
+export { handleAssetsManifest_assertUsageCssTarget };
 import fs from 'fs/promises';
 import fs_sync from 'fs';
 import path from 'path';
 import { existsSync } from 'fs';
-import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique } from '../../../utils.js';
-import { isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-import { manifestTempFile } from '../pluginBuildConfig.js';
-import { getAssetsDir } from '../../../shared/getAssetsDir.js';
+import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique } from '../../utils.js';
+import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { manifestTempFile } from './pluginBuildConfig.js';
+import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
-import { isV1Design } from '../../importUserCode/v1-design/getVikeConfig.js';
-import { getOutDirs } from '../../../shared/getOutDirs.js';
-import { viteIsServerBuildEnvAny, viteIsSSR } from '../../../shared/viteIsSSR.js';
-import { getVikeConfigPublic } from '../../commonConfig.js';
-import { set_macro_ASSETS_MANIFEST } from '../pluginBuildEntry.js';
+import { isV1Design } from '../importUserCode/v1-design/getVikeConfig.js';
+import { getOutDirs } from '../../shared/getOutDirs.js';
+import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
+import { getVikeConfigPublic } from '../commonConfig.js';
+import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
-// TODO/now move isV1Design() inside fixServerAssets_isEnabled()
-/**
- * true  => use workaround config.build.ssrEmitAssets
- * false => use workaround extractAssets plugin
- *
- * Only used by V1 design.
- */
-function fixServerAssets_isEnabled() {
-    // We currently apply the workaround iff V1 design.
-    // Shall we allow the user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
-    return true;
+// true  => use workaround config.build.ssrEmitAssets
+// false => use workaround extractAssets plugin
+function handleAssetsManifest_isFixEnabled(config) {
+    // Allow user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
+    return isV1Design(config);
 }
 /** https://github.com/vikejs/vike/issues/1339 */
 async function fixServerAssets(config) {
@@ -221,19 +212,16 @@ function getHash(src) {
     return hash;
 }
 // https://github.com/vikejs/vike/issues/1993
-function fixServerAssets_assertUsageCssCodeSplit(config) {
-    const isServerAssetsFixEnabled = fixServerAssets_isEnabled() && isV1Design(config);
-    if (!isServerAssetsFixEnabled)
+function handleAssetsManifest_assertUsageCssCodeSplit(config) {
+    if (!handleAssetsManifest_isFixEnabled(config))
         return;
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
 const targets = [];
-function fixServerAssets_assertUsageCssTarget(config) {
-    if (!fixServerAssets_isEnabled())
-        return;
-    if (!isV1Design(config))
+function handleAssetsManifest_assertUsageCssTarget(config) {
+    if (!handleAssetsManifest_isFixEnabled(config))
         return;
-    const isServerSide = viteIsSSR(config);
+    const isServerSide = isViteServerBuild(config);
     assert(typeof isServerSide === 'boolean');
     assert(config.build.target !== undefined);
     targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
@@ -292,39 +280,39 @@ async function writeManifestFile(manifest, manifestFilePath) {
     const manifestFileContent = JSON.stringify(manifest, null, 2);
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
-function fixServerAssets_getBuildConfig(config) {
+function handleAssetsManifest_getBuildConfig(config) {
     const vike = getVikeConfigPublic(config);
-    const isServerAssetsFixEnabled = fixServerAssets_isEnabled() && isV1Design(config);
+    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     return {
         // https://github.com/vikejs/vike/issues/1339
-        ssrEmitAssets: isServerAssetsFixEnabled ? true : undefined,
+        ssrEmitAssets: isFixEnabled ? true : undefined,
         // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
-        cssMinify: isServerAssetsFixEnabled ? 'esbuild' : undefined,
+        cssMinify: isFixEnabled ? 'esbuild' : undefined,
         manifest: manifestTempFile,
         copyPublicDir: vike.config.viteEnvironmentAPI
             ? // Already set by vike:build:pluginBuildApp
                 undefined
-            : !viteIsSSR(config)
+            : !isViteServerBuild(config)
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
-    if (viteIsSSR(config, viteEnv)) {
+    if (isViteServerBuild_onlySsrEnv(config, viteEnv)) {
         assert(!assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
         await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
     }
-    if (viteIsServerBuildEnvAny(config, viteEnv)) {
+    if (isViteServerBuild(config, viteEnv)) {
         assert(assetsJsonFilePath);
         // Replace __VITE_ASSETS_MANIFEST__ in all server-side bundles
         await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
     }
 }
 async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
-    const isServerAssetsFixEnabled = fixServerAssets_isEnabled() && isV1Design(config);
+    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
     const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
-    if (!isServerAssetsFixEnabled) {
+    if (!isFixEnabled) {
         await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
     }
     else {

package/dist/esm/node/plugin/plugins/build/pluginAutoFullBuild.d.ts

@@ -1,3 +1,5 @@
 export { pluginAutoFullBuild };
+export { isPrerenderForceExit };
 import type { Plugin } from 'vite';
 declare function pluginAutoFullBuild(): Plugin[];
+declare function isPrerenderForceExit(): boolean;

package/dist/esm/node/plugin/plugins/build/pluginAutoFullBuild.js

@@ -1,7 +1,8 @@
 export { pluginAutoFullBuild };
+export { isPrerenderForceExit };
 import { getFullBuildInlineConfig } from '../../shared/getFullBuildInlineConfig.js';
 import { build } from 'vite';
-import { assert, assertWarning } from '../../utils.js';
+import { assert, assertIsSingleModuleInstance, assertWarning } from '../../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../../prerender/runPrerender.js';
 import { isPrerenderAutoRunEnabled } from '../../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
@@ -10,7 +11,9 @@ import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
 import { manifestTempFile } from './pluginBuildConfig.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { isVikeCliOrApi } from '../../../api/context.js';
-import { handleAssetsManifest } from './pluginAssetsManifest/fixServerAssets.js';
+import { handleAssetsManifest } from './handleAssetsManifest.js';
+import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/isViteServerBuild.js';
+assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
     let config;
@@ -32,7 +35,7 @@ function pluginAutoFullBuild() {
                 */
                 async handler(options, bundle) {
                     await handleAssetsManifest(config, this.environment, options, bundle);
-                    await triggerFullBuild(config, vikeConfig, bundle);
+                    await triggerFullBuild(config, vikeConfig, this.environment, bundle);
                 }
             }
         },
@@ -44,7 +47,9 @@ function pluginAutoFullBuild() {
                 sequential: true,
                 order: 'post',
                 handler() {
-                    if (forceExit) {
+                    if (forceExit &&
+                        // Let vike:build:pluginBuildApp force exit
+                        !vikeConfig.global.config.viteEnvironmentAPI) {
                         runPrerender_forceExit();
                         assert(false);
                     }
@@ -53,10 +58,14 @@ function pluginAutoFullBuild() {
         }
     ];
 }
-async function triggerFullBuild(config, vikeConfig, bundle) {
-    if (config.build.ssr)
-        return; // already triggered
-    if (isDisabled(vikeConfig))
+async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
+    // Whether `builder.buildApp()` is being used, see plugin:build:pluginBuildApp
+    const isBuilderApp = vikeConfig.global.config.viteEnvironmentAPI;
+    // if builder.buildApp() => trigger at end of `this.environment.name === 'ssr'`.
+    // else => trigger at end of client-side build.
+    if (isBuilderApp ? !isViteServerBuild_onlySsrEnv(config, viteEnv) : !isViteClientBuild(config, viteEnv))
+        return;
+    if (isEntirelyDisabled(vikeConfig))
         return;
     // Workaround for @vitejs/plugin-legacy
     //  - The legacy plugin triggers its own Rollup build for the client-side.
@@ -65,14 +74,18 @@ async function triggerFullBuild(config, vikeConfig, bundle) {
     if (!bundle[manifestTempFile])
         return;
     const configInline = getFullBuildInlineConfig(config);
-    try {
-        await build(setSSR(configInline));
-    }
-    catch (err) {
-        // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
-        console.error(err);
-        logErrorHint(err);
-        process.exit(1);
+    if (
+    // Already chained by builder.buildApp()
+    !isBuilderApp) {
+        try {
+            await build(setSSR(configInline));
+        }
+        catch (err) {
+            // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+            console.error(err);
+            logErrorHint(err);
+            process.exit(1);
+        }
     }
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
         const res = await runPrerenderFromAutoRun(configInline, config);
@@ -94,16 +107,16 @@ function abortViteBuildSsr(vikeConfig) {
         process.exit(0);
     }
 }
-function isDisabled(vikeConfig) {
-    const { disableAutoFullBuild, viteEnvironmentAPI } = vikeConfig.global.config;
-    if (viteEnvironmentAPI) {
-        return true;
-    }
+function isEntirelyDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.global.config;
     if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
-        const isViteApi = !isViteCliCall() && !isVikeCliOrApi();
-        return isViteApi;
+        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isUserUsingViteApi;
     }
     else {
         return disableAutoFullBuild;
     }
 }
+function isPrerenderForceExit() {
+    return forceExit;
+}

package/dist/esm/node/plugin/plugins/build/pluginBuildApp.js

@@ -1,16 +1,10 @@
 export { pluginBuildApp };
-import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../../prerender/runPrerender.js';
-import { isPrerenderAutoRunEnabled } from '../../../prerender/context.js';
+import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
-import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getFullBuildInlineConfig } from '../../shared/getFullBuildInlineConfig.js';
 import { getVikeConfigPublic } from '../commonConfig.js';
+import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
 function pluginBuildApp() {
-    let config;
-    // `builder.buildApp()` can be overriden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
-    // In that case, we shouldn't `forceExit`.
-    let forceExit = false;
     return [
         {
             name: 'vike:build:pluginBuildApp',
@@ -21,12 +15,13 @@ function pluginBuildApp() {
                     return;
                 return {
                     builder: {
-                        buildApp: async (builder) => {
+                        // Can be overriden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
+                        async buildApp(builder) {
                             assert(builder.environments.client);
                             assert(builder.environments.ssr);
                             await builder.build(builder.environments.client);
                             await builder.build(builder.environments.ssr);
-                            if (forceExit) {
+                            if (isPrerenderForceExit()) {
                                 runPrerender_forceExit();
                                 assert(false);
                             }
@@ -50,28 +45,6 @@ function pluginBuildApp() {
                     }
                 };
             }
-        },
-        {
-            name: 'vike:build:pluginBuildApp:prerender',
-            apply: 'build',
-            enforce: 'pre',
-            applyToEnvironment(env) {
-                return env.name === 'ssr';
-            },
-            configResolved(_config) {
-                config = _config;
-            },
-            async writeBundle() {
-                const vike = getVikeConfigPublic(config);
-                if (!vike.config.viteEnvironmentAPI)
-                    return;
-                const vikeConfig = await getVikeConfig(config);
-                if (!isPrerenderAutoRunEnabled(vikeConfig))
-                    return;
-                const configInline = getFullBuildInlineConfig(config);
-                const res = await runPrerenderFromAutoRun(configInline, config);
-                forceExit = res.forceExit;
-            }
         }
     ];
 }

package/dist/esm/node/plugin/plugins/build/pluginBuildConfig.js

@@ -11,9 +11,9 @@ import { createRequire } from 'module';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { viteIsSSR } from '../../shared/viteIsSSR.js';
+import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
-import { fixServerAssets_assertUsageCssCodeSplit, fixServerAssets_assertUsageCssTarget, fixServerAssets_getBuildConfig } from './pluginAssetsManifest/fixServerAssets.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_assertUsageCssTarget, handleAssetsManifest_getBuildConfig } from './handleAssetsManifest.js';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
@@ -35,7 +35,7 @@ function pluginBuildConfig() {
                     assert(Object.keys(entries).length > 0);
                     config.build.rollupOptions.input = injectRollupInputs(entries, config);
                     addLogHook();
-                    fixServerAssets_assertUsageCssCodeSplit(config);
+                    handleAssetsManifest_assertUsageCssCodeSplit(config);
                 }
             },
             config: {
@@ -45,7 +45,7 @@ function pluginBuildConfig() {
                     return {
                         build: {
                             outDir: resolveOutDir(config),
-                            ...fixServerAssets_getBuildConfig(config)
+                            ...handleAssetsManifest_getBuildConfig(config)
                         }
                     };
                 }
@@ -55,7 +55,7 @@ function pluginBuildConfig() {
             },
             closeBundle() {
                 onSetupBuild();
-                fixServerAssets_assertUsageCssTarget(config);
+                handleAssetsManifest_assertUsageCssTarget(config);
             }
         }
     ];
@@ -68,7 +68,7 @@ async function getEntries(config) {
     // TODO/now: add meta.default
     vikeConfig.global.config.includeAssetsImportedByServer ?? true);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
-    if (viteIsSSR(config)) {
+    if (isViteServerBuild(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
@@ -141,7 +141,7 @@ function analyzeClientEntries(pageConfigs, config) {
 // Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
 // (Otherwise the page files may be missing in the client manifest.json)
 async function getPageFileEntries(config, includeAssetsImportedByServer) {
-    const isForClientSide = !viteIsSSR(config);
+    const isForClientSide = !isViteServerBuild(config);
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');

package/dist/esm/node/plugin/plugins/build/pluginBuildEntry.d.ts

@@ -4,5 +4,4 @@ import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
 declare function pluginBuildEntry(): Plugin[];
-/** Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js) */
 declare function set_macro_ASSETS_MANIFEST(options: Options, bundle: Bundle, assetsJsonFilePath: string): Promise<void>;

package/dist/esm/node/plugin/plugins/build/pluginBuildEntry.js

@@ -59,7 +59,7 @@ function getServerProductionEntryCode(config) {
     ].join('\n');
     return importerCode;
 }
-/** Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js) */
+// Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js)
 async function set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath) {
     const { dir } = options;
     assert(dir);

package/dist/esm/node/plugin/plugins/build/pluginDistFileNames.js

@@ -28,7 +28,7 @@ function pluginDistFileNames() {
                 else {
                     // If a user needs this:
                     //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
-                    //    - It's needed for getHash() of fixServerAssets()
+                    //    - It's needed for getHash() of handleAssetsManifest()
                     //    - Asset URLs should always contain a hash: it's paramount for caching assets.
                     //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
                     assertUsage(false, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use.");

package/dist/esm/node/plugin/plugins/build/pluginDistPackageJsonFile.js

@@ -9,7 +9,7 @@
 // TODO/refactor: prefix all other plugins with `plugin` as well?
 export { pluginDistPackageJsonFile };
 import { rollupIsEsm } from '../../shared/rollupIsEsm.js';
-import { viteIsSSR } from '../../shared/viteIsSSR.js';
+import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 function pluginDistPackageJsonFile() {
     let config;
     return {
@@ -19,7 +19,7 @@ function pluginDistPackageJsonFile() {
             config = config_;
         },
         generateBundle(options, bundle) {
-            if (!viteIsSSR(config))
+            if (!isViteServerBuild(config))
                 return;
             const isEsm = rollupIsEsm(options);
             const fileName = 'package.json';

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

@@ -4,7 +4,7 @@ import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArr
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { viteIsSSR_safe } from '../shared/viteIsSSR.js';
+import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
 // TODO/enventually: (after we implemented vike.config.js)
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -37,7 +37,7 @@ function envVarsPlugin() {
             if (!code.includes('import.meta.env.'))
                 return;
             const isBuild = config.command === 'build';
-            const isClientSide = !viteIsSSR_safe(config, options);
+            const isClientSide = !isViteServerBuild_safe(config, options);
             Object.entries(envsAll)
                 .filter(([key]) => {
                 // Already handled by Vite

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

@@ -13,11 +13,11 @@ import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import pc from '@brillout/picocolors';
-import { fixServerAssets_isEnabled } from './build/pluginAssetsManifest/fixServerAssets.js';
-import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
+import { handleAssetsManifest_isFixEnabled } from './build/handleAssetsManifest.js';
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { viteIsSSR_safe } from '../shared/viteIsSSR.js';
+import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -26,7 +26,7 @@ const debug = createDebugger('vike:extractAssets');
 function extractAssetsPlugin() {
     let config;
     let vikeConfig;
-    let isServerAssetsFixEnabled;
+    let isFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
         {
@@ -39,14 +39,14 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }
-                if (isServerAssetsFixEnabled) {
-                    // I'm guessing isServerAssetsFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
+                if (isFixEnabled) {
+                    // I'm guessing isFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
                     assertV1Design(vikeConfig.pageConfigs, true);
                     assert(false);
                 }
                 // TODO/now: add meta.default
                 assert(vikeConfig.global.config.includeAssetsImportedByServer ?? true);
-                assert(!viteIsSSR_safe(config, options));
+                assert(!isViteServerBuild_safe(config, options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
@@ -63,7 +63,7 @@ function extractAssetsPlugin() {
             //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
             enforce: 'pre',
             async resolveId(source, importer, options) {
-                if (viteIsSSR_safe(config, options)) {
+                if (isViteServerBuild_safe(config, options)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
                     assert(importer === undefined || !extractAssetsRE.test(importer));
@@ -140,8 +140,8 @@ function extractAssetsPlugin() {
             async configResolved(config_) {
                 config = config_;
                 vikeConfig = await getVikeConfig(config);
-                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config));
-                if (!isServerAssetsFixEnabled) {
+                isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+                if (!isFixEnabled) {
                     // https://github.com/vikejs/vike/issues/1060
                     assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
                 }

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

@@ -5,7 +5,7 @@ import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage
 import { getExportNames } from '../shared/parseEsModule.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { viteIsSSR_options } from '../shared/viteIsSSR.js';
+import { isViteServerBuild_options } from '../shared/isViteServerBuild.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebugger('vike:extractExportNames');
 const globalObject = getGlobalObject('plugins/extractExportNamesPlugin.ts', {});
@@ -16,7 +16,7 @@ function extractExportNamesPlugin() {
         enforce: 'post',
         async transform(src, id, options) {
             id = normalizeId(id);
-            const isClientSide = !viteIsSSR_options(options);
+            const isClientSide = !isViteServerBuild_options(options);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
                 debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);

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

@@ -7,12 +7,12 @@ import path from 'path';
 import { getVirtualFilePageConfigs } from './v1-design/virtual-files/getVirtualFilePageConfigs.js';
 import { isV1Design as isV1Design_ } from './v1-design/getVikeConfig.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { viteIsSSR_options } from '../../shared/viteIsSSR.js';
+import { isViteServerBuild_options } from '../../shared/isViteServerBuild.js';
 async function getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
     const { isForClientSide, isClientRouting } = idParsed;
-    assert(isForClientSide === !viteIsSSR_options(options));
+    assert(isForClientSide === !isViteServerBuild_options(options));
     const code = await getCode(config, vikeConfig, isForClientSide, isClientRouting, isDev, id);
     return code;
 }
@@ -69,7 +69,7 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
 
 `;
     // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
-    const isV1Design = await isV1Design_(config);
+    const isV1Design = isV1Design_(config);
     // Old design => no + files => only to enable pre-rendering is setting `vike({prerender})` in vite.config.js
     const isPrerendering = !!vikeConfig.global.config.prerender;
     fileTypes

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

@@ -21,11 +21,8 @@ function importUserCode() {
             vikeConfig = await getVikeConfig(config_);
             config = config_;
             // TODO/v1-release: remove
-            {
-                const isV1 = await isV1Design(config);
-                if (!isV1)
-                    config.experimental.importGlobRestoreExtension = true;
-            }
+            if (!isV1Design(config))
+                config.experimental.importGlobRestoreExtension = true;
         },
         resolveId(id) {
             if (isVirtualFileId(id)) {

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

@@ -85,7 +85,6 @@ async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doN
     }
     return await vikeConfigPromise;
 }
-// TODO/now update all isV1Design() usage
 function isV1Design(config) {
     const vikeConfig = config._vikeConfigObject;
     assert(vikeConfig);