vike 0.4.218 → 0.4.219

package/dist/cjs/shared/{getPageFiles/getExports.js → page-configs/getPageConfigUserFriendly.js}

@@ -3,17 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageContextExports = getPageContextExports;
-const isScriptFile_js_1 = require("../../utils/isScriptFile.js");
+exports.getPageConfigUserFriendly = getPageConfigUserFriendly;
+exports.getPageConfigUserFriendlyNew = getPageConfigUserFriendlyNew;
+const assert_exports_old_design_js_1 = require("../getPageFiles/assert_exports_old_design.js");
+const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
+const helpers_js_1 = require("./helpers.js");
 const utils_js_1 = require("../utils.js");
-const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
-const getConfigDefinedAt_js_1 = require("../page-configs/getConfigDefinedAt.js");
-const helpers_js_1 = require("../page-configs/helpers.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function getPageContextExports(pageFiles, pageConfig) {
-    const configEntries = {};
+function getPageConfigUserFriendly(pageFiles, pageConfig) {
     const config = {};
-    const exportsAll = {};
+    const configEntries = {}; // TODO/v1-release: remove
+    const exportsAll = {}; // TODO/v1-release: remove
     // V0.4 design
     // TODO/v1-release: remove
     pageFiles.forEach((pageFile) => {
@@ -31,78 +31,26 @@ function getPageContextExports(pageFiles, pageConfig) {
             });
         });
     });
-    // V1 design
-    const source = {};
-    const sources = {};
-    const addSrc = (src, configName) => {
-        source[configName] = src;
-        sources[configName] ?? (sources[configName] = []);
-        sources[configName].push(src);
-    };
-    const from = {
-        configsStandard: {},
-        configsCumulative: {},
-        configsComputed: {}
-    };
+    let source;
+    let sources;
+    let from;
     if (pageConfig) {
-        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            const { value } = configValue;
-            const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData);
-            const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, configValue.definedAtData);
-            config[configName] = config[configName] ?? value;
-            configEntries[configName] = configEntries[configName] ?? [];
-            // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
-            (0, utils_js_1.assert)(configEntries[configName].length === 0);
-            configEntries[configName].push({
-                configValue: value,
-                configDefinedAt,
-                configDefinedByFile: configValueFilePathToShowToUser
-            });
-            if (configValue.type === 'standard') {
-                const src = {
-                    type: 'configsStandard',
-                    value: configValue.value,
-                    definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName)
-                };
-                addSrc(src, configName);
-                from.configsStandard[configName] = src;
-            }
-            if (configValue.type === 'cumulative') {
-                const src = {
-                    type: 'configsCumulative',
-                    values: configValue.value.map((value, i) => {
-                        const definedAtFile = configValue.definedAtData[i];
-                        (0, utils_js_1.assert)(definedAtFile);
-                        const definedAt = (0, getConfigDefinedAt_js_1.getDefinedAtString)(definedAtFile, configName);
-                        return {
-                            value,
-                            definedAt
-                        };
-                    })
-                };
-                addSrc(src, configName);
-                from.configsCumulative[configName] = src;
-            }
-            if (configValue.type === 'computed') {
-                const src = {
-                    type: 'configsComputed',
-                    value: configValue.value
-                };
-                addSrc(src, configName);
-                from.configsComputed[configName] = src;
-            }
-            // TODO/v1-release: remove
-            const exportName = configName;
-            exportsAll[exportName] = exportsAll[exportName] ?? [];
-            exportsAll[exportName].push({
-                exportValue: value,
-                exportSource: configDefinedAt,
-                filePath: configValueFilePathToShowToUser,
-                _filePath: configValueFilePathToShowToUser,
-                _fileType: null,
-                _isFromDefaultExport: null
-            });
-        });
+        const res = getPageConfigUserFriendlyNew(pageConfig);
+        source = res.source;
+        sources = res.sources;
+        from = res.from;
+        Object.assign(config, res.config);
+        Object.assign(configEntries, res.configEntries);
+        Object.assign(exportsAll, res.exportsAll);
+    }
+    else {
+        source = {};
+        sources = {};
+        from = {
+            configsStandard: {},
+            configsCumulative: {},
+            configsComputed: {}
+        };
     }
     const pageExports = createObjectWithDeprecationWarning();
     const exports = {};
@@ -132,17 +80,101 @@ function getPageContextExports(pageFiles, pageConfig) {
     };
     return pageContextExports;
 }
+// V1 design
+function getPageConfigUserFriendlyNew(pageConfig) {
+    const config = {};
+    const configEntries = {};
+    const exportsAll = {};
+    const source = {};
+    const sources = {};
+    const from = {
+        configsStandard: {},
+        configsCumulative: {},
+        configsComputed: {}
+    };
+    const addSrc = (src, configName) => {
+        source[configName] = src;
+        sources[configName] ?? (sources[configName] = []);
+        sources[configName].push(src);
+    };
+    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+        const { value } = configValue;
+        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData);
+        const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, configValue.definedAtData);
+        config[configName] = config[configName] ?? value;
+        configEntries[configName] = configEntries[configName] ?? [];
+        // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
+        (0, utils_js_1.assert)(configEntries[configName].length === 0);
+        configEntries[configName].push({
+            configValue: value,
+            configDefinedAt,
+            configDefinedByFile: configValueFilePathToShowToUser
+        });
+        if (configValue.type === 'standard') {
+            const src = {
+                type: 'configsStandard',
+                value: configValue.value,
+                definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName)
+            };
+            addSrc(src, configName);
+            from.configsStandard[configName] = src;
+        }
+        if (configValue.type === 'cumulative') {
+            const src = {
+                type: 'configsCumulative',
+                values: configValue.value.map((value, i) => {
+                    const definedAtFile = configValue.definedAtData[i];
+                    (0, utils_js_1.assert)(definedAtFile);
+                    const definedAt = (0, getConfigDefinedAt_js_1.getDefinedAtString)(definedAtFile, configName);
+                    return {
+                        value,
+                        definedAt
+                    };
+                })
+            };
+            addSrc(src, configName);
+            from.configsCumulative[configName] = src;
+        }
+        if (configValue.type === 'computed') {
+            const src = {
+                type: 'configsComputed',
+                value: configValue.value
+            };
+            addSrc(src, configName);
+            from.configsComputed[configName] = src;
+        }
+        // TODO/v1-release: remove
+        const exportName = configName;
+        exportsAll[exportName] = exportsAll[exportName] ?? [];
+        exportsAll[exportName].push({
+            exportValue: value,
+            exportSource: configDefinedAt,
+            filePath: configValueFilePathToShowToUser,
+            _filePath: configValueFilePathToShowToUser,
+            _fileType: null,
+            _isFromDefaultExport: null
+        });
+    });
+    return {
+        config,
+        configEntries,
+        exportsAll,
+        source,
+        sources,
+        from
+    };
+}
 function getExportValues(pageFile) {
     const { filePath, fileExports } = pageFile;
     (0, utils_js_1.assert)(fileExports); // assume pageFile.loadFile() was called
-    (0, utils_js_1.assert)((0, isScriptFile_js_1.isScriptFile)(filePath));
+    (0, utils_js_1.assert)((0, utils_js_1.isScriptFile)(filePath));
     const exportValues = [];
     Object.entries(fileExports)
         .sort((0, utils_js_1.makeLast)(([exportName]) => exportName === 'default')) // `export { bla }` should override `export default { bla }`
         .forEach(([exportName, exportValue]) => {
         let isFromDefaultExport = exportName === 'default';
         if (isFromDefaultExport) {
-            if ((0, isScriptFile_js_1.isTemplateFile)(filePath)) {
+            if ((0, utils_js_1.isTemplateFile)(filePath)) {
                 exportName = 'Page';
             }
             else {

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeConfigValues = serializeConfigValues;
+exports.getConfigValuesBase = getConfigValuesBase;
 const assertSetup_js_1 = require("../../../utils/assertSetup.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
 const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
@@ -17,77 +18,45 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // - vike/shared/page-configs/serialize/parsePageConfigs.ts
 // - parsePageConfigs() is loaded on both the client- and server-side.
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
-function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace, isEager) {
     const lines = [];
     tabspace += '  ';
-    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
-        if (!isEnvMatch(configValuesComputed.configEnv))
-            return;
-        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
-        if (pageConfig.configValueSources[configName])
-            return;
-        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
-        const configValueBase = {
-            type: 'computed',
-            definedAtData: null
-        };
-        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
-    });
-    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-        const configDef = pageConfig.configDefinitions[configName];
-        (0, utils_js_1.assert)(configDef);
-        if (isEager !== !!configDef.eager)
-            return;
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            (0, utils_js_1.assert)(configValueSource);
-            (0, utils_js_1.assert)(sources.slice(1).every((s) => s.isOverriden === true));
-            if (!isEnvMatch(configValueSource.configEnv))
-                return;
-            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
-            const configValueBase = {
-                type: 'standard',
-                definedAtData: definedAtFile
-            };
+    getConfigValuesBase(pageConfig, isEnvMatch, isEager).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            (0, utils_js_1.assert)('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements);
             serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
         }
-        else {
+        if (entry.configValueBase.type === 'standard') {
+            (0, utils_js_1.assert)('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements);
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            (0, utils_js_1.assert)('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
             const valueDataList = [];
-            const definedAtData = [];
-            sources
-                .filter((s) => !s.isOverriden)
-                .forEach((configValueSource) => {
-                if (!isEnvMatch(configValueSource.configEnv))
-                    return;
-                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            sourcesRelevant.forEach((source) => {
+                const valueData = getValueSerializedFromSource(source, configName, importStatements);
                 valueDataList.push(valueData);
-                definedAtData.push(definedAtFile);
             });
-            if (valueDataList.length === 0)
-                return;
-            const configValueBase = {
-                type: 'cumulative',
-                definedAtData
-            };
             serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
         }
     });
     return lines;
 }
-function serializeConfigValueSource(configValueSource, configName, importStatements) {
+function getValueSerializedFromSource(configValueSource, configName, importStatements) {
     (0, utils_js_1.assert)(configValueSource.isOverriden === false);
     let valueData;
     if ('value' in configValueSource) {
-        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
     }
     else {
-        valueData = serializeWithImport(configValueSource, importStatements);
+        valueData = getValueSerializedWithImport(configValueSource, importStatements);
     }
-    const definedAtFile = {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
-    };
-    return { valueData, definedAtFile };
+    return valueData;
 }
 function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
     lineAdd(`[${JSON.stringify(configName)}]: {`);
@@ -131,7 +100,7 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function serializeWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
     const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
@@ -144,7 +113,7 @@ function serializeWithImport(configValueSource, importStatements) {
         valueAsJsCode: importName
     };
 }
-function serializeWithJson(value, configName, definedAtData, importStatements) {
+function getValueSerializedWithJson(value, configName, definedAtData, importStatements) {
     const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
     return {
         type: 'js-serialized',
@@ -201,3 +170,59 @@ function logJsonSerializeError(err, configName, definedAtData) {
     (0, utils_js_1.assert)(configValueFilePathToShowToUser);
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
 }
+function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
+    const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
+        if (!isEnvMatch(valueInfo.configEnv))
+            return 'SKIP';
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return 'SKIP';
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        return { configValueBase, value: valueInfo.value, configName };
+    });
+    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        (0, utils_js_1.assert)(configDef);
+        if (isEager !== null && isEager !== !!configDef.eager)
+            return 'SKIP';
+        if (!configDef.cumulative) {
+            const source = sources[0];
+            (0, utils_js_1.assert)(source);
+            (0, utils_js_1.assert)(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(source.configEnv))
+                return 'SKIP';
+            const definedAtFile = getDefinedAtFileSource(source);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            return { configValueBase, sourceRelevant: source, configName };
+        }
+        else {
+            const sourcesRelevant = sources.filter((source) => !source.isOverriden && isEnvMatch(source.configEnv));
+            if (sourcesRelevant.length === 0)
+                return 'SKIP';
+            const definedAtData = [];
+            sourcesRelevant.forEach((source) => {
+                const definedAtFile = getDefinedAtFileSource(source);
+                definedAtData.push(definedAtFile);
+            });
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            return { configValueBase, sourcesRelevant, configName };
+        }
+    });
+    return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
+}
+function getDefinedAtFileSource(source) {
+    const definedAtFile = {
+        filePathToShowToUser: source.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: source.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return definedAtFile;
+}

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -5,7 +5,7 @@ const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
 const utils_js_2 = require("../utils.js");
-const getConfigValue_js_1 = require("../page-configs/getConfigValue.js");
+const getConfigValueRuntime_js_1 = require("../page-configs/getConfigValueRuntime.js");
 const getConfigDefinedAt_js_1 = require("../page-configs/getConfigDefinedAt.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const getHook_js_1 = require("../hooks/getHook.js");
@@ -30,7 +30,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, configName);
+                const configValue = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
                     (0, utils_js_1.assert)(configValue.definedAtData);
@@ -46,7 +46,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,

package/dist/cjs/shared/utils.js

@@ -42,3 +42,4 @@ __exportStar(require("../utils/escapeRegex.js"), exports);
 __exportStar(require("../utils/isArray.js"), exports);
 __exportStar(require("../utils/changeEnumerable.js"), exports);
 __exportStar(require("../utils/objectDefineProperty.js"), exports);
+__exportStar(require("../utils/isScriptFile.js"), exports);

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.218';
+exports.PROJECT_VERSION = '0.4.219';

package/dist/cjs/utils/assert.js

@@ -35,6 +35,7 @@ const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/assert.ts'
 (0, assertSingleInstance_js_1.assertSingleInstance_onAssertModuleLoad)();
 const projectTag = `[vike]`;
 const projectTagWithVersion = `[vike@${projectInfo_js_1.projectInfo.projectVersion}]`;
+const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -54,7 +55,7 @@ function assert(condition, debugInfo) {
         .filter(Boolean)
         .join(' ');
     errMsg = addWhitespace(errMsg);
-    errMsg = addPrefixAssertType(errMsg, 'Bug');
+    errMsg = addPrefixAssertType(errMsg, bugTag);
     errMsg = addPrefixProjctName(errMsg, true);
     const internalError = (0, createErrorWithCleanStackTrace_js_1.createErrorWithCleanStackTrace)(errMsg, numberOfStackTraceLinesToRemove);
     globalObject.onBeforeLog?.();
@@ -165,7 +166,7 @@ function getAssertErrMsg(thing) {
         const showVikeVersion = tag === projectTagWithVersion;
         const errStackPrefix = `Error: ${tag}`;
         if (errStack?.startsWith(errStackPrefix)) {
-            if (globalObject.showStackTraceList.has(thing)) {
+            if (globalObject.showStackTraceList.has(thing) || isBug(thing)) {
                 const assertMsg = errStack.slice(errStackPrefix.length);
                 return { assertMsg, showVikeVersion };
             }
@@ -184,7 +185,7 @@ function overwriteAssertProductionLogger(logger) {
     globalObject.logger = logger;
 }
 function isBug(err) {
-    return !String(err).includes('[Bug]');
+    return String(err).includes(`[${bugTag}]`);
 }
 function setAlwaysShowStackTrace() {
     globalObject.alwaysShowStackTrace = true;

package/dist/cjs/utils/assertSetup.js

@@ -33,16 +33,19 @@ function onSetupRuntime() {
         debug('assertSetup()', new Error().stack);
     if (isTest())
         return;
+    assertNodeEnvIsNotUndefinedString();
     if (!isViteLoaded()) {
         // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
-        (0, assert_js_1.assertWarning)(!isNodeEnvDev(), `The ${getEnvDescription()}, which seems contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        (0, assert_js_1.assertWarning)(!isNodeEnvDev(), `The ${getEnvDescription()}, which is contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
         (0, assert_js_1.assertUsage)(!setup.vikeVitePlugin, "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.");
         // This assert() one of the main goal of this file: it ensures assertIsNotProductionRuntime()
         (0, assert_js_1.assert)(!setup.shouldNotBeProduction);
     }
     else {
-        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
-        (0, assert_js_1.assertWarning)(isNodeEnvDev() || setup.vitePreviewServer || setup.isPrerendering, `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        if (!setup.vitePreviewServer && !setup.isPrerendering) {
+            // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+            (0, assert_js_1.assertWarning)(isNodeEnvDev(), `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        }
         // These two assert() calls aren't that interesting
         (0, assert_js_1.assert)(setup.vikeVitePlugin);
         (0, assert_js_1.assert)(setup.shouldNotBeProduction);
@@ -62,7 +65,7 @@ function onSetupBuild() {
 }
 function onSetupPrerender() {
     markSetup_isPrerendering();
-    if (getNodeEnvValue())
+    if (getNodeEnv())
         assertUsageNodeEnvIsNotDev('pre-rendering');
     setNodeEnvProduction();
 }
@@ -71,7 +74,7 @@ function isViteLoaded() {
     return setup.viteDevServer || setup.vitePreviewServer || setup.isViteDev !== undefined;
 }
 function isTest() {
-    return (0, isVitest_js_1.isVitest)() || getNodeEnvValue() === 'test';
+    return (0, isVitest_js_1.isVitest)() || isNodeEnv('test');
 }
 // Called by Vite hook configureServer()
 function markSetup_viteDevServer() {
@@ -110,26 +113,40 @@ function assertUsageNodeEnvIsNotDev(operation) {
     (0, assert_js_1.assertWarning)(false, `The ${getEnvDescription()} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
 }
 function getEnvDescription() {
-    const nodeEnv = getNodeEnvValue();
-    const isDev = isNodeEnvDev();
-    const envType = `${(isDev ? 'development' : 'production')} environment`;
-    const nodeEnvDesc = `environment is set to be a ${picocolors_1.default.bold(envType)} by ${picocolors_1.default.cyan(`process.env.NODE_ENV===${JSON.stringify(nodeEnv)}`)}`;
+    const envType = `${(isNodeEnvDev() ? 'development' : 'production')} environment`;
+    const nodeEnvDesc = `environment is set to be a ${picocolors_1.default.bold(envType)} by ${picocolors_1.default.cyan(`process.env.NODE_ENV===${JSON.stringify(getNodeEnv())}`)}`;
     return nodeEnvDesc;
 }
+// For example, Wrangler bug replaces `process.env.NODE_ENV` with `"undefined"`
+// https://github.com/cloudflare/workers-sdk/issues/7886
+function assertNodeEnvIsNotUndefinedString() {
+    const nodeEnv = getNodeEnv();
+    (0, assert_js_1.assertWarning)(nodeEnv !== 'undefined', `${picocolors_1.default.cyan('process.env.NODE_ENV==="undefined"')} which is unexpected: ${picocolors_1.default.cyan('process.env.NODE_ENV')} can be set to the *value* ${picocolors_1.default.cyan('undefined')} (i.e. ${picocolors_1.default.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be set to the *string* ${picocolors_1.default.cyan('"undefined"')} ${picocolors_1.default.underline('https://vike.dev/NODE_ENV')}`, { onlyOnce: true });
+}
 function isNodeEnvDev() {
-    const nodeEnv = getNodeEnvValue();
+    const nodeEnv = getNodeEnv();
     // That's quite strict, let's see if some user complains
-    return !nodeEnv || ['development', 'dev'].includes(nodeEnv);
+    return nodeEnv === undefined || isNodeEnv(['development', 'dev', '']);
+}
+function isNodeEnv(value) {
+    const values = Array.isArray(value) ? value : [value];
+    const nodeEnv = getNodeEnv();
+    return nodeEnv !== undefined && values.includes(nodeEnv.toLowerCase());
 }
-function getNodeEnvValue() {
-    if (typeof process === 'undefined')
-        return null;
-    return process.env.NODE_ENV?.toLowerCase();
+function getNodeEnv() {
+    let val;
+    try {
+        val = process.env.NODE_ENV;
+    }
+    catch {
+        return undefined;
+    }
+    return val;
 }
 function setNodeEnvProduction() {
     // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
     const proc = process;
     const { env } = proc;
     env.NODE_ENV = 'production';
-    (0, assert_js_1.assert)(getNodeEnvValue() === 'production');
+    (0, assert_js_1.assert)(isNodeEnv('production'));
 }

package/dist/cjs/utils/debug.js

@@ -21,6 +21,7 @@ const flags = [
     'vike:extractAssets',
     'vike:extractExportNames',
     'vike:glob',
+    'vike:globalContext',
     'vike:log',
     'vike:optimizeDeps',
     'vike:outDir',
@@ -33,7 +34,7 @@ const flags = [
     'vike:esbuild-resolve'
 ];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;
-assertDEBUG();
+assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
     (0, checkType_js_1.checkType)(flag);
     (0, assert_js_1.assert)(flags.includes(flag));
@@ -76,8 +77,8 @@ function debug_(flag, options, ...msgs) {
 function isDebugActivated(flag) {
     (0, checkType_js_1.checkType)(flag);
     (0, assert_js_1.assert)(flags.includes(flag));
-    const DEBUG = getDEBUG();
-    const isActivated = DEBUG?.includes(flag) ?? false;
+    const flagsActivated = getFlagsActivated();
+    const isActivated = flagsActivated.includes(flag);
     return isActivated;
 }
 function formatMsg(info, options, padding, position) {
@@ -140,13 +141,17 @@ function replaceFunctionSerializer(_key, value) {
     }
     return value;
 }
-function assertDEBUG() {
-    const DEBUG = getDEBUG() ?? '';
-    const flagsActivated = DEBUG.match(flagRegex) ?? [];
+function assertFlagsActivated() {
+    const flagsActivated = getFlagsActivated();
     flagsActivated.forEach((flag) => {
         (0, assert_js_1.assertUsage)(flags.includes(flag), `Unknown DEBUG flag ${picocolors_1.default.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${picocolors_1.default.cyan(f)}`).join('\n')}`);
     });
 }
+function getFlagsActivated() {
+    const DEBUG = getDEBUG() ?? '';
+    const flagsActivated = DEBUG.match(flagRegex) ?? [];
+    return flagsActivated;
+}
 function getDEBUG() {
     let DEBUG;
     // - `process` can be undefined in edge workers

package/dist/cjs/utils/getGlobalObject.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalObject = getGlobalObject;
 exports.assertIsSingleModuleInstance = assertIsSingleModuleInstance;
 const assert_js_1 = require("./assert.js");
-const projectInfo_js_1 = require("./projectInfo.js");
-const projectKey = `_${projectInfo_js_1.projectInfo.projectName.toLowerCase()}`;
 /** Share information across module instances. */
 function getGlobalObject(
 // We use the filename (or file path) as key. There should be only one getGlobalObject() usage per file. Thus the key should be unique, assuming the filename (or file path) is unique.
@@ -21,6 +19,7 @@ key) {
     (0, assert_js_1.assert)(!(key in globalObjects));
 }
 function getGlobalObjects() {
+    const projectKey = '_vike';
     // @ts-ignore
     const globalObjects = (globalThis[projectKey] = globalThis[projectKey] || {});
     return globalObjects;

package/dist/cjs/utils/objectReplace.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectReplace = objectReplace;
+function objectReplace(obj, objNew, except) {
+    Object.keys(obj)
+        .filter((key) => !except?.includes(key))
+        .forEach((key) => delete obj[key]);
+    Object.assign(obj, objNew);
+}