vike 0.4.231 → 0.4.232-commit-134207d

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

@@ -0,0 +1,53 @@
+export { getVirtualFilePageConfigLazy };
+import { assert, getProjectError } from '../../utils.js';
+import { getVirtualFileIdPageConfigLazy, isVirtualFileIdPageConfigLazy, } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
+import { debug } from './debug.js';
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.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);
+    /* This assertion fails when using includeAssetsImportedByServer
+    {
+      const isForClientSide = !config.build.ssr
+      assert(result.isForClientSide === isForClientSide)
+    }
+    */
+    const { pageId, isForClientSide } = result;
+    const vikeConfig = await getVikeConfigInternal(true);
+    const { _pageConfigs: pageConfigs } = vikeConfig;
+    const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
+    if (!isDev) {
+        assert(pageConfig);
+    }
+    else {
+        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition.
+        assert(pageConfig, { id, pageId })
+        /*/
+        if (!pageConfig)
+            throw getProjectError('Outdated request');
+        //*/
+    }
+    const code = getLoadConfigLazy(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), config, isDev);
+    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function getLoadConfigLazy(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, config, isDev) {
+    const lines = [];
+    const importStatements = [];
+    const filesEnv = new Map();
+    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+    lines.push('export const configValuesSerialized = {');
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
+    lines.push('};');
+    if (!handleAssetsManifest_isFixEnabled(config) && includeAssetsImportedByServer && isForClientSide && !isDev) {
+        importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigLazy(pageId, false))}'`);
+    }
+    const code = [...importStatements, ...lines].join('\n');
+    return code;
+}

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

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

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/virtual-files/getVirtualFilePageConfigs.js → vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigsEager.js}

@@ -1,12 +1,12 @@
-export { getVirtualFilePageConfigs };
-import { getVirtualFileIdPageConfigValuesAll } from '../../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+export { getVirtualFilePageConfigsEager };
+import { getVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { debug } from './debug.js';
-import { getVikeConfig } from '../getVikeConfig.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValues } from '../../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
-    const { pageConfigs, pageConfigGlobal } = vikeConfig;
+import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
+async function getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting) {
+    const vikeConfig = await getVikeConfigInternal(true);
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
@@ -31,9 +31,9 @@ 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(getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide));
+        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigLazy(pageId, isForClientSide));
         const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
-        lines.push(`    loadConfigValuesAll: ${load},`);
+        lines.push(`    loadConfigLazy: ${load},`);
         lines.push(`    configValuesSerialized: {`);
         lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/virtual-files → vite/plugins/pluginVirtualFiles}/isRuntimeEnvMatch.d.ts

@@ -1,5 +1,5 @@
 export { isRuntimeEnvMatch };
-import type { ConfigEnvInternal } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal } from '../../../../types/PageConfig.js';
 declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
     isForClientSide: boolean;
     isClientRouting: boolean;

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

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

package/dist/esm/node/{plugin/plugins/importUserCode/index.js → vite/plugins/pluginVirtualFiles.js}

@@ -1,27 +1,27 @@
-export { importUserCode };
+export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
-import { getVirtualFilePageConfigValuesAll } from './v1-design/virtual-files/getVirtualFilePageConfigValuesAll.js';
-import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-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 { reloadVikeConfig, isV1Design, getVikeConfig, getVikeConfigOptional } from './v1-design/getVikeConfig.js';
+import { getVirtualFilePageConfigLazy } from './pluginVirtualFiles/getVirtualFilePageConfigLazy.js';
+import { getVirtualFileEntry } from './pluginVirtualFiles/getVirtualFileEntry.js';
+import { assert, assertPosixPath, isScriptFile } from '../utils.js';
+import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
+import { isVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { isVirtualFileIdEntry } from '../../shared/virtualFiles/virtualFileEntry.js';
+import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
 import pc from '@brillout/picocolors';
-import { logConfigInfo } from '../../shared/loggerNotProd.js';
-import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
-import { updateUserFiles } from '../../../runtime/globalContext.js';
-import { isPlusFile } from './v1-design/getVikeConfig/crawlPlusFiles.js';
-function importUserCode() {
+import { logConfigInfo } from '../shared/loggerNotProd.js';
+import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { updateUserFiles } from '../../runtime/globalContext.js';
+import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
+import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
+import { getVikeConfigError } from '../../shared/getVikeConfigError.js';
+function pluginVirtualFiles() {
     let config;
-    let vikeConfig;
     return {
-        name: 'vike:importUserCode',
+        name: 'vike:pluginVirtualFiles',
         async configResolved(config_) {
-            vikeConfig = await getVikeConfig(config_);
             config = config_;
             // TODO/v1-release: remove
-            if (!isV1Design(config))
+            if (!isV1Design())
                 config.experimental.importGlobRestoreExtension = true;
         },
         resolveId(id) {
@@ -45,18 +45,18 @@ function importUserCode() {
             id = getVirtualFileId(id);
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
-            if (isVirtualFileIdPageConfigValuesAll(id)) {
-                const code = await getVirtualFilePageConfigValuesAll(id, isDev, config);
+            if (isVirtualFileIdPageConfigLazy(id)) {
+                const code = await getVirtualFilePageConfigLazy(id, isDev, config);
                 return code;
             }
-            if (isVirtualFileIdImportUserCode(id)) {
-                const code = await getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev);
+            if (isVirtualFileIdEntry(id)) {
+                const code = await getVirtualFileEntry(id, options, config, isDev);
                 return code;
             }
         },
         configureServer(server) {
             handleFileAddRemove(server, config);
-        }
+        },
     };
 }
 function handleFileAddRemove(server, config) {
@@ -65,9 +65,31 @@ function handleFileAddRemove(server, config) {
     return;
     async function listener(file, isRemove) {
         file = normalizePath(file);
-        if (isPlusFile(file) || (await isVikeConfigDependency(file, server.moduleGraph))?.modifiesVikeVirtualFiles) {
-            invalidateVikeVirtualFiles(server);
-            reloadConfig(file, config, isRemove ? 'removed' : 'created');
+        if (isTemporaryBuildFile(file))
+            return;
+        const { moduleGraph } = server;
+        const isVikeConfig = await isVikeConfigDependency(file, moduleGraph);
+        const reload = () => reloadConfig(file, config, isRemove ? 'removed' : 'created', server);
+        if (isVikeConfig) {
+            if (isVikeConfig.isNotProcessedByVite) {
+                reload();
+            }
+            else {
+                // Let Vite handle it
+                assert(existsInViteModuleGraph(file, moduleGraph));
+            }
+        }
+        else {
+            // Trick: when importing a file that doesn't exist => we don't know whether `file` is that missing file => we take a leap of faith when the conditions below are met.
+            // - Not sure how reliable that trick is.
+            // - Reloading Vike's config is cheap and file creation/removal is rare => the trick is worth it.
+            // - Reproduction:
+            //   ```bash
+            //   rm someDep.js && sleep 2 && git checkout someDep.js
+            //   ```
+            if (isScriptFile(file) && getVikeConfigError() && !existsInViteModuleGraph(file, moduleGraph)) {
+                reload();
+            }
         }
     }
 }
@@ -77,60 +99,67 @@ function invalidateVikeVirtualFiles(server) {
         server.moduleGraph.invalidateModule(mod);
     });
 }
+// Vite calls its hook handleHotUpdate() whenever *any file* is modified — including files that aren't in Vite's module graph such as `pages/+config.js`
 async function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
     const isVikeConfig = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
-        if (isVikeConfig.modifiesVikeVirtualFiles) {
+        if (isVikeConfig.isNotProcessedByVite) {
             /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
             const isViteModule = ctx.modules.length > 0
             assert(!isViteModule)
             */
-            // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
-            invalidateVikeVirtualFiles(server);
-            reloadConfig(file, config, 'modified');
+            reloadConfig(file, config, 'modified', server);
+            // Files such as `pages/+config.js` can potentially modify Vike's virtual files.
             // Triggers a full page reload
             const vikeVirtualFiles = getVikeVirtualFiles(server);
             return vikeVirtualFiles;
         }
         else {
             // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
-            // Vite already invalidates it, but possibly *after* handleHotUpdate() and thus after server.ssrLoadModule()
+            // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
             updateUserFiles();
         }
     }
 }
 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.)
+    // Non-runtime Vike config files such as `pages/+config.js` which aren't processed by Vite.
+    // - They're missing in Vite's module graph.
+    // - Potentially modifies Vike's virtual files.
+    // - Same for all `pages/+config.js` dependencies.
     assertPosixPath(filePathAbsoluteFilesystem);
-    const vikeConfigObject = await getVikeConfigOptional();
+    const vikeConfigObject = await getVikeConfigInternalOptional();
     if (vikeConfigObject) {
-        const { vikeConfigDependencies } = vikeConfigObject;
+        const { _vikeConfigDependencies: vikeConfigDependencies } = vikeConfigObject;
         vikeConfigDependencies.forEach((f) => assertPosixPath(f));
         if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
-            return { modifiesVikeVirtualFiles: true };
+            return { isNotProcessedByVite: true };
     }
-    // Check using Vite's module graph, for example all +htmlAttributes dependencies.
-    // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
+    // Runtime Vike config files such as +data.js which are processed by Vite.
+    // - They're included in Vite's module graph.
+    // - They never modify Vike's virtual files.
+    // - Same for all `+data.js` dependencies.
     const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
     const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
     if (isPlusValueFileDependency)
-        return { modifiesVikeVirtualFiles: false };
+        return { isNotProcessedByVite: false };
     return null;
 }
-function reloadConfig(filePath, config, op) {
+function reloadConfig(filePath, config, op, server) {
+    // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
+    invalidateVikeVirtualFiles(server);
     {
         const filePathToShowToUserResolved = getModuleFilePathAbsolute(filePath, config);
         const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config);
+    reloadVikeConfig();
     updateUserFiles();
 }
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
-        .filter((url) => isVirtualFileIdPageConfigValuesAll(url) || isVirtualFileIdImportUserCode(url))
+        .filter((url) => isVirtualFileIdPageConfigLazy(url) || isVirtualFileIdEntry(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);
@@ -170,3 +199,6 @@ function getModuleImporters(mod, seen = new Set()) {
     }
     return importers;
 }
+function existsInViteModuleGraph(file, moduleGraph) {
+    return !!moduleGraph.getModulesByFile(file);
+}

package/dist/esm/node/vite/plugins/pluginWorkaroundCssModuleHmr.d.ts

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

package/dist/esm/node/{plugin/plugins/workaroundCssModuleHmr.js → vite/plugins/pluginWorkaroundCssModuleHmr.js}

@@ -1,13 +1,13 @@
-export { workaroundCssModuleHmr };
-function workaroundCssModuleHmr() {
+export { pluginWorkaroundCssModuleHmr };
+function pluginWorkaroundCssModuleHmr() {
     return {
-        name: 'vike:workaroundCssModuleHmr',
+        name: 'vike:pluginWorkaroundCssModuleHmr',
         handleHotUpdate(ctx) {
             // prevent full reload due to non self-accepting css module.
             // here only "?direct" module should be filtered out as it doesn't have a parent module.
             if (ctx.file.includes('module.css')) {
                 return ctx.modules.filter((m) => !m.id?.includes('?direct'));
             }
-        }
+        },
     };
 }

package/dist/esm/node/vite/plugins/pluginWorkaroundVite6HmrRegression.d.ts

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

package/dist/esm/node/{plugin/plugins/workaroundVite6HmrRegression.js → vite/plugins/pluginWorkaroundVite6HmrRegression.js}

@@ -1,11 +1,11 @@
-export { workaroundVite6HmrRegression };
+export { pluginWorkaroundVite6HmrRegression };
 // https://vite.dev/guide/migration (will be 404 after vite@7 release) > search for `hmrReload()`
 // https://v6.vite.dev/guide/migration (will exist after vite@7 release) > search for `hmrReload()`
 // Workaround seems to work for docs page /banner (which is HTML-only)
 // But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
-function workaroundVite6HmrRegression() {
+function pluginWorkaroundVite6HmrRegression() {
     return {
-        name: 'vike:workaroundVite6HmrRegression',
+        name: 'vike:pluginWorkaroundVite6HmrRegression',
         enforce: 'post',
         hotUpdate: {
             order: 'post',
@@ -27,7 +27,7 @@ function workaroundVite6HmrRegression() {
                     server.ws.send({ type: 'full-reload' });
                     return [];
                 }
-            }
-        }
+            },
+        },
     };
 }

package/dist/esm/node/{plugin → vite}/shared/addSsrMiddleware.js

@@ -12,18 +12,18 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const { headers } = req;
         const pageContextInit = {
             urlOriginal: url,
-            headersOriginal: headers
+            headersOriginal: headers,
         };
         Object.defineProperty(pageContextInit, 'userAgent', {
             get() {
                 // TODO/next-major-release: assertUsage() instead of assertWarning()
                 assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
                     showStackTrace: true,
-                    onlyOnce: true
+                    onlyOnce: true,
                 });
                 return headers['user-agent'];
             },
-            enumerable: false
+            enumerable: false,
         });
         let pageContext;
         try {

package/dist/esm/node/{plugin → vite}/shared/findPageFiles.js

@@ -13,7 +13,7 @@ async function findPageFiles(config, fileTypes, isDev) {
     if (isDev) {
         // We only warn in dev, because while building it's expected to take a long time as tinyglobby is competing for resources with other tasks
         assertWarning(time < 1.5 * 1000, `Finding your page files ${pc.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
-            onlyOnce: 'slow-page-files-search'
+            onlyOnce: 'slow-page-files-search',
         });
     }
     return pageFiles;

package/dist/esm/node/{plugin → vite}/shared/getFilePath.d.ts

@@ -1,12 +1,12 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
 export { getFilePathAbsoluteUserRootDir };
-export { getFilePathToShowToUserFromUnkown };
+export { getFilePathToShowToUserFromUnknown };
 export { getModuleFilePathAbsolute };
 export { getModuleFilePathRelative };
-export { cleanFilePathUnkown };
+export { cleanFilePathUnknown };
 export { assertModuleId };
-import type { FilePathResolved, FilePathUnresolved } from '../../../shared/page-configs/FilePath.js';
+import type { FilePathResolved, FilePathUnresolved } from '../../../types/FilePath.js';
 import type { ResolvedConfig } from 'vite';
 declare function getFilePathResolved(args: {
     userRootDir: string;
@@ -20,12 +20,12 @@ declare function getFilePathResolved(args: {
 declare function getFilePathUnresolved(args: {
     importPathAbsolute: string;
 }): FilePathUnresolved;
-declare function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }: {
+declare function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir, }: {
     filePathAbsoluteFilesystem: string;
     userRootDir: string;
 }): string | null;
 declare function getModuleFilePathAbsolute(moduleId: string, config: ResolvedConfig): string;
 declare function getModuleFilePathRelative(moduleId: string, config: ResolvedConfig): string;
 declare function assertModuleId(moduleId: string): void;
-declare function getFilePathToShowToUserFromUnkown(filePathUnkown: string, userRootDir: string): string;
-declare function cleanFilePathUnkown(filePathUnknown: string): string;
+declare function getFilePathToShowToUserFromUnknown(filePathUnknown: string, userRootDir: string): string;
+declare function cleanFilePathUnknown(filePathUnknown: string): string;

package/dist/esm/node/{plugin → vite}/shared/getFilePath.js

@@ -1,13 +1,13 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
 export { getFilePathAbsoluteUserRootDir };
-export { getFilePathToShowToUserFromUnkown };
+export { getFilePathToShowToUserFromUnknown };
 export { getModuleFilePathAbsolute };
 export { getModuleFilePathRelative };
-export { cleanFilePathUnkown };
+export { cleanFilePathUnknown };
 export { assertModuleId };
-import path from 'path';
-import { assert, assertIsImportPathNpmPackage, assertFilePathAbsoluteFilesystem, assertPosixPath, toPosixPath } from '../utils.js';
+import path from 'node:path';
+import { assert, assertIsImportPathNpmPackage, assertFilePathAbsoluteFilesystem, assertPosixPath, toPosixPath, } from '../utils.js';
 function getFilePathResolved(args) {
     const { userRootDir } = args;
     let filePathAbsoluteFilesystem;
@@ -30,7 +30,7 @@ function getFilePathResolved(args) {
         ...getComputedProps(args),
         filePathAbsoluteFilesystem,
         filePathToShowToUserResolved,
-        fileName
+        fileName,
     };
     return filePathResolved;
 }
@@ -44,7 +44,7 @@ function getComputedProps(args) {
             importPathAbsolute,
             filePathAbsoluteUserRootDir,
             filePathAbsoluteVite: filePathAbsoluteUserRootDir,
-            filePathToShowToUser: filePathAbsoluteUserRootDir
+            filePathToShowToUser: filePathAbsoluteUserRootDir,
         };
     }
     else {
@@ -58,16 +58,16 @@ function getComputedPropsImportPathAbsolute(args) {
         filePathAbsoluteUserRootDir: null,
         importPathAbsolute,
         filePathAbsoluteVite: importPathAbsolute,
-        filePathToShowToUser: importPathAbsolute
+        filePathToShowToUser: importPathAbsolute,
     };
 }
 function getFilePathUnresolved(args) {
     return {
         ...getComputedPropsImportPathAbsolute(args),
-        filePathAbsoluteFilesystem: null
+        filePathAbsoluteFilesystem: null,
     };
 }
-function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
+function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir, }) {
     assertPosixPath(filePathAbsoluteUserRootDir);
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);
@@ -75,14 +75,14 @@ function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRo
     assertFilePathAbsoluteFilesystem(userRootDir);
     return filePathAbsoluteFilesystem;
 }
-function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir, }) {
     const { filePathAbsoluteUserRootDir } = getFilePathRelative({
         filePathAbsoluteFilesystem,
-        userRootDir
+        userRootDir,
     });
     return filePathAbsoluteUserRootDir;
 }
-function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir }) {
+function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir, }) {
     assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
@@ -92,7 +92,7 @@ function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir }) {
         assert(filePathRelativeUserRootDir.startsWith('../'));
         return {
             filePathAbsoluteUserRootDir: null,
-            filePathRelativeUserRootDir
+            filePathRelativeUserRootDir,
         };
     }
     else {
@@ -124,7 +124,7 @@ function getModuleFilePath(moduleId, config) {
     assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
     const { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir } = getFilePathRelative({
         filePathAbsoluteFilesystem,
-        userRootDir
+        userRootDir,
     });
     return { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
 }
@@ -132,17 +132,17 @@ function assertModuleId(moduleId) {
     assertPosixPath(moduleId);
     assertFilePathAbsoluteFilesystem(moduleId); // Can moduleId be something else than the filesystem absolute path?
 }
-function getFilePathToShowToUserFromUnkown(
-// We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
-filePathUnkown, userRootDir) {
+function getFilePathToShowToUserFromUnknown(
+// We don't have any guarantee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
+filePathUnknown, userRootDir) {
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);
-    filePathUnkown = cleanFilePathUnkown(filePathUnkown);
-    if (!filePathUnkown.startsWith(userRootDir)) {
-        return filePathUnkown;
+    filePathUnknown = cleanFilePathUnknown(filePathUnknown);
+    if (!filePathUnknown.startsWith(userRootDir)) {
+        return filePathUnknown;
     }
     else {
-        return getFilePathAbsoluteUserRootDir2(filePathUnkown, userRootDir);
+        return getFilePathAbsoluteUserRootDir2(filePathUnknown, userRootDir);
     }
 }
 function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir) {
@@ -152,7 +152,7 @@ function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir
         filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir;
     return filePathAbsoluteUserRootDir;
 }
-function cleanFilePathUnkown(filePathUnknown) {
+function cleanFilePathUnknown(filePathUnknown) {
     filePathUnknown = toPosixPath(filePathUnknown);
     filePathUnknown = cleanModuleId(filePathUnknown);
     return filePathUnknown;

package/dist/esm/node/{plugin → vite}/shared/getHttpRequestAsyncStore.js

@@ -10,7 +10,7 @@ export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
 import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
 import { assert, assertIsNotProductionRuntime, isObject, unique } from '../utils.js';
-import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
+import { getConfigBuildErrorFormatted } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
 import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 import { isDeepStrictEqual } from 'node:util';
@@ -35,7 +35,7 @@ async function installHttpRequestAsyncStore() {
             if (loggedErrors.has(err) ||
                 Array.from(loggedErrors).some((errAlreadyLogged) => isEquivalent(err, errAlreadyLogged))) {
                 // In principle, some random message can be shown between the non-swallowed error and this logErrorDebugNote() call.
-                // We take a leap of faith that it happens only seldomly and that it's worth the risk.
+                // We take a leap of faith that it happens only seldom and that it's worth the risk.
                 logErrorDebugNote();
                 return true;
             }
@@ -47,7 +47,7 @@ async function installHttpRequestAsyncStore() {
             httpRequestId,
             markErrorAsLogged,
             shouldErrorBeSwallowed,
-            errorDebugNoteAlreadyShown: false
+            errorDebugNoteAlreadyShown: false,
         };
         const pageContextReturn = await asyncLocalStorage.run(store, renderPage);
         return { pageContextReturn };
@@ -79,9 +79,9 @@ function isEquivalent(err1, err2) {
         'message',
         'stack',
         ...Object.keys(err1),
-        ...Object.keys(err2)
+        ...Object.keys(err2),
     ]).every((k) => {
-        // isDeepStrictEqual() need to compare error.position wich is an object.
+        // isDeepStrictEqual() need to compare error.position which is an object.
         if (isDeepStrictEqual(err1[k], err2[k]))
             return true;
         // console.log('diff', k)

package/dist/esm/node/{plugin → vite}/shared/getOutDirs.js

@@ -131,8 +131,8 @@ function normalizeOutDir(outDir) {
     return outDir;
 }
 function outDirIsAbsolutePath(outDir) {
-    // There doesn't seem to be a better alternative to determine whether `outDir` is an aboslute path
-    //  - Very unlikely that `outDir`'s first dir macthes the filesystem's first dir
+    // There doesn't seem to be a better alternative to determine whether `outDir` is an absolute path
+    //  - Very unlikely that `outDir`'s first dir matches the filesystem's first dir
     //    - Although more likely to happen with Docker
     return getFirstDir(outDir) === getFirstDir(process.cwd());
 }

package/dist/esm/node/{plugin → vite}/shared/getViteConfigRuntime.js

@@ -8,12 +8,12 @@ function getViteConfigRuntime(config) {
     const viteConfigRuntime = {
         root: config.root,
         build: {
-            outDir: outDirRoot
+            outDir: outDirRoot,
         },
         _baseViteOriginal: config._baseViteOriginal,
         vitePluginServerEntry: {
-            inject: config.vitePluginServerEntry?.inject
-        }
+            inject: config.vitePluginServerEntry?.inject,
+        },
     };
     return viteConfigRuntime;
 }

package/dist/esm/node/{plugin → vite}/shared/isAsset.js

@@ -34,5 +34,5 @@ const assetFileExtensions = [
     // other
     'webmanifest',
     'pdf',
-    'txt'
+    'txt',
 ];

package/dist/esm/node/{plugin → vite}/shared/isViteCliCall.js

@@ -55,7 +55,7 @@ function getViteConfigFromCli() {
             logLevel: options.logLevel,
             clearScreen: options.clearScreen,
             optimizeDeps: { force: options.force },
-            build: buildOptions
+            build: buildOptions,
         };
     });
     let configFromCli = null;