vike 0.4.225 → 0.4.226-commit-a0035ee

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/fileEnv.js

@@ -7,6 +7,7 @@ import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
+import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -16,6 +17,8 @@ function fileEnv() {
             // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
             if (!viteDevServer)
                 return;
+            if (!isV1Design(config))
+                return;
             if (skip(id))
                 return;
             // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475

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

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

@@ -1,10 +1,11 @@
 export { getVikeConfig };
+export { getVikeConfigOptional };
 export { getVikeConfig2 };
 export { reloadVikeConfig };
-export { vikeConfigDependencies };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
+export { getVikeConfigFromCliOrEnv };
 export { isOverriden };
 export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, ConfigValueSource, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
@@ -17,14 +18,22 @@ type VikeConfigObject = {
     pageConfigGlobal: PageConfigGlobalBuildTime;
     global: PageConfigUserFriendly;
     pages: PageConfigsUserFriendly;
+    vikeConfigDependencies: Set<string>;
 };
-declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(config: ResolvedConfig): void;
 declare function getVikeConfig(config: ResolvedConfig, { doNotRestartViteOnError }?: {
     doNotRestartViteOnError?: true;
 }): Promise<VikeConfigObject>;
 declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePluginOptions: unknown): Promise<VikeConfigObject>;
+declare function getVikeConfigOptional(): Promise<null | VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig | UserConfig): boolean;
+declare function getVikeConfigFromCliOrEnv(): {
+    vikeConfigFromCliOrEnv: {
+        [x: string]: unknown;
+    };
+    configFromCliOptions: import("../../../../cli/parseCli.js").CliOptions | null;
+    configFromEnvVar: Record<string, unknown> | null;
+};
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitions, configName: string): ConfigDefinitionInternal | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;