vike 0.4.159 → 0.4.160-commit-a1101c1

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

@@ -8,28 +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 replaceImportStatements_js_1 = require("./replaceImportStatements.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 assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.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();
 }
@@ -89,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, []);
+        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] ?? [];
@@ -105,7 +105,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         (0, utils_js_1.assert)(configName);
         const interfaceFile = {
             filePath,
-            configMap: {
+            fileExportsByConfigName: {
                 [configName]: {}
             },
             isConfigFile: false,
@@ -118,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);
             }
         }
         {
@@ -139,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, assertExports_js_1.assertExportsOfValueFile)(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) {
@@ -168,16 +151,15 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
         filePath,
-        configMap: {},
+        fileExportsByConfigName: {},
         isConfigFile: true,
         isValueFile: false,
         isConfigExtend,
         extendsFilePaths
     };
-    const { filePathToShowToUser } = filePath;
-    (0, assertExports_js_1.assertExportsOfConfigFile)(fileExports, filePathToShowToUser);
-    Object.entries(fileExports.default).forEach(([configName, configValue]) => {
-        interfaceFile.configMap[configName] = { configValue };
+    const fileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(fileExports, filePath.filePathToShowToUser);
+    Object.entries(fileExport).forEach(([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, replaceImportStatements_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]) => {
+    Object.entries(interfaceFilesRelevant).reverse().forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
-            const configMeta = interfaceFile.configMap['meta'];
+            const configMeta = interfaceFile.fileExportsByConfigName['meta'];
             if (!configMeta)
                 return;
             const meta = configMeta.configValue;
@@ -845,109 +737,22 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsoluteFilesystem } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, false, userRootDir);
-    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);
-        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);
-        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 assertExtendsImportPath(importPath, filePath, configFilePath) {
-    if ((0, utils_js_1.isNpmPackageImport)(importPath)) {
-        const fileDir = path_1.default.posix.dirname(filePath) + '/';
-        const fileName = path_1.default.posix.basename(filePath);
-        const fileNameBaseCorrect = '+config';
-        const [fileNameBase, ...fileNameRest] = fileName.split('.');
-        const fileNameCorrect = [fileNameBaseCorrect, ...fileNameRest].join('.');
-        (0, utils_js_1.assertWarning)(fileNameBase === fileNameBaseCorrect, `Rename ${fileName} to ${fileNameCorrect} in ${fileDir}`, {
-            onlyOnce: true
-        });
-    }
-    else {
-        (0, utils_js_1.assertWarning)(false, `${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 feature.`, { onlyOnce: true });
-    }
-}
-function getExtendsImportData(configFileExports, configFilePath) {
-    const { filePathToShowToUser } = configFilePath;
-    (0, assertExports_js_1.assertExportsOfConfigFile)(configFileExports, filePathToShowToUser);
-    const defaultExports = configFileExports.default;
-    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 defaultExports)) {
-        return [];
-    }
-    else if ((0, utils_js_1.hasProp)(defaultExports, 'extends', 'string')) {
-        extendList = [defaultExports.extends];
-    }
-    else if ((0, utils_js_1.hasProp)(defaultExports, 'extends', 'string[]')) {
-        extendList = defaultExports.extends;
-    }
-    else {
-        (0, utils_js_1.assertUsage)(false, wrongUsage);
-    }
-    const extendsImportData = extendList.map((importDataSerialized) => {
-        const importData = (0, replaceImportStatements_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;
@@ -1030,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/plugins/previewConfig.js

@@ -33,7 +33,7 @@ function previewConfig() {
                - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
             config.appType = 'mpa'
             */
-            (0, utils_js_1.markEnvAsPreview)();
+            (0, utils_js_1.markEnvAsVitePreview)();
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.

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

@@ -22,10 +22,10 @@ exports.logWithVikeTag = logWithVikeTag;
 function getProjectTag(showVikeVersion) {
     let projectTag;
     if (showVikeVersion) {
-        projectTag = `[${utils_js_1.projectInfo.npmPackageName}@${utils_js_1.projectInfo.projectVersion}]`;
+        projectTag = `[vike@${utils_js_1.projectInfo.projectVersion}]`;
     }
     else {
-        projectTag = `[${utils_js_1.projectInfo.npmPackageName}]`;
+        projectTag = `[vike]`;
     }
     return projectTag;
 }
@@ -89,7 +89,7 @@ function prependTags(msg, projectTag, category, logType) {
             return picocolors_1.default.yellow(s);
         if (projectTag === '[vite]')
             return picocolors_1.default.bold(picocolors_1.default.cyan(s));
-        if (projectTag.startsWith(`[${utils_js_1.projectInfo.npmPackageName}`))
+        if (projectTag.startsWith(`[vike`))
             return picocolors_1.default.bold(picocolors_1.default.cyan(s));
         (0, utils_js_1.assert)(false);
     };

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/node/runtime/globalContext.js

@@ -157,7 +157,8 @@ function assertNodeEnv(hasViteDevServer) {
     const nodeEnv = (0, utils_js_1.getNodeEnv)();
     if (nodeEnv === null || nodeEnv === 'test')
         return;
-    const isDevNodeEnv = [undefined, '', 'dev', 'development'].includes(nodeEnv);
-    // calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    (0, utils_js_1.assertWarning)(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+    const isDevNodeEnv = (0, utils_js_1.isNodeEnvDev)();
+    // - Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    // - We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value).
+    (0, utils_js_1.assertUsage)(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`);
 }

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -91,7 +91,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     const positionJavaScriptEntry = (() => {
         if (pageContext._pageContextPromise) {
             (0, utils_js_1.assertWarning)(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time as progressive hydration won't work", { onlyOnce: true });
-            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/stream#initial-data-after-stream-end
+            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/streaming#initial-data-after-stream-end
             return 'HTML_END';
         }
         if (injectToStream) {

package/dist/cjs/node/runtime/html/renderHtml.js

@@ -186,7 +186,7 @@ async function renderTemplate(templateContent, pageContext) {
             const varType = typeof templateVar;
             const streamNote = ['boolean', 'number', 'bigint', 'symbol'].includes(varType)
                 ? null
-                : '(See https://vike.dev/stream for HTML streaming.)';
+                : '(See https://vike.dev/streaming for HTML streaming.)';
             (0, utils_js_1.assertUsage)(varType === 'string', getErrMsg(picocolors_1.default.cyan(`typeof htmlVar === "${varType}"`), streamNote));
         }
         {

package/dist/cjs/node/runtime/html/stream.js

@@ -631,7 +631,7 @@ exports.isStream = isStream;
 const __streamPipeWeb = '__streamPipeWeb';
 /** @deprecated */
 function pipeWebStream(pipe) {
-    (0, utils_js_1.assertWarning)(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+    (0, utils_js_1.assertWarning)(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
         showStackTrace: true
     });
@@ -668,7 +668,7 @@ exports.isStreamPipeWeb = isStreamPipeWeb;
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+    (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
         showStackTrace: true
     });

package/dist/cjs/node/runtime/renderPage/executeOnRenderHtmlHook.js

@@ -125,11 +125,11 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         const val = hookReturnValue.pageContext;
         const errBegin = `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext }')}, but ${picocolors_1.default.cyan('pageContext')}`;
         if ((0, utils_js_1.isPromise)(val) || (0, utils_js_1.isCallable)(val)) {
-            (0, utils_js_1.assertWarning)(!(0, utils_js_1.isPromise)(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/stream#initial-data-after-stream-end`, { onlyOnce: true });
+            (0, utils_js_1.assertWarning)(!(0, utils_js_1.isPromise)(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/streaming#initial-data-after-stream-end`, { onlyOnce: true });
             pageContextPromise = val;
         }
         else {
-            (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(val), `${errBegin} should be an object or an async function, see https://vike.dev/stream#initial-data-after-stream-end`);
+            (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(val), `${errBegin} should be an object or an async function, see https://vike.dev/streaming#initial-data-after-stream-end`);
             (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(val, renderHook);
             pageContextProvidedByRenderHook = val;
         }

package/dist/cjs/node/runtime/renderPage/getHttpResponseBody.js

@@ -8,7 +8,7 @@ const stream_js_1 = require("../html/stream.js");
 const utils_js_1 = require("../utils.js");
 const renderHtml_js_1 = require("../html/renderHtml.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const streamDocs = 'See https://vike.dev/stream for more information.';
+const streamDocs = 'See https://vike.dev/streaming for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
         (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} instead`));