vike 0.4.225 → 0.4.226

package/dist/esm/node/api/prepareViteApiCall.js

@@ -4,61 +4,85 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextApiOperation, setContextApiOperation } from './context.js';
-import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig2, getVikeConfigFromCliOrEnv } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import path from 'path';
-import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './utils.js';
+import { assert, assertUsage, getGlobalObject, isObject, pick, toPosixPath } from './utils.js';
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
+import { getEnvVarObject } from '../plugin/shared/getEnvVarObject.js';
 const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
 async function prepareViteApiCall(options, operation) {
     clear();
     setContextApiOperation(operation, options);
-    const viteConfigFromOptions = options.viteConfig;
-    return enhanceViteConfig(viteConfigFromOptions, operation);
+    const viteConfigFromUserApiOptions = options.viteConfig;
+    return resolveConfigs(viteConfigFromUserApiOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextApiOperation();
     clearGlobalContext();
 }
-async function enhanceViteConfig(viteConfigFromOptions, operation) {
-    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
-    await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
+async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
+    const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserEnhanced, operation);
     return {
         vikeConfig,
-        viteConfigEnhanced
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserEnhanced
     };
 }
-function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
     if (!viteConfigs)
-        return viteConfigEnhanced;
+        return viteConfigFromUserEnhanced;
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
+        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, v.value);
         assertUsage(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
-    return viteConfigEnhanced;
+    return viteConfigFromUserEnhanced;
 }
 async function getViteRoot(operation) {
     if (!globalObject.root)
-        await getInfoFromVite(undefined, operation);
+        await getViteInfo(undefined, operation);
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfigFromOptions, operation) {
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
-    const root = normalizeViteRoot(
-    // `viteConfigFromOptions.root` before `viteConfigFromUserViteFile.root` replicates Vite's precedence:
+async function getViteInfo(viteConfigFromUserApiOptions, operation) {
+    let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
+    // Precedence:
+    //  1) viteConfigFromUserEnvVar (highest precendence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precendence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserEnvVar);
+    }
+    // Resolve vite.config.js
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromUserEnhanced, operation);
+    // Correct precedence, replicates Vite:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    viteConfigFromOptions?.root ?? viteConfigFromUserViteFile?.root ?? process.cwd());
+    const viteConfigResolved = mergeConfig(viteConfigFromUserViteFile ?? {}, viteConfigFromUserEnhanced ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
     globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TODO/next-major: remove
+    // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfigFromOptions;
-    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
-    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
+    const found = findVikeVitePlugin(viteConfigResolved);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -66,16 +90,16 @@ async function getInfoFromVite(viteConfigFromOptions, operation) {
         // Add Vike to plugins if not present.
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
-        viteConfigEnhanced = {
-            ...viteConfigFromOptions,
-            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
+        viteConfigFromUserEnhanced = {
+            ...viteConfigFromUserEnhanced,
+            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced);
+        const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigEnhanced };
+    return { root, vikeVitePluginOptions, viteConfigFromUserEnhanced };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -93,8 +117,8 @@ function findVikeVitePlugin(viteConfig) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromOptions, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
+async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromUserApiOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {
@@ -126,11 +150,12 @@ function normalizeViteRoot(root) {
     path.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigEnhanced, operation) {
-    const args = getResolveConfigArgs(viteConfigEnhanced, operation);
-    // We can eventually this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+async function assertViteRoot2(root, viteConfigFromUserEnhanced, operation) {
+    const args = getResolveConfigArgs(viteConfigFromUserEnhanced, operation);
+    // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
     const viteConfigResolved = await resolveConfig(...args);
     assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+    return { viteConfigResolved };
 }
 function assertViteRoot(root, config) {
     if (globalObject.root)

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

@@ -1,15 +1,14 @@
 export { prerender };
 import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-// TODO/soon use importServerProductionIndex()
 /**
  * Programmatically trigger `$ vike prerender`
  *
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options, 'prerender');
-    options.viteConfig = viteConfigEnhanced;
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'prerender');
+    options.viteConfig = viteConfigFromUserEnhanced;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {
         viteConfig

package/dist/esm/node/api/preview.d.ts

@@ -7,6 +7,6 @@ import type { APIOptions } from './types.js';
  * https://vike.dev/api#preview
  */
 declare function preview(options?: APIOptions): Promise<{
-    viteServer: PreviewServer;
+    viteServer?: PreviewServer;
     viteConfig: ResolvedConfig;
 }>;

package/dist/esm/node/api/preview.js

@@ -1,16 +1,34 @@
 export { preview };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { preview as previewVite } from 'vite';
+import { importServerProductionIndex } from '@brillout/vite-plugin-server-entry/runtime';
+import { getOutDirs } from '../plugin/shared/getOutDirs.js';
+import { assertWarning } from './utils.js';
+import pc from '@brillout/picocolors';
+import path from 'node:path';
+import { onSetupPreview } from '../runtime/utils.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
  * https://vike.dev/api#preview
  */
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options, 'preview');
-    const server = await previewVite(viteConfigEnhanced);
-    return {
-        viteServer: server,
-        viteConfig: server.config
-    };
+    onSetupPreview();
+    const { viteConfigFromUserEnhanced, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
+    if (viteConfigResolved.vitePluginServerEntry?.inject) {
+        const outDir = getOutDirs(viteConfigResolved).outDirRoot;
+        const { outServerIndex } = await importServerProductionIndex({ outDir });
+        const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
+        assertWarning(false, `Never run ${pc.cyan('$ vike preview')} in production, run ${pc.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });
+        return {
+            viteConfig: viteConfigResolved
+        };
+    }
+    else {
+        const server = await previewVite(viteConfigFromUserEnhanced);
+        return {
+            viteServer: server,
+            viteConfig: server.config
+        };
+    }
 }

package/dist/esm/node/api/utils.d.ts

@@ -3,3 +3,4 @@ export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/pick.js';

package/dist/esm/node/api/utils.js

@@ -7,3 +7,4 @@ export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/pick.js';

package/dist/esm/node/cli/entry.js

@@ -57,8 +57,10 @@ async function cmdBuild() {
 async function cmdPreview() {
     try {
         const { viteServer } = await preview();
-        viteServer.printUrls();
-        viteServer.bindCLIShortcuts({ print: true });
+        if (viteServer) {
+            viteServer.printUrls();
+            viteServer.bindCLIShortcuts({ print: true });
+        }
     }
     catch (err) {
         console.error(pc.red(`Error while starting preview server:`));

package/dist/esm/node/cli/parseCli.js

@@ -6,7 +6,7 @@ const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
     { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
-    { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
+    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' }
 ];
 function parseCli() {
     const command = getCommand();
@@ -57,10 +57,16 @@ function showHelp() {
         `vike@${PROJECT_VERSION}`,
         '',
         'Usage:',
-        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${pc.dim('$')} ${pc.bold(`vike ${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${pc.dim(`# ${c.desc}`)}`),
+        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${pc.dim('$')} vike ${c.name.startsWith('-') ? pc.cyan(`${c.name}`) : pc.bold(`${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${pc.dim(`# ${c.desc}`)}`),
         '',
-        `Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI options')} such as --host.`,
-        `Vite settings can be passed over the ${pc.cyan('VITE_CONFIG')} environment variable.`,
+        'Common CLI options:',
+        [`vike dev ${pc.cyan('--host')}`, `vike dev ${pc.cyan('--port')} 80`, `vike build ${pc.cyan('--mode')} staging`]
+            .map((o) => `  ${pc.dim('$')} ${o}`)
+            .join('\n'),
+        '',
+        `More Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI options')}.`,
+        `More Vite settings can be passed over the ${pc.cyan('VITE_CONFIG')} environment variable.`,
+        ``,
         `See ${pc.underline('https://vike.dev/cli')} for more information.`
     ].join('\n'));
     process.exit(1);

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

@@ -124,8 +124,8 @@ function isPrerenderForceExit() {
 }
 function getFullBuildInlineConfig(config) {
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    if (config._viteConfigEnhanced) {
-        return config._viteConfigEnhanced;
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
     }
     else {
         return {

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

@@ -0,0 +1,3 @@
+export { pluginModuleBanner };
+import type { Plugin } from 'vite';
+declare function pluginModuleBanner(): Plugin;

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

@@ -0,0 +1,49 @@
+export { pluginModuleBanner };
+import { assert } from '../../utils.js';
+import { removeVirtualIdTag } from '../../../shared/virtual-files.js';
+import { isViteServerBuild, isViteServerBuild_safe } 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).
+const vikeModuleBannerPlaceholder = 'vikeModuleBannerPlaceholder';
+function pluginModuleBanner() {
+    let config;
+    return {
+        name: 'vike:pluginModuleBanner',
+        enforce: 'post',
+        apply: 'build',
+        configResolved(config_) {
+            config = config_;
+        },
+        generateBundle: {
+            order: 'post',
+            handler(_options, bundle) {
+                for (const module of Object.values(bundle)) {
+                    if (module.type === 'chunk') {
+                        if (isViteServerBuild(config)) {
+                            const codeOld = module.code;
+                            const codeNew = codeOld.replace(/vikeModuleBannerPlaceholder\("([^"]*)"\);/g, '/* $1 [vike:pluginModuleBanner] */');
+                            assert(!codeNew.includes(vikeModuleBannerPlaceholder));
+                            module.code = codeNew;
+                        }
+                        else {
+                            assert(!module.code.includes(vikeModuleBannerPlaceholder));
+                        }
+                    }
+                }
+            }
+        },
+        transform: {
+            order: 'post',
+            handler(code, id, options) {
+                if (!isViteServerBuild_safe(config, options))
+                    return;
+                if (id.startsWith('\0'))
+                    id = id;
+                id = removeVirtualIdTag(id);
+                if (id.startsWith(config.root))
+                    id = id.slice(config.root.length + 1);
+                return `${vikeModuleBannerPlaceholder}(${JSON.stringify(id)}); ${code}`;
+            }
+        }
+    };
+}

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

@@ -6,6 +6,7 @@ import { pluginDistFileNames } from './build/pluginDistFileNames.js';
 import { pluginAutoFullBuild } from './build/pluginAutoFullBuild.js';
 import { pluginBuildEntry } from './build/pluginBuildEntry.js';
 import { pluginBuildConfig } from './build/pluginBuildConfig.js';
+import { pluginModuleBanner } from './build/pluginModuleBanner.js';
 function build() {
     return [
         ...pluginBuildConfig(),
@@ -14,6 +15,7 @@ function build() {
         ...pluginBuildEntry(),
         pluginDistPackageJsonFile(),
         pluginSuppressRollupWarning(),
-        pluginDistFileNames()
+        pluginDistFileNames(),
+        pluginModuleBanner()
     ];
 }

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -4,13 +4,15 @@ export type { VikeConfigPublic };
 import { type InlineConfig, type Plugin, type ResolvedConfig, type UserConfig } from 'vite';
 import { type VikeConfigObject } from './importUserCode/v1-design/getVikeConfig.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
+import type { VitePluginServerEntryOptions } from '@brillout/vite-plugin-server-entry/plugin';
 declare module 'vite' {
     interface UserConfig {
         _isDev?: boolean;
         _vikeVitePluginOptions?: unknown;
+        vitePluginServerEntry?: VitePluginServerEntryOptions;
         _root?: string;
         _baseViteOriginal?: string;
-        _viteConfigEnhanced?: InlineConfig;
+        _viteConfigFromUserEnhanced?: InlineConfig;
         _vike?: VikeConfigPublic;
         _vikeConfigObject?: VikeConfigObject;
     }

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

@@ -1,13 +1,11 @@
 export { commonConfig };
 export { getVikeConfigPublic };
-import { mergeConfig } from 'vite';
 import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import path from 'path';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
-import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
@@ -68,6 +66,7 @@ function commonConfig(vikeVitePluginOptions) {
                     assertEsm(config.root);
                     assertVikeCliOrApi(config);
                     temp_supportOldInterface(config);
+                    emitServerEntryOnlyIfNeeded(config);
                 }
             },
             config: {
@@ -91,10 +90,6 @@ function commonConfig(vikeVitePluginOptions) {
                         // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
-                    // VITE_CONFIG
-                    const configFromEnvVar = getEnvVarObject('VITE_CONFIG');
-                    if (configFromEnvVar)
-                        configFromVike = mergeConfig(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }
@@ -197,3 +192,10 @@ function getVikeConfigPublic(config) {
     assert(vikeConfig);
     return vikeConfig;
 }
+// Only emit dist/server/entry.mjs if necessary
+function emitServerEntryOnlyIfNeeded(config) {
+    if (config.vitePluginServerEntry?.inject &&
+        !resolvePrerenderConfigGlobal(config._vikeConfigObject).isPrerenderingEnabled) {
+        config.vitePluginServerEntry.disableServerEntryEmit = true;
+    }
+}

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -50,18 +50,18 @@ async function getPageDeps(config, pageConfigs) {
                     .forEach((configValueSource) => {
                     if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
                         return;
-                    const { definedAtFilePath, configEnv } = configValueSource;
+                    const { definedAt, configEnv } = configValueSource;
                     if (!configEnv.client)
                         return;
-                    if (definedAtFilePath.definedBy)
+                    if (definedAt.definedBy)
                         return;
-                    if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                    if (definedAt.filePathAbsoluteUserRootDir !== null) {
                         // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                        addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
+                        addEntry(definedAt.filePathAbsoluteFilesystem);
                     }
                     else {
                         // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                        addInclude(definedAtFilePath.importPathAbsolute);
+                        addInclude(definedAt.importPathAbsolute);
                     }
                 });
             });

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

@@ -6,7 +6,7 @@ import { assert, assertPosixPath } from '../../utils.js';
 import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../../shared/virtual-files.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { vikeConfigDependencies, reloadVikeConfig, isV1Design, getVikeConfig } from './v1-design/getVikeConfig.js';
+import { reloadVikeConfig, isV1Design, getVikeConfig, getVikeConfigOptional } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
@@ -29,9 +29,9 @@ function importUserCode() {
                 return resolveVirtualFileId(id);
             }
         },
-        handleHotUpdate(ctx) {
+        async handleHotUpdate(ctx) {
             try {
-                return handleHotUpdate(ctx, config);
+                return await handleHotUpdate(ctx, config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -63,9 +63,9 @@ function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
     server.watcher.prependListener('unlink', (f) => listener(f, true));
     return;
-    function listener(file, isRemove) {
+    async function listener(file, isRemove) {
         file = normalizePath(file);
-        if (isPlusFile(file) || isVikeConfigDependency(file, server.moduleGraph)?.modifiesVikeVirtualFiles) {
+        if (isPlusFile(file) || (await isVikeConfigDependency(file, server.moduleGraph))?.modifiesVikeVirtualFiles) {
             invalidateVikeVirtualFiles(server);
             reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
@@ -77,9 +77,9 @@ function invalidateVikeVirtualFiles(server) {
         server.moduleGraph.invalidateModule(mod);
     });
 }
-function handleHotUpdate(ctx, config) {
+async function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
-    const isVikeConfig = isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
+    const isVikeConfig = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
         if (isVikeConfig.modifiesVikeVirtualFiles) {
             /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
@@ -101,12 +101,16 @@ function handleHotUpdate(ctx, config) {
         }
     }
 }
-function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
+async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
     // Check config-only files, for example all pages/+config.js dependencies. (There aren't part of Vite's module graph.)
     assertPosixPath(filePathAbsoluteFilesystem);
-    vikeConfigDependencies.forEach((f) => assertPosixPath(f));
-    if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
-        return { modifiesVikeVirtualFiles: true };
+    const vikeConfigObject = await getVikeConfigOptional();
+    if (vikeConfigObject) {
+        const { vikeConfigDependencies } = vikeConfigObject;
+        vikeConfigDependencies.forEach((f) => assertPosixPath(f));
+        if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
+            return { modifiesVikeVirtualFiles: true };
+    }
     // Check using Vite's module graph, for example all +htmlAttributes dependencies.
     // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
     const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);

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

@@ -96,7 +96,7 @@ const configDefinitionsBuiltIn = {
                     assert(source.valueIsLoaded);
                     if (source.value !== null) {
                         const { value } = source;
-                        const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAtFilePath);
+                        const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAt);
                         assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
                         return value;
                     }
@@ -131,6 +131,10 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true
     },
+    mode: {
+        env: { config: true },
+        global: true
+    },
     injectScriptsAt: {
         env: { server: true }
     },

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.d.ts

@@ -7,8 +7,11 @@ import type { FilePathResolved } from '../../../../../../shared/page-configs/Fil
 type FileExports = {
     fileExports: Record<string, unknown>;
 };
-type EsbuildCache = Record<string, // filePathAbsoluteFilesystem
-Promise<FileExports>>;
+type EsbuildCache = {
+    transpileCache: Record<string, // filePathAbsoluteFilesystem
+    Promise<FileExports>>;
+    vikeConfigDependencies: Set<string>;
+};
 declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<FileExports>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;
 declare function getConfigExecutionErrorIntroMsg(err: unknown): string | null;

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

@@ -9,7 +9,6 @@ import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
 import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport, genPromise, isVitest } from '../../../../utils.js';
 import { transformPointerImports } from './transformPointerImports.js';
-import { vikeConfigDependencies } from '../getVikeConfig.js';
 import sourceMapSupport from 'source-map-support';
 import { getFilePathAbsoluteUserRootDir } from '../../../../shared/getFilePath.js';
 import { createRequire } from 'module';
@@ -26,11 +25,11 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assert(filePathAbsoluteFilesystem);
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    if (esbuildCache[filePathAbsoluteFilesystem]) {
-        return await esbuildCache[filePathAbsoluteFilesystem];
+    if (esbuildCache.transpileCache[filePathAbsoluteFilesystem]) {
+        return await esbuildCache.transpileCache[filePathAbsoluteFilesystem];
     }
     const { promise, resolve } = genPromise();
-    esbuildCache[filePathAbsoluteFilesystem] = promise;
+    esbuildCache.transpileCache[filePathAbsoluteFilesystem] = promise;
     assertUsage(isPlainJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
@@ -43,20 +42,20 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     }
     else {
         const transformImports = isHeader ? 'all' : true;
-        const code = await transpileFile(filePath, transformImports, userRootDir);
+        const code = await transpileFile(filePath, transformImports, userRootDir, esbuildCache);
         fileExports = await executeTranspiledFile(filePath, code);
     }
     resolve({ fileExports });
     return { fileExports };
 }
-async function transpileFile(filePath, transformImports, userRootDir) {
+async function transpileFile(filePath, transformImports, userRootDir, esbuildCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assert(filePathAbsoluteFilesystem);
     assertPosixPath(filePathAbsoluteFilesystem);
-    vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+    esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isActivated)
         debug('transpile', filePathToShowToUserResolved);
-    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
+    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache);
     if (debug.isActivated)
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
@@ -75,7 +74,7 @@ async function transpileFile(filePath, transformImports, userRootDir) {
     }
     return code;
 }
-async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
+async function transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path.posix.dirname(entryFilePath);
     const options = {
@@ -229,7 +228,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
                     let { path } = args;
                     path = toPosixPath(path);
-                    vikeConfigDependencies.add(path);
+                    esbuildCache.vikeConfigDependencies.add(path);
                     return undefined;
                 });
                 /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
@@ -258,7 +257,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         filePathRelative = toPosixPath(filePathRelative);
         assertPosixPath(userRootDir);
         const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
-        vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+        esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     });
     const code = result.outputFiles[0].text;
     assert(typeof code === 'string');
@@ -330,7 +329,7 @@ function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
     const dirname = path.posix.dirname(filePathAbsoluteFilesystem);
     const filename = path.posix.basename(filePathAbsoluteFilesystem);
     // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const filePathTmp = path.posix.join(dirname, `${filename}.build-${getRandomId(12)}.mjs`);
+    const filePathTmp = path.posix.join(dirname, `${filename}.build-${getRandomId()}.mjs`);
     assert(isTemporaryBuildFile(filePathTmp));
     return filePathTmp;
 }