vike 0.4.159-commit-0424983 → 0.4.159-commit-d73533a

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

@@ -2,32 +2,31 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, mergeCumulativeValues, requireResolve, getOutDirs, deepEqual, assertKeys } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTmpFile, transpileAndExecuteFile } from './transpileAndExecuteFile.js';
-import { parseImportData } from './transformImports.js';
+import { isTmpFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
-import { assertPlusFileExport } from '../../../../../shared/page-configs/assertPlusFileExport.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
+import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileConfigEnv.js';
+import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-const filesEnv = new Map();
 function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
     vikeConfigDependencies.clear();
-    filesEnv.clear();
+    clearFilesEnvMap();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
     handleReloadSideEffects();
 }
@@ -101,7 +100,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         assert(configName);
         const interfaceFile = {
             filePath,
-            configMap: {
+            fileExportsByConfigName: {
                 [configName]: {}
             },
             isConfigFile: false,
@@ -135,23 +134,6 @@ function getConfigDefinition(configDefinitionsRelevant, configName, filePathToSh
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
-    const { filePathToShowToUser } = interfaceValueFile.filePath;
-    assertPlusFileExport(fileExports, filePathToShowToUser, configName);
-    Object.entries(fileExports).forEach(([exportName, configValue]) => {
-        const configName_ = exportName === 'default' ? configName : exportName;
-        interfaceValueFile.configMap[configName_] = { configValue };
-    });
-}
-async function loadImportedFile(filePath, userRootDir, importedFilesLoaded) {
-    const f = filePath.filePathAbsoluteFilesystem;
-    if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(filePath, true, userRootDir).then((r) => r.fileExports);
-    }
-    const fileExports = await importedFilesLoaded[f];
-    return fileExports;
-}
 function isConfigEnv(configDef, configName) {
     const configEnv = configDef.env;
     if (configDef.cumulative) {
@@ -164,7 +146,7 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
         filePath,
-        configMap: {},
+        fileExportsByConfigName: {},
         isConfigFile: true,
         isValueFile: false,
         isConfigExtend,
@@ -172,7 +154,7 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     };
     const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
     Object.entries(fileExport).forEach(([configName, configValue]) => {
-        interfaceFile.configMap[configName] = { configValue };
+        interfaceFile.fileExportsByConfigName[configName] = { configValue };
     });
     return interfaceFile;
 }
@@ -182,7 +164,7 @@ function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
         const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.configMap).forEach((configName) => {
+            Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
                 assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
             });
         });
@@ -296,7 +278,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
 function interfacefileIsAlreaydLoaded(interfaceFile) {
-    const configMapValues = Object.values(interfaceFile.configMap);
+    const configMapValues = Object.values(interfaceFile.fileExportsByConfigName);
     const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
     if (isAlreadyLoaded) {
         assert(configMapValues.every((conf) => 'configValue' in conf));
@@ -337,7 +319,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
         Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
             interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.configMap).forEach((configName) => {
+                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
                     if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
                         assertUsage(false, [
                             `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(configName)} which is global:`,
@@ -378,7 +360,7 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
     const sourcesInfo = [];
     // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
     for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
-        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.configMap[configName]);
+        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.fileExportsByConfigName[configName]);
         if (interfaceFilesDefiningConfig.length === 0)
             continue;
         const visited = new WeakSet();
@@ -456,13 +438,14 @@ function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded) {
-    const conf = interfaceFile.configMap[configName];
+    const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
     const configEnv = configDef.env;
     const definedAtConfigFile = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
+    // +client.js
     if (configDef._valueIsFilePath) {
         let definedAt;
         let valueFilePath;
@@ -491,9 +474,11 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         };
         return configValueSource;
     }
+    // +config.js
     if (interfaceFile.isConfigFile) {
         assert('configValue' in conf);
         const { configValue } = conf;
+        // fake import
         const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
             const configValueSource = {
@@ -501,12 +486,14 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 valueIsImportedAtRuntime: true,
                 definedAt: import_
             };
-            // Load config value
-            if (isConfigEnv(configDef, configName)) {
+            // Load fake import
+            if (isConfigEnv(configDef, configName) &&
+                // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
+                configName !== 'extends') {
                 if (import_.filePathAbsoluteFilesystem) {
                     assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
-                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
-                    configValueSource.value = fileExports[import_.fileExportName];
+                    const fileExport = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExport;
                 }
                 else {
                     const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
@@ -515,17 +502,17 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             }
             return configValueSource;
         }
-        else {
-            const configValueSource = {
-                value: configValue,
-                configEnv,
-                valueIsImportedAtRuntime: false,
-                definedAt: definedAtConfigFile
-            };
-            return configValueSource;
-        }
+        // Defined by config file, i.e. +config.js file
+        const configValueSource = {
+            value: configValue,
+            configEnv,
+            valueIsImportedAtRuntime: false,
+            definedAt: definedAtConfigFile
+        };
+        return configValueSource;
     }
-    else if (interfaceFile.isValueFile) {
+    // Defined by value file, i.e. +{configName}.js
+    if (interfaceFile.isValueFile) {
         const valueAlreadyLoaded = 'configValue' in conf;
         assert(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
@@ -546,25 +533,9 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     assert(false);
 }
-function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
-    assertPosixPath(filePathForEnvCheck);
-    if (!filesEnv.has(filePathForEnvCheck)) {
-        filesEnv.set(filePathForEnvCheck, []);
-    }
-    const fileEnv = filesEnv.get(filePathForEnvCheck);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
-    if (configDifferentEnv) {
-        assertUsage(false, [
-            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(JSON.stringify(c.configEnv))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
-        ].join('\n'));
-    }
-}
 function isDefiningPage(interfaceFiles) {
     for (const interfaceFile of interfaceFiles) {
-        const configNames = Object.keys(interfaceFile.configMap);
+        const configNames = Object.keys(interfaceFile.fileExportsByConfigName);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -574,90 +545,11 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
-    if (typeof configValue !== 'string')
-        return null;
-    const importData = parseImportData(configValue);
-    if (!importData)
-        return null;
-    const { importPath, exportName } = importData;
-    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
-    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    if (importPath.startsWith('.')) {
-        // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
-        // ```
-        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
-        // ```
-        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
-    }
-    else {
-        // importPath can be:
-        //  - an npm package import
-        //  - a path alias
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir: null,
-            filePathAbsoluteVite: importPath,
-            filePathToShowToUser: importPath,
-            importPathAbsolute: importPath
-        };
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
-    }
-}
-function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
-    assertPosixPath(userRootDir);
-    let filePathRelativeToUserRootDir;
-    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
-    }
-    else {
-        assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
-        // None of the following works. Seems to be a Vite bug?
-        // /*
-        // assert(filePathAbsoluteFilesystem.startsWith('/'))
-        // filePath = `/@fs${filePathAbsoluteFilesystem}`
-        // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
-        // assert(filePathRelativeToUserRootDir.startsWith('../'))
-        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
-        // //*/
-    }
-    assertPosixPath(filePathRelativeToUserRootDir);
-    assert(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
-}
-function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(root);
-    assert(filePathAbsoluteFilesystem.startsWith(root));
-    let vitePath = path.posix.relative(root, filePathAbsoluteFilesystem);
-    assert(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
-    vitePath = '/' + vitePath;
-    return vitePath;
-}
 function getConfigDefinitions(interfaceFilesRelevant) {
     const configDefinitions = { ...configDefinitionsBuiltIn };
     Object.entries(interfaceFilesRelevant).forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
-            const configMeta = interfaceFile.configMap['meta'];
+            const configMeta = interfaceFile.fileExportsByConfigName['meta'];
             if (!configMeta)
                 return;
             const meta = configMeta.configValue;
@@ -840,108 +732,22 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
-    const { filePathAbsoluteFilesystem } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir, isConfigOfExtension);
-    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
-        ...visited,
-        filePathAbsoluteFilesystem
-    ]);
-    const configFile = {
-        fileExports,
-        filePath: configFilePath,
-        extendsFilePaths
-    };
-    return { configFile, extendsConfigs };
-}
-function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
-    const idx = visited.indexOf(filePathAbsoluteFilesystem);
-    if (idx === -1)
-        return;
-    const loop = visited.slice(idx);
-    assert(loop[0] === filePathAbsoluteFilesystem);
-    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
-}
-async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
-    const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
-    const extendsConfigFiles = [];
-    extendsImportData.map((importData) => {
-        const { importPath: importPath } = importData;
-        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
-        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
-        assertExtendsImportPath(importPath, filePathAbsoluteFilesystem, configFilePath);
-        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
-        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
-        extendsConfigFiles.push({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteVite,
-            filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathAbsoluteVite,
-            importPathAbsolute: importPath
-        });
-    });
-    const extendsConfigs = [];
-    await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
-        const result = await loadConfigFile(configFilePath, userRootDir, visited, true);
-        extendsConfigs.push(result.configFile);
-        extendsConfigs.push(...result.extendsConfigs);
-    }));
-    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
-    return { extendsConfigs, extendsFilePaths };
-}
-function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(userRootDir);
-    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        return null;
-    }
-    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
-    if (!filePathRelativeToUserRootDir.startsWith('/'))
-        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
-    return filePathRelativeToUserRootDir;
-}
-function assertExtendsImportPath(importPath, filePath, configFilePath) {
-    if (isNpmPackageImport(importPath)) {
-        const fileDir = path.posix.dirname(filePath) + '/';
-        const fileName = path.posix.basename(filePath);
-        const fileNameBaseCorrect = '+config';
-        const [fileNameBase, ...fileNameRest] = fileName.split('.');
-        const fileNameCorrect = [fileNameBaseCorrect, ...fileNameRest].join('.');
-        assertWarning(fileNameBase === fileNameBaseCorrect, `Rename ${fileName} to ${fileNameCorrect} in ${fileDir}`, {
-            onlyOnce: true
-        });
-    }
-    else {
-        assertWarning(false, `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this feature.`, { onlyOnce: true });
-    }
-}
-function getExtendsImportData(configFileExports, configFilePath) {
-    const { filePathToShowToUser } = configFilePath;
-    const configFileExport = getConfigFileExport(configFileExports, filePathToShowToUser);
-    const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
-    let extendList;
-    if (!('extends' in configFileExport)) {
-        return [];
-    }
-    else if (hasProp(configFileExport, 'extends', 'string')) {
-        extendList = [configFileExport.extends];
-    }
-    else if (hasProp(configFileExport, 'extends', 'string[]')) {
-        extendList = configFileExport.extends;
-    }
-    else {
-        assertUsage(false, wrongUsage);
-    }
-    const extendsImportData = extendList.map((importDataSerialized) => {
-        const importData = parseImportData(importDataSerialized);
-        assertUsage(importData, wrongUsage);
-        return importData;
-    });
-    return extendsImportData;
-}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split('/')
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join('/')
+    assertUsage(
+      !dir.includes('+'),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes('+'),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+*/
 function isGlobalConfig(configName) {
     if (configName === 'prerender')
         return false;
@@ -1024,32 +830,6 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
-    assertPosixPath(importerFilePathAbsolute);
-    const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
-    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
-    return filePathAbsoluteFilesystem;
-}
-function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = importData;
-    const { filePathToShowToUser } = importerFilePath;
-    if (!filePathAbsoluteFilesystem) {
-        const importPathString = pc.cyan(`'${importPath}'`);
-        const errIntro = importStringWasGenerated
-            ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
-        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            assertUsage(false, `${errIntro2} point to an existing file?`);
-        }
-        else {
-            assertUsage(false, `${errIntro2} exist?`);
-        }
-    }
-}
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }

package/dist/esm/node/plugin/shared/getHttpRequestAsyncStore.js

@@ -12,7 +12,7 @@ export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
 import { renderPage_addWrapper } from '../../runtime/renderPage.js';
 import { assert, assertIsNotProductionRuntime, isObject } from '../utils.js';
-import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
+import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
 import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 assertIsNotProductionRuntime();

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -18,7 +18,7 @@ import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, i
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from './isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
+import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logWithVikeTag, logWithViteTag, logDirectly, isFirstLog, screenHasErrors, clearScreen, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';
 import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';

package/dist/esm/utils/projectInfo.d.ts

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.159-commit-0424983";
+declare const PROJECT_VERSION: "0.4.159-commit-d73533a";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.159-commit-0424983";
+    projectVersion: "0.4.159-commit-d73533a";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.159-commit-0424983';
+const PROJECT_VERSION = '0.4.159-commit-d73533a';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.159-commit-0424983",
+  "version": "0.4.159-commit-d73533a",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",