vike 0.4.159-commit-a6bc208 → 0.4.159-commit-d73533a

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

@@ -8,29 +8,28 @@ const utils_js_1 = require("../../../utils.js");
 const path_1 = __importDefault(require("path"));
 const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
 const filesystemRouting_js_1 = require("./getVikeConfig/filesystemRouting.js");
-const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
-const transformImports_js_1 = require("./transformImports.js");
+const transpileAndExecuteFile_js_1 = require("./getVikeConfig/transpileAndExecuteFile.js");
 const isConfigInvalid_js_1 = require("../../../../runtime/renderPage/isConfigInvalid.js");
 const globalContext_js_1 = require("../../../../runtime/globalContext.js");
 const loggerNotProd_js_1 = require("../../../shared/loggerNotProd.js");
 const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/removeSuperfluousViteLog.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
-const assertPlusFileExport_js_1 = require("../../../../../shared/page-configs/assertPlusFileExport.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
 const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 const crawlPlusFiles_js_1 = require("./getVikeConfig/crawlPlusFiles.js");
 const getConfigFileExport_js_1 = require("./getConfigFileExport.js");
+const loadFileConfigEnv_js_1 = require("./getVikeConfig/loadFileConfigEnv.js");
+const resolveImportPath_js_1 = require("./getVikeConfig/resolveImportPath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
 exports.vikeConfigDependencies = vikeConfigDependencies;
-const filesEnv = new Map();
 function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
     vikeConfigDependencies.clear();
-    filesEnv.clear();
+    (0, resolveImportPath_js_1.clearFilesEnvMap)();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
     handleReloadSideEffects();
 }
@@ -90,7 +89,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
     let interfaceFilesByLocationId = {};
     // Config files
     await Promise.all(configFiles.map(async (filePath) => {
-        const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
+        const { configFile, extendsConfigs } = await (0, loadFileConfigEnv_js_1.loadConfigFile)(filePath, userRootDir, [], false);
         const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
         const locationId = (0, filesystemRouting_js_1.getLocationId)(filePath.filePathAbsoluteVite);
         interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
@@ -106,7 +105,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         (0, utils_js_1.assert)(configName);
         const interfaceFile = {
             filePath,
-            configMap: {
+            fileExportsByConfigName: {
                 [configName]: {}
             },
             isConfigFile: false,
@@ -119,7 +118,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
             const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn, configName);
             if (configDef && isConfigEnv(configDef, configName)) {
-                await loadValueFile(interfaceFile, configName, userRootDir);
+                await (0, loadFileConfigEnv_js_1.loadValueFile)(interfaceFile, configName, userRootDir);
             }
         }
         {
@@ -140,23 +139,6 @@ function getConfigDefinition(configDefinitionsRelevant, configName, filePathToSh
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, true, userRootDir);
-    const { filePathToShowToUser } = interfaceValueFile.filePath;
-    (0, assertPlusFileExport_js_1.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] = (0, transpileAndExecuteFile_js_1.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) {
@@ -169,7 +151,7 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
         filePath,
-        configMap: {},
+        fileExportsByConfigName: {},
         isConfigFile: true,
         isValueFile: false,
         isConfigExtend,
@@ -177,7 +159,7 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     };
     const fileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(fileExports, filePath.filePathToShowToUser);
     Object.entries(fileExport).forEach(([configName, configValue]) => {
-        interfaceFile.configMap[configName] = { configValue };
+        interfaceFile.fileExportsByConfigName[configName] = { configValue };
     });
     return interfaceFile;
 }
@@ -187,7 +169,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);
             });
         });
@@ -258,7 +240,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
                 return;
             // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
             (0, utils_js_1.assert)(!(configName in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configName, userRootDir);
+            await (0, loadFileConfigEnv_js_1.loadValueFile)(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
         await Promise.all((0, utils_js_1.objectEntries)(configDefinitionsRelevant)
@@ -301,7 +283,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     (0, utils_js_1.assertUsage)(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${picocolors_1.default.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) {
         (0, utils_js_1.assert)(configMapValues.every((conf) => 'configValue' in conf));
@@ -342,7 +324,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path_1.default.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 (!(0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds) && isGlobalConfig(configName)) {
                         (0, utils_js_1.assertUsage)(false, [
                             `${interfaceFile.filePath.filePathToShowToUser} defines the config ${picocolors_1.default.cyan(configName)} which is global:`,
@@ -383,7 +365,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();
@@ -461,19 +443,20 @@ 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];
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
     const definedAtConfigFile = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
+    // +client.js
     if (configDef._valueIsFilePath) {
         let definedAt;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
-            const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            const import_ = (0, resolveImportPath_js_1.resolveImport)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
             const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, { definedAt: definedAtConfigFile });
             (0, utils_js_1.assertUsage)(import_, `${configDefinedAt} should be an import`);
             valueFilePath = import_.filePathAbsoluteVite;
@@ -496,22 +479,26 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         };
         return configValueSource;
     }
+    // +config.js
     if (interfaceFile.isConfigFile) {
         (0, utils_js_1.assert)('configValue' in conf);
         const { configValue } = conf;
-        const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+        // fake import
+        const import_ = (0, resolveImportPath_js_1.resolveImport)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
             const configValueSource = {
                 configEnv,
                 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) {
                     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
-                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
-                    configValueSource.value = fileExports[import_.fileExportName];
+                    const fileExport = await (0, loadFileConfigEnv_js_1.loadImportedFile)(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExport;
                 }
                 else {
                     const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSource);
@@ -520,17 +507,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;
         (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
@@ -551,25 +538,9 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     (0, utils_js_1.assert)(false);
 }
-function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
-    (0, utils_js_1.assertPosixPath)(filePathForEnvCheck);
-    if (!filesEnv.has(filePathForEnvCheck)) {
-        filesEnv.set(filePathForEnvCheck, []);
-    }
-    const fileEnv = filesEnv.get(filePathForEnvCheck);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
-    if (configDifferentEnv) {
-        (0, utils_js_1.assertUsage)(false, [
-            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.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;
         }
@@ -579,90 +550,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 = (0, transformImports_js_1.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) {
-    (0, utils_js_1.assertPosixPath)(userRootDir);
-    let filePathRelativeToUserRootDir;
-    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
-    }
-    else {
-        (0, utils_js_1.assertUsage)(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${picocolors_1.default.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
-        // //*/
-    }
-    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
-    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
-}
-function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPosixPath)(root);
-    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(root));
-    let vitePath = path_1.default.posix.relative(root, filePathAbsoluteFilesystem);
-    (0, utils_js_1.assert)(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
-    vitePath = '/' + vitePath;
-    return vitePath;
-}
 function getConfigDefinitions(interfaceFilesRelevant) {
     const configDefinitions = { ...configDefinitionsBuiltIn_js_1.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;
@@ -845,96 +737,22 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
-    const { filePathAbsoluteFilesystem } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.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);
-    (0, utils_js_1.assert)(loop[0] === filePathAbsoluteFilesystem);
-    (0, utils_js_1.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);
-        warnUserLandExtension(importPath, 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) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPosixPath)(userRootDir);
-    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        return null;
-    }
-    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
-    if (!filePathRelativeToUserRootDir.startsWith('/'))
-        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
-    return filePathRelativeToUserRootDir;
-}
-function warnUserLandExtension(importPath, configFilePath) {
-    (0, utils_js_1.assertWarning)((0, utils_js_1.isNpmPackageImport)(importPath), `${configFilePath.filePathToShowToUser} uses ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.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.`, { onlyOnce: true });
-}
-function getExtendsImportData(configFileExports, configFilePath) {
-    const { filePathToShowToUser } = configFilePath;
-    const configFileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(configFileExports, filePathToShowToUser);
-    const wrongUsage = `${filePathToShowToUser} sets the config ${picocolors_1.default.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
-    let extendList;
-    if (!('extends' in configFileExport)) {
-        return [];
-    }
-    else if ((0, utils_js_1.hasProp)(configFileExport, 'extends', 'string')) {
-        extendList = [configFileExport.extends];
-    }
-    else if ((0, utils_js_1.hasProp)(configFileExport, 'extends', 'string[]')) {
-        extendList = configFileExport.extends;
-    }
-    else {
-        (0, utils_js_1.assertUsage)(false, wrongUsage);
-    }
-    const extendsImportData = extendList.map((importDataSerialized) => {
-        const importData = (0, transformImports_js_1.parseImportData)(importDataSerialized);
-        (0, utils_js_1.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;
@@ -1017,32 +835,6 @@ function determineIsErrorPage(routeFilesystem) {
     (0, utils_js_1.assertPosixPath)(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
-    (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
-    const cwd = path_1.default.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 = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
-    return filePathAbsoluteFilesystem;
-}
-function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = importData;
-    const { filePathToShowToUser } = importerFilePath;
-    if (!filePathAbsoluteFilesystem) {
-        const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
-        const errIntro = importStringWasGenerated
-            ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
-        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
-        }
-        else {
-            (0, utils_js_1.assertUsage)(false, `${errIntro2} exist?`);
-        }
-    }
-}
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }

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

@@ -29,7 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installHttpRequestAsyncStore = exports.getHttpRequestAsyncStore = void 0;
 const renderPage_js_1 = require("../../runtime/renderPage.js");
 const utils_js_1 = require("../utils.js");
-const transpileAndExecuteFile_js_1 = require("../plugins/importUserCode/v1-design/transpileAndExecuteFile.js");
+const transpileAndExecuteFile_js_1 = require("../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js");
 const loggerNotProd_js_1 = require("./loggerNotProd.js");
 const errorWithCodeSnippet_js_1 = require("./loggerNotProd/errorWithCodeSnippet.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();

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

@@ -17,7 +17,7 @@ const utils_js_1 = require("../utils.js");
 const getHttpRequestAsyncStore_js_1 = require("./getHttpRequestAsyncStore.js");
 const isErrorDebug_js_1 = require("./isErrorDebug.js");
 const errorWithCodeSnippet_js_1 = require("./loggerNotProd/errorWithCodeSnippet.js");
-const transpileAndExecuteFile_js_1 = require("../plugins/importUserCode/v1-design/transpileAndExecuteFile.js");
+const transpileAndExecuteFile_js_1 = require("../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js");
 const log_js_1 = require("./loggerNotProd/log.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isNewError_js_1 = require("../../runtime/renderPage/isNewError.js");

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.159-commit-a6bc208';
+const PROJECT_VERSION = '0.4.159-commit-d73533a';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

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

@@ -0,0 +1,21 @@
+export { loadImportedFile };
+export { loadValueFile };
+export { loadConfigFile };
+export type { ImportedFilesLoaded };
+export type { ConfigFile };
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { InterfaceValueFile } from '../getVikeConfig.js';
+type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>;
+type ConfigFile = {
+    fileExports: Record<string, unknown>;
+    filePath: FilePathResolved;
+    extendsFilePaths: string[];
+};
+declare function loadImportedFile(import_: FilePathResolved & {
+    fileExportName: string;
+}, userRootDir: string, importedFilesLoaded: ImportedFilesLoaded): Promise<unknown>;
+declare function loadValueFile(interfaceValueFile: InterfaceValueFile, configName: string, userRootDir: string): Promise<void>;
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isConfigOfExtension: boolean): Promise<{
+    configFile: ConfigFile;
+    extendsConfigs: ConfigFile[];
+}>;