vike 0.4.236-commit-eab75f6 → 0.4.237-commit-85e89b1

package/dist/esm/node/vite/plugins/pluginBuild/pluginAutoFullBuild.js

@@ -55,7 +55,7 @@ function pluginAutoFullBuild() {
                 order: 'post',
                 async handler() {
                     onSetupBuild();
-                    handleAssetsManifest_assertUsageCssTarget(config);
+                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
                     const vikeConfig = await getVikeConfigInternal();
                     if (forceExit &&
                         // Let vike:build:pluginBuildApp force exit

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildApp.js

@@ -53,6 +53,7 @@ function pluginBuildApp() {
                         client: {
                             consumer: 'client',
                             build: {
+                                outDir: resolveOutDir(config, false),
                                 copyPublicDir: true,
                                 ssr: false,
                             },

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -4,17 +4,18 @@ export { analyzeClientEntries };
 import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { getVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { resolveOutDir } from '../../shared/getOutDirs.js';
+import { isViteServerBuild_withoutEnv } from '../../shared/isViteServerBuild.js';
+import { resolveOutDir_configEnvironment } from '../../shared/getOutDirs.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 function pluginBuildConfig() {
     let config;
+    let configUnresolved;
     return [
         {
             name: 'vike:build:pluginBuildConfig',
@@ -33,18 +34,26 @@ function pluginBuildConfig() {
                     handleAssetsManifest_assertUsageCssCodeSplit(config);
                 },
             },
-            config: {
+            configEnvironment: {
                 order: 'post',
-                async handler(config) {
-                    onSetupBuild();
+                async handler(envName, configEnv) {
+                    assert(configUnresolved);
                     return {
                         build: {
-                            outDir: resolveOutDir(config),
-                            ...(await handleAssetsManifest_getBuildConfig(config)),
+                            outDir: resolveOutDir_configEnvironment(configUnresolved, envName, configEnv),
                         },
                     };
                 },
             },
+            config: {
+                order: 'post',
+                async handler(config) {
+                    configUnresolved = config;
+                    onSetupBuild();
+                    const build = await handleAssetsManifest_getBuildConfig(config);
+                    return { build };
+                },
+            },
             buildStart() {
                 onSetupBuild();
             },
@@ -57,7 +66,7 @@ async function getEntries(config) {
     // TO-DO/next-major-release: remove
     const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config));
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
-    if (isViteServerBuild(config)) {
+    if (isViteServerBuild_withoutEnv(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
@@ -130,7 +139,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 = !isViteServerBuild(config);
+    const isForClientSide = !isViteServerBuild_withoutEnv(config);
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');
@@ -174,7 +183,7 @@ function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
 }
 function getEntryFromPageConfig(pageConfig, isForClientSide) {
     let { pageId } = pageConfig;
-    const entryTarget = getVirtualFileIdPageConfigLazy(pageId, isForClientSide);
+    const entryTarget = generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide });
     let entryName = pageId;
     // Avoid:
     // ```

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildEntry.js

@@ -1,7 +1,7 @@
 export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
-import { virtualFileIdEntryServer } from '../../../shared/virtualFiles/virtualFileEntry.js';
+import { virtualFileIdGlobalEntryServer } from '../../../shared/virtualFileId.js';
 import { assert, PROJECT_VERSION, requireResolveVikeDistFile } from '../../utils.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -40,14 +40,14 @@ function getServerProductionEntryCode(config) {
     // After the old design is removed, let's maybe simplify and move everything into a single virtual module
     const importerCode = [
         `  import { setGlobalContext_buildEntry } from '${importPath}';`,
-        `  import * as virtualFileExports from '${virtualFileIdEntryServer}';`,
+        `  import * as virtualFileExportsGlobalEntry from '${virtualFileIdGlobalEntryServer}';`,
         `  {`,
         // Because of a Rollup bug, we have to assign ASSETS_MANIFEST to a variable before passing it to setGlobalContext_buildEntry()
         // - This workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
         `    const assetsManifest = ${ASSETS_MANIFEST};`,
         `    const buildInfo = ${JSON.stringify(buildInfo, null, 2)};`,
         '    setGlobalContext_buildEntry({',
-        `      virtualFileExports,`,
+        `      virtualFileExportsGlobalEntry,`,
         `      assetsManifest,`,
         `      buildInfo,`,
         '    });',
@@ -97,7 +97,7 @@ function getImportPath(config) {
         return 'vike/__internal';
     }
     else {
-        const { outDirServer } = getOutDirs(config);
+        const { outDirServer } = getOutDirs(config, undefined);
         const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
         return filePathRelative;
     }

package/dist/esm/node/vite/plugins/pluginBuild/pluginDistPackageJsonFile.js

@@ -18,7 +18,7 @@ function pluginDistPackageJsonFile() {
             config = config_;
         },
         generateBundle(options, bundle) {
-            if (!isViteServerBuild(config))
+            if (!isViteServerBuild(config, this.environment))
                 return;
             const isEsm = rollupIsEsm(options);
             const fileName = 'package.json';

package/dist/esm/node/vite/plugins/pluginBuild/pluginModuleBanner.js

@@ -1,7 +1,7 @@
 export { pluginModuleBanner };
-import MagicString from 'magic-string';
 import { removeVirtualFileIdPrefix } from '../../utils.js';
-import { isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+import { isViteServerBuild_extraSafe } from '../../shared/isViteServerBuild.js';
 // Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
 function pluginModuleBanner() {
@@ -16,7 +16,7 @@ function pluginModuleBanner() {
         transform: {
             order: 'post',
             handler(code, id, options) {
-                if (!isViteServerBuild_safe(config, options) &&
+                if (!isViteServerBuild_extraSafe(config, options, this.environment) &&
                     // Inject module banners if user sets `build.minify` to `false` for inspecting dist/client/
                     config.build.minify) {
                     return;
@@ -27,15 +27,12 @@ function pluginModuleBanner() {
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
                 id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
-                const magicString = new MagicString(code);
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
                 // Use legal comment so that esbuild doesn't remove it.
                 // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
                 // - https://esbuild.github.io/api/#legal-comments
                 magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
-                return {
-                    code: magicString.toString(),
-                    map: magicString.generateMap({ hires: true, source: id }),
-                };
+                return getMagicStringResult();
             },
         },
     };

package/dist/esm/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -1,10 +1,11 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, } from '../../utils.js';
-import { getVikeConfigInternal, isOverridden } from '../../shared/resolveVikeConfigInternal.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { analyzeClientEntries } from '../pluginBuild/pluginBuildConfig.js';
-import { virtualFileIdEntryClientCR, virtualFileIdEntryClientSR, } from '../../../shared/virtualFiles/virtualFileEntry.js';
+import { virtualFileIdGlobalEntryClientCR, virtualFileIdGlobalEntryClientSR } from '../../../shared/virtualFileId.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
+import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const debug = createDebugger('vike:optimizeDeps');
 async function determineOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
@@ -38,43 +39,36 @@ async function getPageDeps(config, pageConfigs) {
     let entriesServer = [];
     let includeClient = [];
     let includeServer = [];
-    const addEntry = (e, configEnv, definedAt) => {
+    const addEntry = (e, isForClientSide, definedAt) => {
         assert(e);
         // optimizeDeps.entries expects filesystem absolute paths
         assert(isVirtualFileId(e) || isFilePathAbsoluteFilesystem(e));
-        if (isRelevant(e, false, configEnv, definedAt)) {
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
             entriesClient.push(e);
         }
-        if (isRelevant(e, true, configEnv, definedAt)) {
+        else {
             entriesServer.push(e);
         }
     };
-    const addInclude = (e, configEnv, definedAt) => {
+    const addInclude = (e, isForClientSide, definedAt) => {
         assert(e);
         // optimizeDeps.include expects npm packages
         assert(!e.startsWith('/'));
         // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
         assertIsImportPathNpmPackage(e);
-        if (isRelevant(e, false, configEnv, definedAt)) {
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
             includeClient.push(e);
         }
-        if (isRelevant(e, true, configEnv, definedAt)) {
-            includeServer.push(e);
-        }
-    };
-    const isRelevant = (e, server, configEnv, definedAt) => {
-        if (server) {
-            if (!configEnv || !configEnv.server)
-                return false;
-        }
         else {
-            if (configEnv && !configEnv.client)
-                return false;
+            includeServer.push(e);
         }
-        return !isExcluded(e, server, definedAt);
     };
-    const isExcluded = (e, server, definedAt) => {
-        const exclude = server ? config.ssr.optimizeDeps.exclude : config.optimizeDeps.exclude;
+    const isExcluded = (e, isForClientSide, definedAt) => {
+        const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
         if (!exclude)
             return false;
         if (definedAt?.importPathAbsolute) {
@@ -86,26 +80,34 @@ async function getPageDeps(config, pageConfigs) {
     };
     // V1 design
     {
-        pageConfigs.forEach((pageConfig) => {
-            Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-                sources
-                    .filter((source) => !isOverridden(source, configName, pageConfig))
-                    .forEach((configValueSource) => {
-                    if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
-                        return;
-                    const { definedAt, configEnv } = configValueSource;
-                    if (definedAt.definedBy)
-                        return;
-                    if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                        addEntry(
-                        // optimizeDeps.entries expects filesystem absolute paths
-                        definedAt.filePathAbsoluteFilesystem, configEnv, definedAt);
-                    }
-                    else {
-                        addInclude(
-                        // optimizeDeps.include expects npm packages
-                        definedAt.importPathAbsolute, configEnv, definedAt);
-                    }
+        ;
+        [true, false].forEach((isForClientSide) => {
+            pageConfigs.forEach((pageConfig) => {
+                Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
+                    const runtimeEnv = {
+                        isForClientSide,
+                        isDev: true,
+                        // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                        isClientRouting: true,
+                    };
+                    const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
+                    sourcesRelevant.forEach((configValueSource) => {
+                        if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
+                            return;
+                        const { definedAt } = configValueSource;
+                        if (definedAt.definedBy)
+                            return;
+                        if (definedAt.filePathAbsoluteUserRootDir !== null) {
+                            addEntry(
+                            // optimizeDeps.entries expects filesystem absolute paths
+                            definedAt.filePathAbsoluteFilesystem, isForClientSide, definedAt);
+                        }
+                        else {
+                            addInclude(
+                            // optimizeDeps.include expects npm packages
+                            definedAt.importPathAbsolute, isForClientSide, definedAt);
+                        }
+                    });
                 });
             });
         });
@@ -117,7 +119,7 @@ async function getPageDeps(config, pageConfigs) {
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
             const { filePathAbsoluteFilesystem } = entry;
-            addEntry(filePathAbsoluteFilesystem);
+            addEntry(filePathAbsoluteFilesystem, true);
         });
     }
     // Add virtual files.
@@ -127,11 +129,11 @@ async function getPageDeps(config, pageConfigs) {
     //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
     {
         const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
-        Object.values(clientEntries).forEach((e) => addEntry(e));
+        Object.values(clientEntries).forEach((e) => addEntry(e, true));
         if (hasClientRouting)
-            addEntry(virtualFileIdEntryClientCR);
+            addEntry(virtualFileIdGlobalEntryClientCR, true);
         if (hasServerRouting)
-            addEntry(virtualFileIdEntryClientSR);
+            addEntry(virtualFileIdGlobalEntryClientSR, true);
     }
     entriesClient = entriesClient;
     entriesServer = entriesServer;

package/dist/esm/node/vite/plugins/pluginEnvVars.js

@@ -1,11 +1,10 @@
 export { pluginEnvVars };
-import MagicString from 'magic-string';
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
+import { getMagicString } from '../shared/getMagicString.js';
 // TO-DO/eventually:
 // - 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,8 +36,8 @@ function pluginEnvVars() {
             if (!code.includes('import.meta.env.'))
                 return;
             const isBuild = config.command === 'build';
-            const isClientSide = !isViteServerBuild_safe(config, options);
-            const magicString = new MagicString(code);
+            const isClientSide = !isViteServerBuild_extraSafe(config, options, this.environment);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
             // Find & check
             const replacements = Object.entries(envsAll)
                 .filter(([key]) => {
@@ -76,14 +75,11 @@ function pluginEnvVars() {
                 .filter(isNotNullish);
             // Apply
             replacements.forEach(({ regExpStr, replacement }) => {
-                applyRegExpWithMagicString(magicString, regExpStr, replacement);
+                magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
             });
             if (!magicString.hasChanged())
                 return null;
-            return {
-                code: magicString.toString(),
-                map: magicString.generateMap({ hires: true, source: id }),
-            };
+            return getMagicStringResult();
         },
     };
 }

package/dist/esm/node/vite/plugins/pluginExtractAssets.js

@@ -15,8 +15,8 @@ import { handleAssetsManifest_isFixEnabled } from './pluginBuild/handleAssetsMan
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-import { resolveIncludeAssetsImportedByServer } from '../../runtime/renderPage/getPageAssets.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
+import { resolveIncludeAssetsImportedByServer } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -45,7 +45,7 @@ function pluginExtractAssets() {
                 }
                 const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
                 assert(includeAssetsImportedByServer);
-                assert(!isViteServerBuild_safe(config, options));
+                assert(!isViteServerBuild_extraSafe(config, options, this.environment));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
@@ -62,7 +62,7 @@ function pluginExtractAssets() {
             //  - 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 (isViteServerBuild_safe(config, options)) {
+                if (isViteServerBuild_extraSafe(config, options, this.environment)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
                     assert(importer === undefined || !extractAssetsRE.test(importer));

package/dist/esm/node/vite/plugins/pluginExtractExportNames.js

@@ -4,18 +4,19 @@ export { extractExportNamesRE };
 import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage, rollupSourceMapRemove, } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_options } from '../shared/isViteServerBuild.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebugger('vike:pluginExtractExportNames');
 const globalObject = getGlobalObject('plugins/pluginExtractExportNames.ts', {});
 function pluginExtractExportNames() {
     let isDev = false;
+    let config;
     return {
         name: 'vike:pluginExtractExportNames',
         enforce: 'post',
         async transform(src, id, options) {
             id = normalizeId(id);
-            const isClientSide = !isViteServerBuild_options(options);
+            const isClientSide = !isViteServerBuild_extraSafe(config, options, this.environment);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
                 debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
@@ -25,6 +26,9 @@ function pluginExtractExportNames() {
         configureServer() {
             isDev = true;
         },
+        configResolved(config_) {
+            config = config_;
+        },
         config() {
             if (debug.isActivated) {
                 return { logLevel: 'silent' };

package/dist/esm/node/vite/plugins/pluginNonRunnableDev.js

@@ -1,7 +1,6 @@
 export { pluginNonRunnableDev };
 import { createViteRPC, assertIsNotProductionRuntime, requireResolveVikeDistFile, isRunnableDevEnvironment, } from '../utils.js';
-import { resolveClientEntriesDev } from '../shared/resolveClientEntriesDev.js';
-import { retrieveAssetsDev } from '../../runtime/renderPage/getPageAssets/retrieveAssetsDev.js';
+import { retrievePageAssetsDev } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
 import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
 import { getMagicString } from '../shared/getMagicString.js';
 assertIsNotProductionRuntime();
@@ -10,11 +9,8 @@ function getViteRpcFunctions(viteDevServer) {
         async transformIndexHtmlRPC(html) {
             return await viteDevServer.transformIndexHtml('/', html);
         },
-        // TODO/now: dedupe retrievePageAssetsDevRPC and retrievePageAssetsDev()
         async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
-            const clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer));
-            const assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
-            return { clientEntriesSrc, assetUrls };
+            return await retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries);
         },
         async getViteConfigRuntimeRPC() {
             return getViteConfigRuntime(viteDevServer.config);

package/dist/esm/node/vite/plugins/pluginPreview.js

@@ -1,24 +1,31 @@
 export { pluginPreview };
-import { assertUsage, applyPreview } from '../utils.js';
+import { assertUsage, applyPreview, assert } from '../utils.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
 import { logDockerHint } from './pluginDev.js';
-import { getOutDirs, resolveOutDir } from '../shared/getOutDirs.js';
+import { getOutDirs, resolveOutDir_configEnvironment } from '../shared/getOutDirs.js';
 import sirv from 'sirv';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
     let config;
+    let configUnresolved;
     let vikeConfig;
     return {
         name: 'vike:pluginPreview',
         apply: applyPreview,
         config(config) {
+            configUnresolved = config;
             return {
                 appType: 'custom',
+            };
+        },
+        configEnvironment(envName, configEnv) {
+            assert(configUnresolved);
+            return {
                 build: {
-                    outDir: resolveOutDir(config),
+                    outDir: resolveOutDir_configEnvironment(configUnresolved, envName, configEnv),
                 },
             };
         },
@@ -46,7 +53,7 @@ function pluginPreview() {
         },
     };
     function assertDist(isPrerenderingEnabledForAllPages) {
-        const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
+        const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config, undefined);
         const dirS = [outDirRoot, outDirClient];
         if (!isPrerenderingEnabledForAllPages)
             dirS.push(outDirServer);
@@ -55,11 +62,11 @@ function pluginPreview() {
         });
     }
     function addStaticAssetsMiddleware(middlewares) {
-        const { outDirClient } = getOutDirs(config);
+        const { outDirClient } = getOutDirs(config, undefined);
         middlewares.use(sirv(outDirClient));
     }
     function addStatic404Middleware(middlewares) {
-        const { outDirClient } = getOutDirs(config);
+        const { outDirClient } = getOutDirs(config, undefined);
         middlewares.use(config.base, (_, res, next) => {
             const file = path.posix.join(outDirClient, './404.html');
             if (fs.existsSync(file)) {

package/dist/esm/node/vite/plugins/pluginReplaceConstants.js

@@ -1,9 +1,8 @@
 export { pluginReplaceConstants };
-import MagicString from 'magic-string';
 import { assert, assertPosixPath } from '../utils.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
+import { getMagicString } from '../shared/getMagicString.js';
 function pluginReplaceConstants() {
     let config;
     return {
@@ -30,24 +29,21 @@ function pluginReplaceConstants() {
             // @ts-expect-error
             if (config._skipVikeReplaceConstants?.(id))
                 return;
-            const magicString = new MagicString(code);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
             const constantsMap = [];
             constantsMap.push({
                 constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
-                replacement: !isViteServerBuild_safe(config, options),
+                replacement: !isViteServerBuild_extraSafe(config, options, this.environment),
             });
             constantsMap.forEach(({ constants, replacement }) => {
                 if (!constants.some((c) => code.includes(c)))
                     return;
                 const regExp = getConstantRegExp(constants);
-                applyRegExpWithMagicString(magicString, regExp, replacement);
+                magicString.replaceAll(regExp, JSON.stringify(replacement));
             });
             if (!magicString.hasChanged())
                 return null;
-            return {
-                code: magicString.toString(),
-                map: magicString.generateMap({ hires: true, source: id }),
-            };
+            return getMagicStringResult();
         },
     };
 }

package/dist/esm/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.d.ts

@@ -0,0 +1,2 @@
+export { generateVirtualFileGlobalEntry };
+declare function generateVirtualFileGlobalEntry(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean): Promise<string>;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/{getVirtualFilePageConfigsEager.js → generateVirtualFileGlobalEntry.js}

@@ -1,10 +1,9 @@
-export { getVirtualFilePageConfigsEager };
-import { getVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+export { generateVirtualFileGlobalEntry };
+import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
 import { debug } from './debug.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
-async function getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting) {
+async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
     const vikeConfig = await getVikeConfigInternal(true);
     const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -35,11 +34,10 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigLazy(pageId, isForClientSide));
-        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
-        lines.push(`    loadConfigLazy: ${load},`);
+        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide }));
+        lines.push(`    loadVirtualFilePageEntry: () => ({ moduleId: ${virtualFileId}, moduleExportsPromise: import(${virtualFileId}) }),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -49,7 +47,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.d.ts

@@ -0,0 +1,6 @@
+export { generateVirtualFileGlobalEntryWithOldDesign };
+import type { ResolvedConfig } from 'vite';
+import type { Environment } from 'vite';
+declare function generateVirtualFileGlobalEntryWithOldDesign(id: string, options: {
+    ssr?: boolean;
+} | undefined, config: ResolvedConfig, env: Environment, isDev: boolean): Promise<string>;