vike 0.4.218 → 0.4.220-commit-a9f46b8

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.220-commit-a9f46b8';

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,54 @@ 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')} is allowed to be the *value* ${picocolors_1.default.cyan('undefined')} (i.e. ${picocolors_1.default.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be 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;
+    }
+    /*
+    // Should we show the following warning? So far I don't think so because of the following. Maybe we can show it once we enable users to disable warnings.
+    // - The warning isn't always actionable, e.g. if it's a tool that dynamically sets `process.env.NODE_ENV`.
+    // - We assume that tools use `process.env.NODE_ENV` and not someting like `const { env } = process; env.NODE_ENV`. Thus, in practice, `val` overrides `val2` so having `val!==val2` isn't an issue.
+    {
+      const val2 = process.env['NODE' + '_ENV']
+      if (val2)
+        assertWarning(
+          val === val2,
+          `Dynamically setting process.env.NODE_ENV to ${val2} hasn't any effect because process.env.NODE_ENV is being statically replaced to ${val}.`,
+          { onlyOnce: true }
+        )
+    }
+    //*/
+    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/catchInfiniteLoop.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.catchInfiniteLoop = catchInfiniteLoop;
+const assert_js_1 = require("./assert.js");
+const trackers = {};
+function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds = 5) {
+    // Init
+    const now = new Date();
+    let tracker = (trackers[functionName] ?? (trackers[functionName] = createTracker(now)));
+    // Reset
+    const elapsedTime = now.getTime() - tracker.start.getTime();
+    if (elapsedTime > withinSeconds * 1000)
+        tracker = trackers[functionName] = createTracker(now);
+    // Count
+    tracker.count++;
+    // Error
+    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    if (tracker.count > maxNumberOfCalls) {
+        (0, assert_js_1.assert)(false, msg);
+    }
+    // Warning, at 50% threshold
+    if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
+        // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
+        (0, assert_js_1.assertWarning)(false, msg, { onlyOnce: false });
+        tracker.warned = true;
+    }
+}
+function createTracker(now) {
+    const tracker = {
+        count: 0,
+        start: now
+    };
+    return tracker;
+}

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

@@ -7,6 +7,8 @@ const assert_js_1 = require("./assert.js");
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
     // Released at vite@5.1.0 which is guaranteed with `assertVersion('Vite', version, '5.1.0')`
+    // - Release: https://github.com/vitejs/vite/blob/6f7466e6211027686f40ad7e4ce6ec8477414546/packages/vite/CHANGELOG.md#510-beta4-2024-01-26:~:text=fix(preview)%3A-,set%20isPreview%20true,-(%2315695)%20(93fce55
+    // - Surprisingly, this assert() can fail: https://github.com/vikejs/vike/issues/2120
     (0, assert_js_1.assert)(typeof isPreview === 'boolean');
     return command === 'serve' && !isPreview;
 }

package/dist/cjs/utils/makePublicCopy.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePublicCopy = makePublicCopy;
+const assert_js_1 = require("./assert.js");
+const objectKeys_js_1 = require("./objectKeys.js");
+/** Prefix internal properties with `_` + show warning */
+function makePublicCopy(obj, objName, propsPublic, propsInternalNoWarning) {
+    const objPublic = {};
+    (0, objectKeys_js_1.objectKeys)(obj).forEach((key) => {
+        const val = obj[key];
+        if (propsPublic.includes(key)) {
+            objPublic[key] = val;
+        }
+        else {
+            const keyPublic = key.startsWith('_') ? key : `_${key}`;
+            if (propsInternalNoWarning?.includes(key)) {
+                // @ts-expect-error
+                objPublic[keyPublic] = val;
+            }
+            else {
+                Object.defineProperty(objPublic, keyPublic, {
+                    enumerable: true,
+                    get() {
+                        (0, assert_js_1.assertWarning)(false, `Using internal ${objName}.${keyPublic} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+                        return val;
+                    }
+                });
+            }
+        }
+    });
+    return objPublic;
+}

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);
+}

package/dist/esm/__internal/index.d.ts

@@ -1,14 +1,12 @@
+export { setGlobalContext_buildEntry } from '../node/runtime/globalContext.js';
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 export { getMiddlewares };
 import { route as routeInternal, type PageRoutes } from '../shared/route/index.js';
-import { type PageFile } from '../shared/getPageFiles.js';
+import type { PageFile } from '../shared/getPageFiles/getPageFileObject.js';
 import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
 /**
- * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
- * to compute some rewrite rules and extract { isr } configs.
- * Needs `import 'vike/__internal/setup'`
- * @param config
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
  */
 declare function getPagesAndRoutes(): Promise<{
     pageRoutes: PageRoutes;

package/dist/esm/__internal/index.js

@@ -1,24 +1,22 @@
+// Internals needed by Vike
+export { setGlobalContext_buildEntry } from '../node/runtime/globalContext.js';
 // Internals needed by vite-plugin-vercel
 export { route, getPagesAndRoutes };
 // Internals needed by experimental implementation of vike-telefunc
 export { getMiddlewares };
 import { route as routeInternal } from '../shared/route/index.js';
-import { getPageFilesAll } from '../shared/getPageFiles.js';
+import { getPageFilesAll } from '../shared/getPageFiles/getPageFiles.js';
 import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
 import { setNodeEnvProduction } from '../utils/assertSetup.js';
-import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**
- * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
- * to compute some rewrite rules and extract { isr } configs.
- * Needs `import 'vike/__internal/setup'`
- * @param config
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
  */
 async function getPagesAndRoutes() {
     setNodeEnvProduction();
-    const renderContext = await getRenderContext();
+    const globalContext = getGlobalContext();
     const { 
     //
-    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = renderContext;
+    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = globalContext;
     return {
         pageRoutes,
         pageFilesAll,

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -1,10 +1,13 @@
 export { createPageContext };
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
-import { getPageFilesAll } from '../../shared/getPageFiles.js';
+import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
 import { assert, isBaseServer, getGlobalObject, objectAssign } from './utils.js';
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vike:importUserCode:client:client-routing';
 const globalObject = getGlobalObject('createPageContext.ts', {});
+setPageFiles(pageFilesExports);
 async function createPageContext(urlOriginal) {
     if (!globalObject.pageFilesData) {
         globalObject.pageFilesData = await getPageFilesAll(true);

package/dist/esm/client/client-routing-runtime/entry.d.ts

@@ -1 +1 @@
-import './pageFiles';
+export {};

package/dist/esm/client/client-routing-runtime/entry.js

@@ -1,6 +1,5 @@
 import { assertClientRouting } from '../../utils/assertRoutingType.js';
 assertClientRouting();
-import './pageFiles';
 import { initClientRouter } from './initClientRouter.js';
 import { assertSingleInstance_onClientEntryClientRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';

package/dist/esm/client/client-routing-runtime/getPageContextCurrent.d.ts

@@ -1,7 +1,7 @@
 export { setPageContextCurrent };
 export { getPageContextCurrent };
-import type { PageContextExports } from '../../shared/getPageFiles.js';
-type PageContextCurrent = PageContextExports & {
+import type { PageConfigUserFriendly } from '../../shared/getPageFiles.js';
+type PageContextCurrent = PageConfigUserFriendly & {
     urlPathname: string;
 };
 declare function getPageContextCurrent(): null | PageContextCurrent;

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -5,7 +5,7 @@ export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
 export type { PageContextFromServerHooks };
 export type { PageContextFromClientHooks };
-import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContext = {
     urlOriginal: string;
@@ -21,9 +21,9 @@ declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports & {
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageConfigUserFriendly & {
     _hasPageContextFromServer: true;
-}): Promise<PageContextSerialized & PageContext & PageContextExports & {
+}): Promise<PageContextSerialized & PageContext & PageConfigUserFriendly & {
     _hasPageContextFromServer: true;
 } & {
     _hasPageContextFromClient: boolean;
@@ -45,5 +45,5 @@ type PageContextFromClientHooks = {
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContext & PageContextExports, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+} & PageContext & PageConfigUserFriendly, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
 declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;