vike 0.4.217 → 0.4.218-commit-ed9b3d4

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

@@ -1,14 +1,14 @@
-export { getPageContextExports };
-import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
-import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
-import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
-import { getConfigDefinedAtOptional, getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
-import { getConfigValueFilePathToShowToUser } from '../page-configs/helpers.js';
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyNew };
+import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
+import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
+import { getConfigValueFilePathToShowToUser } from './helpers.js';
+import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile } from '../utils.js';
 import pc from '@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) => {
@@ -26,78 +26,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 = getConfigValueFilePathToShowToUser(configValue.definedAtData);
-            const configDefinedAt = 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.)
-            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: 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];
-                        assert(definedAtFile);
-                        const definedAt = 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 = {};
@@ -127,6 +75,90 @@ function getPageContextExports(pageFiles, pageConfig) {
     };
     return pageContextExports;
 }
+// V1 design
+function getPageConfigUserFriendlyNew(pageConfig) {
+    const config = {};
+    const configEntries = {}; // TODO/v1-release: remove
+    const exportsAll = {}; // TODO/v1-release: remove
+    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 = getConfigValueFilePathToShowToUser(configValue.definedAtData);
+        const configDefinedAt = 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.)
+        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: 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];
+                    assert(definedAtFile);
+                    const definedAt = 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;
     assert(fileExports); // assume pageFile.loadFile() was called

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -1,7 +1,31 @@
 export { serializeConfigValues };
-import type { ConfigEnvInternal, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
-declare function serializeConfigValues(pageConfig: PageConfigBuildTime | (PageConfigGlobalBuildTime & {
-    configValuesComputed?: undefined;
-}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, { isEager }: {
+export { getConfigValuesBase };
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, { isEager }: {
     isEager: boolean;
 }, tabspace: string): string[];
+declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, { isEager }?: {
+    isEager?: boolean;
+}): ConfigValuesBase;
+type ConfigValuesBase = ({
+    configValueBase: {
+        type: 'computed';
+        definedAtData: null;
+    };
+    value: unknown;
+    configName: string;
+} | {
+    configValueBase: {
+        type: 'standard';
+        definedAtData: DefinedAtFile;
+    };
+    sourceRelevant: ConfigValueSource;
+    configName: string;
+} | {
+    configValueBase: {
+        type: 'cumulative';
+        definedAtData: DefinedAtFile[];
+    };
+    sourcesRelevant: ConfigValueSource[];
+    configName: string;
+})[];

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

@@ -1,4 +1,5 @@
 export { serializeConfigValues };
+export { getConfigValuesBase };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
@@ -15,74 +16,42 @@ assertIsNotProductionRuntime();
 function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
     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];
-        assert(configDef);
-        if (isEager !== !!configDef.eager)
-            return;
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            assert(configValueSource);
-            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') {
+            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') {
+            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') {
+            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) {
     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)}]: {`);
@@ -126,7 +95,7 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function serializeWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
     assert(valueIsImportedAtRuntime);
@@ -139,7 +108,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',
@@ -196,3 +165,59 @@ function logJsonSerializeError(err, configName, definedAtData) {
     assert(configValueFilePathToShowToUser);
     assertUsage(false, `${pc.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];
+        assert(configDef);
+        if (isEager !== undefined && isEager !== !!configDef.eager)
+            return 'SKIP';
+        if (!configDef.cumulative) {
+            const source = sources[0];
+            assert(source);
+            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/esm/shared/route/executeGuardHook.d.ts

@@ -1,7 +1,7 @@
 export { executeGuardHook };
-import type { PageContextExports, PageFile } from '../getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../getPageFiles.js';
 import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
-declare function executeGuardHook<T extends PageContextExports & {
+declare function executeGuardHook<T extends PageConfigUserFriendly & {
     pageId: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

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

@@ -3,7 +3,7 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';

package/dist/esm/shared/types.d.ts

@@ -8,7 +8,7 @@ export { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
-import type { ConfigEntries, ExportsAll, From, Source, Sources } from './getPageFiles/getExports.js';
+import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getPageConfigUserFriendly.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';

package/dist/esm/shared/utils.d.ts

@@ -22,3 +22,4 @@ export * from '../utils/escapeRegex.js';
 export * from '../utils/isArray.js';
 export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
+export * from '../utils/isScriptFile.js';

package/dist/esm/shared/utils.js

@@ -26,3 +26,4 @@ export * from '../utils/escapeRegex.js';
 export * from '../utils/isArray.js';
 export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
+export * from '../utils/isScriptFile.js';

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

@@ -10,7 +10,7 @@ export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.
 export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, KeepScrollPosition } from '../shared/page-configs/Config.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
+export type { ConfigEntries } from '../shared/page-configs/getPageConfigUserFriendly.js';
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.217";
+export declare const PROJECT_VERSION: "0.4.218-commit-ed9b3d4";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.217';
+export const PROJECT_VERSION = '0.4.218-commit-ed9b3d4';

package/dist/esm/utils/assert.js

@@ -30,6 +30,7 @@ const globalObject = getGlobalObject('utils/assert.ts', {
 assertSingleInstance_onAssertModuleLoad();
 const projectTag = `[vike]`;
 const projectTagWithVersion = `[vike@${projectInfo.projectVersion}]`;
+const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -49,7 +50,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 = createErrorWithCleanStackTrace(errMsg, numberOfStackTraceLinesToRemove);
     globalObject.onBeforeLog?.();
@@ -160,7 +161,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 };
             }
@@ -179,7 +180,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/esm/utils/debug.d.ts

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugActivated };
 export type { Debug };
-declare const flags: readonly ["vike:error", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files", "vike:esbuild-resolve"];
+declare const flags: readonly ["vike:error", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files", "vike:esbuild-resolve"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

@@ -16,6 +16,7 @@ const flags = [
     'vike:extractAssets',
     'vike:extractExportNames',
     'vike:glob',
+    'vike:globalContext',
     'vike:log',
     'vike:optimizeDeps',
     'vike:outDir',
@@ -28,7 +29,7 @@ const flags = [
     'vike:esbuild-resolve'
 ];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;
-assertDEBUG();
+assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
     checkType(flag);
     assert(flags.includes(flag));
@@ -71,8 +72,8 @@ function debug_(flag, options, ...msgs) {
 function isDebugActivated(flag) {
     checkType(flag);
     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) {
@@ -135,13 +136,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) => {
         assertUsage(flags.includes(flag), `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.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/esm/utils/objectReplace.d.ts

@@ -0,0 +1 @@
+export declare function objectReplace(obj: object, objNew: object, except?: string[]): void;

package/dist/esm/utils/objectReplace.js

@@ -0,0 +1,6 @@
+export 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/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.217";
+    projectVersion: "0.4.218-commit-ed9b3d4";
 };