vike 0.4.160-commit-a1101c1 → 0.4.160-commit-facd36e

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

@@ -2,7 +2,7 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } 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';
@@ -17,8 +17,9 @@ 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 { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
+import { resolveFilePathRelativeToUserRootDir } from './getVikeConfig/resolveFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -82,69 +83,77 @@ 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 interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
-        const locationId = getLocationId(filePath.filePathAbsoluteVite);
-        interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-        interfaceFilesByLocationId[locationId].push(interfaceFile);
-        extendsConfigs.forEach((extendsConfig) => {
-            const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true);
-            interfaceFilesByLocationId[locationId].push(interfaceFile);
-        });
-    }));
-    // Value files
-    await Promise.all(valueFiles.map(async (filePath) => {
-        const configName = getConfigName(filePath.filePathAbsoluteVite);
-        assert(configName);
-        const interfaceFile = {
-            filePath,
-            fileExportsByConfigName: {
-                [configName]: {}
-            },
-            isConfigFile: false,
-            isValueFile: true,
-            configName
-        };
-        {
-            // We don't have access to the custom config definitions defined by the user yet.
-            //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
-            //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
-            if (configDef && isConfigEnv(configDef, configName)) {
-                await loadValueFile(interfaceFile, configName, userRootDir);
-            }
-        }
-        {
-            const locationId = getLocationId(filePath.filePathAbsoluteVite);
+    await Promise.all([
+        // Config files
+        ...configFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            assert(filePathRelativeToUserRootDir);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
+            assert(filePath.filePathRelativeToUserRootDir);
+            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[locationId].push(interfaceFile);
-        }
-    }));
+            extendsConfigs.forEach((extendsConfig) => {
+                /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
+                ```js
+                // /pages/admin/+config.h.js
+        
+                import vikeVue from 'vike-vue/config'
+                // Should only apply to /pages/admin/**
+                export default { extends: [vikeVue] }
+                ```
+                ```js
+                // /pages/marketing/+config.h.js
+        
+                import vikeReact from 'vike-react/config'
+                // Should only apply to /pages/marketing/**
+                export default { extends: [vikeReact] }
+                ```
+                */
+                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
+                interfaceFilesByLocationId[locationId].push(interfaceFile);
+            });
+        }),
+        // Value files
+        ...valueFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            assert(filePathRelativeToUserRootDir);
+            const configName = getConfigName(filePathRelativeToUserRootDir);
+            assert(configName);
+            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const interfaceFile = {
+                locationId,
+                filePath,
+                fileExportsByConfigName: {
+                    [configName]: {}
+                },
+                isConfigFile: false,
+                isValueFile: true,
+                configName
+            };
+            {
+                // We don't have access to the custom config definitions defined by the user yet.
+                //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
+                //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
+                const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
+                if (configDef && isConfigEnv(configDef, configName)) {
+                    await loadValueFile(interfaceFile, configName, userRootDir);
+                }
+            }
+            {
+                interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
+                interfaceFilesByLocationId[locationId].push(interfaceFile);
+            }
+        })
+    ]);
     assertAllConfigsAreKnown(interfaceFilesByLocationId);
     return interfaceFilesByLocationId;
 }
-function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
-    const configDef = configDefinitionsRelevant[configName];
-    assertConfigExists(configName, Object.keys(configDefinitionsRelevant), filePathToShowToUser);
-    assert(configDef);
-    return configDef;
-}
-function getConfigDefinitionOptional(configDefinitions, configName) {
-    return configDefinitions[configName] ?? null;
-}
-function isConfigEnv(configDef, configName) {
-    const configEnv = configDef.env;
-    if (configDef.cumulative) {
-        // In principle we could lift that requirement (but it requires non-trivial modifications)
-        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
-    }
-    return !!configEnv.config;
-}
-function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
+function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
+        locationId,
         filePath,
         fileExportsByConfigName: {},
         isConfigFile: true,
@@ -160,12 +169,12 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
 }
 /** Show error message upon unknown config */
 function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+    objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
             Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
+                assertConfigExists(configName, Object.keys(configDefinitions), interfaceFile.filePath.filePathToShowToUser);
             });
         });
     });
@@ -215,11 +224,11 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
-    const pageConfigs = await Promise.all(Object.entries(interfaceFilesByLocationId)
+    const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         // Load value files of custom config-only configs
         await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
@@ -227,7 +236,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             const { configName } = interfaceFile;
             if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, interfaceFile.filePath.filePathToShowToUser);
+            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
             if (!isConfigEnv(configDef, configName))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
@@ -237,8 +246,8 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             assert(!(configName in configDefinitionsBuiltIn));
             await loadValueFile(interfaceFile, configName, userRootDir);
         }));
-        const configValueSources = {};
-        await Promise.all(objectEntries(configDefinitionsRelevant)
+        let configValueSources = {};
+        await Promise.all(objectEntries(configDefinitions)
             .filter(([configName]) => !isGlobalConfig(configName))
             .map(async ([configName, configDef]) => {
             const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
@@ -246,10 +255,11 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
                 return;
             configValueSources[configName] = sources;
         }));
+        configValueSources = sortConfigValueSources(configValueSources, locationId);
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitionsRelevant);
-        const configValuesComputed = getComputed(configValueSources, configDefinitionsRelevant);
-        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant);
+        applyEffectsAll(configValueSources, configDefinitions);
+        const configValuesComputed = getComputed(configValueSources, configDefinitions);
+        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitions);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
@@ -286,7 +296,7 @@ function interfacefileIsAlreaydLoaded(interfaceFile) {
     return isAlreadyLoaded;
 }
 function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(Object.entries(interfaceFilesByLocationId)
+    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesByLocationId)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
@@ -301,14 +311,14 @@ function getInterfaceFileList(interfaceFilesByLocationId) {
     return interfaceFiles;
 }
 async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const locationIds = Object.keys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = Object.fromEntries(Object.entries(interfaceFilesByLocationId).filter(([locationId]) => {
+    const locationIds = objectKeys(interfaceFilesByLocationId);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
     }));
     // Validate that global configs live in global interface files
     {
         const interfaceFilesGlobalPaths = [];
-        Object.entries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             assert(isGlobalLocation(locationId, locationIds));
             interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
                 if (filePathRelativeToUserRootDir) {
@@ -317,7 +327,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]) => {
+        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
             interfaceFiles.forEach((interfaceFile) => {
                 Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
                     if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
@@ -441,6 +451,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
     const configEnv = configDef.env;
+    const { locationId } = interfaceFile;
     const definedAtConfigFile = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
@@ -466,6 +477,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
+            locationId,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
@@ -482,6 +494,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
             const configValueSource = {
+                locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 definedAt: import_
@@ -504,6 +517,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         }
         // Defined by config file, i.e. +config.js file
         const configValueSource = {
+            locationId,
             value: configValue,
             configEnv,
             valueIsImportedAtRuntime: false,
@@ -516,6 +530,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const valueAlreadyLoaded = 'configValue' in conf;
         assert(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
+            locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             definedAt: {
@@ -546,8 +561,10 @@ function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
 function getConfigDefinitions(interfaceFilesRelevant) {
-    const configDefinitions = { ...configDefinitionsBuiltIn };
-    Object.entries(interfaceFilesRelevant).reverse().forEach(([_locationId, interfaceFiles]) => {
+    const configDefinitionsMerged = { ...configDefinitionsBuiltIn };
+    Object.entries(interfaceFilesRelevant)
+        .reverse()
+        .forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
             const configMeta = interfaceFile.fileExportsByConfigName['meta'];
             if (!configMeta)
@@ -566,13 +583,14 @@ function getConfigDefinitions(interfaceFilesRelevant) {
             });
             objectEntries(meta).forEach(([configName, configDefinition]) => {
                 // User can override an existing config definition
-                configDefinitions[configName] = {
-                    ...configDefinitions[configName],
+                configDefinitionsMerged[configName] = {
+                    ...configDefinitionsMerged[configName],
                     ...configDefinition
                 };
             });
         });
     });
+    const configDefinitions = configDefinitionsMerged;
     return configDefinitions;
 }
 function assertMetaValue(metaVal, configMetaDefinedAt) {
@@ -611,8 +629,8 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         }
     });
 }
-function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
-    objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+function applyEffectsAll(configValueSources, configDefinitions) {
+    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef.effect)
             return;
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
@@ -671,9 +689,9 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         }
     });
 }
-function getComputed(configValueSources, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitions) {
     const configValuesComputed = {};
-    objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
         const value = configDef._computed(configValueSources);
@@ -688,15 +706,7 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
-        return {
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathAbsoluteFilesystem,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-    });
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir));
     // TODO/v1-release: remove
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
@@ -748,22 +758,6 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
   )
 }
 */
-function isGlobalConfig(configName) {
-    if (configName === 'prerender')
-        return false;
-    const configNamesGlobal = getConfigNamesGlobal();
-    return arrayIncludes(configNamesGlobal, configName);
-}
-function getConfigNamesGlobal() {
-    return Object.keys(configDefinitionsBuiltInGlobal);
-}
-function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
-    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
-    if (configNames.includes(configName))
-        return;
-    handleUnknownConfig(configName, configNames, filePathToShowToUser);
-    assert(false);
-}
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     let errMsg = `${filePathToShowToUser} defines an unknown config ${pc.cyan(configName)}`;
     let configNameSimilar = null;
@@ -833,7 +827,7 @@ function determineIsErrorPage(routeFilesystem) {
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
-function getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant) {
+function getConfigValues(configValueSources, configValuesComputed, configDefinitions) {
     const configValues = {};
     Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
         configValues[configName] = {
@@ -842,7 +836,7 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
         };
     });
     Object.entries(configValueSources).forEach(([configName, sources]) => {
-        const configDef = configDefinitionsRelevant[configName];
+        const configDef = configDefinitions[configName];
         assert(configDef);
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
@@ -956,3 +950,48 @@ function getConfigEnvValue(val, errMsgIntro) {
     */
     return val;
 }
+function getConfigDefinition(configDefinitions, configName, filePathToShowToUser) {
+    const configDef = configDefinitions[configName];
+    assertConfigExists(configName, Object.keys(configDefinitions), filePathToShowToUser);
+    assert(configDef);
+    return configDef;
+}
+function getConfigDefinitionOptional(configDefinitions, configName) {
+    return configDefinitions[configName] ?? null;
+}
+function isConfigEnv(configDef, configName) {
+    const configEnv = configDef.env;
+    if (configDef.cumulative) {
+        // In principle we could lift that requirement (but it requires non-trivial modifications)
+        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
+}
+function isGlobalConfig(configName) {
+    if (configName === 'prerender')
+        return false;
+    const configNamesGlobal = getConfigNamesGlobal();
+    return arrayIncludes(configNamesGlobal, configName);
+}
+function getConfigNamesGlobal() {
+    return Object.keys(configDefinitionsBuiltInGlobal);
+}
+function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
+    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
+    if (configNames.includes(configName))
+        return;
+    handleUnknownConfig(configName, configNames, filePathToShowToUser);
+    assert(false);
+}
+function sortConfigValueSources(configValueSources, locationIdPage) {
+    return Object.fromEntries(Object.entries(configValueSources)
+        // Make order deterministic (no other purpose)
+        .sort(([, [source1]], [, [source2]]) => source1.definedAt.filePathAbsoluteVite < source2.definedAt.filePathAbsoluteVite ? -1 : 1)
+        // Sort after whether the config value was defined by an npm package
+        .sort(makeFirst(([, [source]]) => {
+        const { importPathAbsolute } = source.definedAt;
+        return !!importPathAbsolute && isNpmPackageImport(importPathAbsolute);
+    }))
+        // Sort after the filesystem inheritance of the config value
+        .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
+}

package/dist/esm/node/plugin/utils.d.ts

@@ -5,7 +5,6 @@ export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
-export * from '../../utils/objectKeys.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
 export * from '../../utils/joinEnglish.js';
@@ -13,7 +12,7 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';

package/dist/esm/node/plugin/utils.js

@@ -11,7 +11,6 @@ export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
-export * from '../../utils/objectKeys.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
 export * from '../../utils/joinEnglish.js';
@@ -19,7 +18,7 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';

package/dist/esm/node/prerender/runPrerender.js

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError, assertNodeEnvIsNotDev, getNodeEnv } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -26,11 +26,11 @@ import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServ
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import { logHintForCjsEsmError } from '../runtime/renderPage/logHintForCjsEsmError.js';
+import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
-    // - We don't use logHintForCjsEsmError() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
+    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 async function runPrerenderFromCLI(options) {
     try {
@@ -38,7 +38,7 @@ async function runPrerenderFromCLI(options) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
 }
@@ -48,7 +48,7 @@ async function runPrerenderFromAutoFullBuild(options) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
 }
@@ -59,7 +59,7 @@ async function runPrerender(options, manuallyTriggered) {
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
-    setNodeEnvToProduction();
+    handleNodeEnv();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);
@@ -713,3 +713,10 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCall);
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
+function handleNodeEnv() {
+    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
+    if (getNodeEnv())
+        assertNodeEnv();
+    setNodeEnvToProduction();
+    assertNodeEnv();
+}

package/dist/esm/node/runtime/globalContext.js

@@ -6,7 +6,7 @@ export { setGlobalContext_viteDevServer };
 export { setGlobalContext_vitePreviewServer };
 export { setGlobalContext_viteConfig };
 export { getRuntimeManifest };
-import { assert, assertUsage, getGlobalObject, getNodeEnv, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -151,8 +151,11 @@ function assertNodeEnv(hasViteDevServer) {
     const nodeEnv = getNodeEnv();
     if (nodeEnv === null || nodeEnv === 'test')
         return;
-    const isDevNodeEnv = 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).
-    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 ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`);
+    const isDev = 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
+    if (hasViteDevServer === isDev)
+        return;
+    const nodeEnvDesc = getNodeEnvDesc();
+    // 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)
+    assertUsage(false, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`);
 }

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

@@ -85,7 +85,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     // See https://github.com/vikejs/vike/pull/1271
     const positionJavaScriptEntry = (() => {
         if (pageContext._pageContextPromise) {
-            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time as progressive hydration won't work", { onlyOnce: true });
+            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time, because 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/streaming#initial-data-after-stream-end
             return 'HTML_END';
         }

package/dist/esm/node/runtime/renderPage/logErrorHint.d.ts

@@ -0,0 +1,8 @@
+export { logErrorHint };
+export { isCjsEsmError };
+export { isKnownError };
+export { getHint };
+declare function logErrorHint(error: unknown): void;
+declare function getHint(error: unknown): null | string;
+declare function isKnownError(error: unknown): false | string;
+declare function isCjsEsmError(error: unknown): boolean | string[];