vike 0.4.237 → 0.4.238

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 { isViteServerSide_extraSafe } from '../shared/isViteServerSide.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(!isViteServerSide_extraSafe(config, this.environment, options));
                 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 (isViteServerSide_extraSafe(config, this.environment, options)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
                     assert(importer === undefined || !extractAssetsRE.test(importer));
@@ -139,7 +139,7 @@ function pluginExtractAssets() {
             async configResolved(config_) {
                 config = config_;
                 vikeConfig = await getVikeConfigInternal();
-                isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+                isFixEnabled = handleAssetsManifest_isFixEnabled();
                 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/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 { isViteServerSide_extraSafe } from '../shared/isViteServerSide.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 = !isViteServerSide_extraSafe(config, this.environment, 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()]);
@@ -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/pluginFileEnv.js

@@ -7,6 +7,7 @@ import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
+import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 function pluginFileEnv() {
     let config;
     let viteDevServer;
@@ -28,7 +29,7 @@ function pluginFileEnv() {
             const importers = Array.from(moduleInfo.importers)
                 .map((m) => m.id)
                 .filter((id) => id !== null);
-            assertFileEnv(id, !!options?.ssr, importers, 
+            assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), 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);
         },
@@ -40,7 +41,7 @@ function pluginFileEnv() {
                 return;
             if (skip(id))
                 return;
-            const isServerSide = !!options?.ssr;
+            const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
             if (!isWrongEnv(id, isServerSide))
                 return;
             const { importers } = this.getModuleInfo(id);
@@ -66,7 +67,7 @@ function pluginFileEnv() {
                     */
                     return;
                 }
-                assertFileEnv(moduleId, !!config.build.ssr, importers, false);
+                assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
             });
         },
         configResolved(config_) {

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 { createViteRPC, assertIsNotProductionRuntime, requireResolveDistFile, isRunnableDevEnvironment, } from '../utils.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);
@@ -22,7 +18,8 @@ function getViteRpcFunctions(viteDevServer) {
     };
 }
 function pluginNonRunnableDev() {
-    const runtimeGlobalContextFilePath = requireResolveVikeDistFile('dist/esm/node/runtime/globalContext.js');
+    const distFileIsNonRunnableDev = requireResolveDistFile('dist/esm/utils/isNonRunnableDev.js');
+    const distFileGlobalContext = requireResolveDistFile('dist/esm/node/runtime/globalContext.js');
     let config;
     return {
         name: 'vike:pluginNonRunnableDev',
@@ -35,14 +32,17 @@ function pluginNonRunnableDev() {
         transform(code, id) {
             if (!config._isDev)
                 return;
-            if (id !== runtimeGlobalContextFilePath)
+            if (id !== distFileIsNonRunnableDev && id !== distFileGlobalContext)
+                return;
+            if (isRunnableDevEnvironment(this.environment))
                 return;
-            const isNonRunnableDev = !isRunnableDevEnvironment(this.environment);
             const { magicString, getMagicStringResult } = getMagicString(code, id);
-            if (isNonRunnableDev) {
+            if (id === distFileIsNonRunnableDev) {
+                magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
+            }
+            if (id === distFileGlobalContext) {
                 magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
             }
-            magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(isNonRunnableDev));
             return getMagicStringResult();
         },
     };

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

@@ -5,7 +5,7 @@ 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 } from '../shared/getOutDirs.js';
 import sirv from 'sirv';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
@@ -14,12 +14,9 @@ function pluginPreview() {
     return {
         name: 'vike:pluginPreview',
         apply: applyPreview,
-        config(config) {
+        config() {
             return {
                 appType: 'custom',
-                build: {
-                    outDir: resolveOutDir(config),
-                },
             };
         },
         async configResolved(config_) {
@@ -46,7 +43,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 +52,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 { isViteServerSide_extraSafe } from '../shared/isViteServerSide.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: !isViteServerSide_extraSafe(config, this.environment, options),
             });
             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/pluginSetGlobalContext.js

@@ -1,5 +1,5 @@
 export { pluginSetGlobalContext };
-import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction, } from '../../runtime/globalContext.js';
+import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProductionAccordingToVite, } from '../../runtime/globalContext.js';
 import { isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
 import { reloadVikeConfig } from '../shared/resolveVikeConfigInternal.js';
 import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
@@ -27,7 +27,7 @@ function pluginSetGlobalContext() {
                 order: 'pre',
                 handler(_, env) {
                     const isViteDev = isDevCheck(env);
-                    setGlobalContext_isProduction(!isViteDev);
+                    setGlobalContext_isProductionAccordingToVite(!isViteDev);
                     markSetup_isViteDev(isViteDev);
                 },
             },

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,9 +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 { 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);
@@ -34,9 +34,8 @@ 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, { isForClientSide, isClientRouting, isDev }, '    ', true));
         lines.push(`    },`);

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>;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/{getVirtualFileEntry.js → generateVirtualFileGlobalEntryWithOldDesign.js}

@@ -1,19 +1,19 @@
-export { getVirtualFileEntry };
+export { generateVirtualFileGlobalEntryWithOldDesign };
 import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning, } from '../../utils.js';
-import { isVirtualFileIdEntry } from '../../../shared/virtualFiles/virtualFileEntry.js';
+import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'node:path';
-import { getVirtualFilePageConfigsEager } from './getVirtualFilePageConfigsEager.js';
+import { generateVirtualFileGlobalEntry } from './generateVirtualFileGlobalEntry.js';
 import { getVikeConfigInternal, isV1Design as isV1Design_ } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerBuild_options } from '../../shared/isViteServerBuild.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-async function getVirtualFileEntry(id, options, config, isDev) {
-    const idParsed = isVirtualFileIdEntry(id);
-    assert(idParsed);
+import { isViteServerSide_extraSafe } from '../../shared/isViteServerSide.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
+async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
+    const idParsed = parseVirtualFileId(id);
+    assert(idParsed && idParsed.type === 'global-entry');
     const { isForClientSide, isClientRouting } = idParsed;
-    assert(isForClientSide === !isViteServerBuild_options(options));
+    assert(isForClientSide === !isViteServerSide_extraSafe(config, env, options));
     const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
     return code;
 }
@@ -66,7 +66,7 @@ export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
 
-${await getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting)}
+${await generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting)}
 
 `;
     // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
@@ -168,7 +168,7 @@ function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
-            excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot),
+            excludeDir: path.posix.relative(config.root, getOutDirs(config, undefined).outDirRoot),
         },
     ];
     return globRoots;

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

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

package/dist/esm/node/vite/plugins/pluginVirtualFiles/{getVirtualFilePageConfigLazy.js → generateVirtualFilePageEntry.js}

@@ -1,17 +1,16 @@
-export { getVirtualFilePageConfigLazy };
-// TODO/now: rename file to generateVirtualFileEntryPage.ts
+export { generateVirtualFilePageEntry };
 import { assert, getProjectError } from '../../utils.js';
-import { getVirtualFileIdPageConfigLazy, isVirtualFileIdPageConfigLazy, } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { parseVirtualFileId, generateVirtualFileId } from '../../../shared/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { handleAssetsManifest_isFixEnabled } from '../pluginBuild/handleAssetsManifest.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-async function getVirtualFilePageConfigLazy(id, isDev, config) {
-    const result = isVirtualFileIdPageConfigLazy(id);
-    assert(result);
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
+async function generateVirtualFilePageEntry(id, isDev) {
+    const result = parseVirtualFileId(id);
+    assert(result && result.type === 'page-entry');
     /* This assertion fails when using includeAssetsImportedByServer
     {
       const isForClientSide = !config.build.ssr
@@ -33,11 +32,11 @@ async function getVirtualFilePageConfigLazy(id, isDev, config) {
             throw getProjectError('Outdated request');
         //*/
     }
-    const code = getLoadConfigLazy(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), config, isDev);
+    const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function getLoadConfigLazy(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, config, isDev) {
+function getCode(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
@@ -45,8 +44,8 @@ function getLoadConfigLazy(pageConfig, isForClientSide, pageId, includeAssetsImp
     lines.push('export const configValuesSerialized = {');
     lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '', false));
     lines.push('};');
-    if (!handleAssetsManifest_isFixEnabled(config) && includeAssetsImportedByServer && isForClientSide && !isDev) {
-        importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigLazy(pageId, false))}'`);
+    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
+        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide: false }))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;

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

@@ -1,5 +1,7 @@
 export { getConfigValueSourcesRelevant };
+export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
+export { isConfigSourceValueNull };
 export type { RuntimeEnv };
 import type { ConfigEnvInternal, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
 type RuntimeEnv = {
@@ -9,6 +11,8 @@ type RuntimeEnv = {
 } | {
     isForConfig: true;
 };
+type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;
 declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];
+declare function getConfigValueSourceRelevantAnyEnv(configName: string, pageConfig: PageConfigPartial): null | ConfigValueSource;
 declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtimeEnv: RuntimeEnv): boolean;
-type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;
+declare function isConfigSourceValueNull(source: ConfigValueSource): boolean | null;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js

@@ -1,28 +1,47 @@
 export { getConfigValueSourcesRelevant };
+export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
-import { assert } from '../../utils.js';
+export { isConfigSourceValueNull };
+import { assert, assertIsNotBrowser } from '../../utils.js';
+assertIsNotBrowser();
 function getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig) {
     const configDef = pageConfig.configDefinitions[configName];
     assert(configDef);
     let sourcesRelevant = pageConfig.configValueSources[configName];
     if (!sourcesRelevant)
         return [];
-    if (!configDef.cumulative) {
+    // Ignore configs with value `undefined`
+    sourcesRelevant = sourcesRelevant.filter((source) => !isConfigSourceValueUndefined(source));
+    // Environment filtering
+    sourcesRelevant = sourcesRelevant.filter((source) => isRuntimeEnvMatch(source.configEnv, runtimeEnv));
+    // Overriding - non-cumulative configs
+    if (!configDef.cumulative && sourcesRelevant.length > 1) {
         const source = sourcesRelevant[0];
-        if (source) {
-            sourcesRelevant = [source];
-        }
-        else {
-            assert(sourcesRelevant.length === 0);
-        }
+        assert(source);
+        sourcesRelevant = [source];
     }
-    else {
-        // isOverridden() must be called before isRuntimeEnvMatch() is called (otherwise isOverridden() will return a wrong value)
-        sourcesRelevant = sourcesRelevant.filter((source) => !isOverridden(source, configName, pageConfig));
+    // Overriding - cumulative configs
+    if (configDef.cumulative && sourcesRelevant.length > 0) {
+        sourcesRelevant = applyFilenameSuffix(sourcesRelevant);
     }
-    sourcesRelevant = sourcesRelevant.filter((source) => isRuntimeEnvMatch(source.configEnv, runtimeEnv));
     return sourcesRelevant;
 }
+function getConfigValueSourceRelevantAnyEnv(configName, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    assert(configDef);
+    assert(!configDef.cumulative); // So far, this function is only used by non-cumulative configs
+    let sourcesRelevant = pageConfig.configValueSources[configName];
+    if (!sourcesRelevant)
+        return null;
+    // Ignore configs with value `undefined`
+    sourcesRelevant = sourcesRelevant.filter((source) => !isConfigSourceValueUndefined(source));
+    const source = sourcesRelevant[0];
+    if (!source)
+        return null;
+    if (isConfigSourceValueNull(source))
+        return null;
+    return source;
+}
 function isRuntimeEnvMatch(configEnv, runtimeEnv) {
     if ('isForConfig' in runtimeEnv)
         return !!configEnv.config;
@@ -52,14 +71,25 @@ function isRuntimeEnvMatch(configEnv, runtimeEnv) {
     }
     return true;
 }
-function isOverridden(source, configName, pageConfig) {
-    const configDef = pageConfig.configDefinitions[configName];
-    assert(configDef);
-    if (configDef.cumulative)
-        return false;
-    const sources = pageConfig.configValueSources[configName];
-    assert(sources);
-    const idx = sources.indexOf(source);
-    assert(idx >= 0);
-    return idx > 0;
+// Setting a config to `undefined` should be equivalent to not setting it at all
+function isConfigSourceValueUndefined(source) {
+    if (!source.valueIsLoaded)
+        return null;
+    return source.value === undefined;
+}
+// Setting a config to `null` enables the user to suppress inherited config by overriding it with `null` (this only works when setting the config value to `null` inside a +config.js file — it doesn't work when setting the config value to `null` with a +{configName}.js file).
+function isConfigSourceValueNull(source) {
+    if (!source.valueIsLoaded)
+        return null;
+    return source.value === null;
+}
+function applyFilenameSuffix(sourcesRelevant) {
+    const getFileName = (source) => source.plusFile?.filePath.fileName ?? '';
+    // Apply `clear`: truncate at first clear file
+    const clearIndex = sourcesRelevant.findIndex((source) => getFileName(source).includes('.clear.'));
+    if (clearIndex !== -1)
+        sourcesRelevant = sourcesRelevant.slice(0, clearIndex + 1);
+    // Apply `default`: exclude defaults if any non-defaults exist, otherwise keep only first default
+    const nonDefaults = sourcesRelevant.filter((source) => !getFileName(source).includes('.default.'));
+    return nonDefaults.length > 0 ? nonDefaults : sourcesRelevant.slice(0, 1);
 }

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

@@ -1,10 +1,9 @@
 export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
-import { getVirtualFilePageConfigLazy } from './pluginVirtualFiles/getVirtualFilePageConfigLazy.js';
-import { getVirtualFileEntry } from './pluginVirtualFiles/getVirtualFileEntry.js';
+import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
+import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
 import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
-import { isVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
-import { isVirtualFileIdEntry } from '../../shared/virtualFiles/virtualFileEntry.js';
+import { parseVirtualFileId } from '../../shared/virtualFileId.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerNotProd.js';
@@ -44,13 +43,16 @@ function pluginVirtualFiles() {
             id = removeVirtualFileIdPrefix(id);
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
-            if (isVirtualFileIdPageConfigLazy(id)) {
-                const code = await getVirtualFilePageConfigLazy(id, isDev, config);
-                return code;
-            }
-            if (isVirtualFileIdEntry(id)) {
-                const code = await getVirtualFileEntry(id, options, config, isDev);
-                return code;
+            const idParsed = parseVirtualFileId(id);
+            if (idParsed) {
+                if (idParsed.type === 'page-entry') {
+                    const code = await generateVirtualFilePageEntry(id, isDev);
+                    return code;
+                }
+                if (idParsed.type === 'global-entry') {
+                    const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                    return code;
+                }
             }
         },
         configureServer(server) {
@@ -163,7 +165,7 @@ function reloadConfig(filePath, config, op, server) {
 }
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
-        .filter((url) => isVirtualFileIdPageConfigLazy(url) || isVirtualFileIdEntry(url))
+        .filter((url) => parseVirtualFileId(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);

package/dist/esm/node/vite/shared/findPageFiles.js

@@ -5,7 +5,7 @@ import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
-    const { outDirRoot } = getOutDirs(config);
+    const { outDirRoot } = getOutDirs(config, undefined);
     const timeBase = new Date().getTime();
     let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensionPattern}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));

package/dist/esm/node/vite/shared/getClientEntrySrcDev.d.ts

@@ -0,0 +1,4 @@
+export { getClientEntrySrcDev };
+export type GetClientEntrySrcDev = typeof getClientEntrySrcDev;
+import type { ViteDevServer } from 'vite';
+declare function getClientEntrySrcDev(clientEntry: string, viteDevServer: ViteDevServer): string;

package/dist/esm/node/vite/shared/{resolveClientEntriesDev.js → getClientEntrySrcDev.js}

@@ -1,7 +1,7 @@
-export { resolveClientEntriesDev };
-import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveVikeDistFile, } from '../utils.js';
+export { getClientEntrySrcDev };
+import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveDistFile, } from '../utils.js';
 assertIsNotProductionRuntime();
-function resolveClientEntriesDev(clientEntry, viteDevServer) {
+function getClientEntrySrcDev(clientEntry, viteDevServer) {
     let userRootDir = viteDevServer.config.root;
     assert(userRootDir);
     userRootDir = toPosixPath(userRootDir);
@@ -23,7 +23,7 @@ function resolveClientEntriesDev(clientEntry, viteDevServer) {
     else {
         if (clientEntry.startsWith('@@vike/')) {
             assert(clientEntry.endsWith('.js'));
-            filePath = requireResolveVikeDistFile(`dist/esm/${clientEntry.replace('@@vike/dist/esm/', '')}`);
+            filePath = requireResolveDistFile(`dist/esm/${clientEntry.replace('@@vike/dist/esm/', '')}`);
         }
         else {
             assertIsImportPathNpmPackage(clientEntry);