vike 0.4.220 → 0.4.221-commit-8577456

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -20,7 +20,8 @@ import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js'
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-type PageConfigBase = {
+import type { PlusFile, PlusFilesByLocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
+type PageConfigCommon = {
     pageId: string;
     isErrorPage?: true;
     routeFilesystem?: {
@@ -28,34 +29,40 @@ type PageConfigBase = {
         definedBy: string;
     };
 };
-/** Page config data structure available at runtime */
-type PageConfigRuntime = PageConfigBase & {
+/** Page config, runtime data structure */
+type PageConfigRuntime = PageConfigCommon & {
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: () => Promise<{
-        configValuesSerialized: Record<string, ConfigValueSerialized>;
-    }>;
+    loadConfigValuesAll: LoadConfigValuesAll;
 };
-/** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
-type PageConfigRuntimeLoaded = PageConfigRuntime & {
-    /** Whether loadConfigValuesAll() was called */
-    isAllLoaded: true;
+/** Global config that applies to all pages, runtime data structure */
+type PageConfigGlobalRuntime = {
+    configValues: ConfigValues;
 };
-/** Page config data structure available at build-time */
-type PageConfigBuildTime = PageConfigBase & {
+/** Page config, build-time data structure */
+type PageConfigBuildTime = PageConfigCommon & {
     configDefinitions: ConfigDefinitions;
+    plusFiles: PlusFilesByLocationId;
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
 };
-/** Page config that applies to all pages */
-type PageConfigGlobalRuntime = {
-    configValues: ConfigValues;
-};
+/** Global config that applies to all pages, build-time data structure */
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
     configDefinitions: ConfigDefinitions;
     configValuesComputed?: undefined;
 };
+/** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
+type PageConfigRuntimeLoaded = PageConfigRuntime & {
+    /** Whether loadConfigValuesAll() was called */
+    isAllLoaded: true;
+};
+type LoadConfigValuesAll = () => {
+    moduleId: string;
+    moduleExports: Promise<{
+        configValuesSerialized: Record<string, ConfigValueSerialized>;
+    }>;
+};
 /** In what environment(s) the config value is loaded.
  *
  * https://vike.dev/meta
@@ -74,9 +81,9 @@ type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
 type ConfigValueSources = Record<string, // configName
 ConfigValueSource[]>;
 type ConfigValueSource = {
-    value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAtFilePath: DefinedAtFilePath;
+    plusFile: PlusFile | null;
     locationId: LocationId;
     isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
@@ -84,7 +91,12 @@ type ConfigValueSource = {
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
     valueIsDefinedByPlusFile: boolean;
-};
+} & ({
+    valueIsLoaded: false;
+} | {
+    valueIsLoaded: true;
+    value: unknown;
+});
 type DefinedAtFilePath = DefinedAtFile & FilePath & {
     fileExportName?: string;
 };

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.d.ts

@@ -1,4 +1,4 @@
-export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyOld };
 export { getPageConfigUserFriendlyNew };
 export type { ConfigUserFriendly };
 export type { PageConfigUserFriendly };
@@ -33,7 +33,7 @@ type ConfigEntries = Record<string, {
     configDefinedByFile: string | null;
 }[]>;
 type PageConfigUserFriendly = {
-    config: Record<string, unknown>;
+    config: ConfigResolved;
     source: Source;
     sources: Sources;
     from: From;
@@ -73,15 +73,13 @@ type SourceConfigsComputed = {
     type: 'configsComputed';
     value: unknown;
 };
-declare function getPageConfigUserFriendly(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageConfigUserFriendly;
 type ConfigUserFriendly = {
     config: ConfigResolved;
-    configEntries: ConfigEntries;
-    exportsAll: ExportsAll;
-    source: Source;
-    sources: Sources;
-    from: From;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
 };
 declare function getPageConfigUserFriendlyNew(pageConfig: {
     configValues: ConfigValues;
 }): ConfigUserFriendly;
+declare function getPageConfigUserFriendlyOld(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageConfigUserFriendly;

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.js

@@ -1,11 +1,20 @@
-export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyOld };
 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 getPageConfigUserFriendly(pageFiles, pageConfig) {
+function getPageConfigUserFriendlyNew(pageConfig) {
+    const res = getPageConfigUserFriendlyV1Desin(pageConfig);
+    return {
+        config: res.config,
+        _source: res.source,
+        _sources: res.sources,
+        _from: res.from
+    };
+}
+function getPageConfigUserFriendlyOld(pageFiles, pageConfig) {
     const config = {};
     const configEntries = {}; // TODO/v1-release: remove
     const exportsAll = {}; // TODO/v1-release: remove
@@ -30,7 +39,7 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     let sources;
     let from;
     if (pageConfig) {
-        const res = getPageConfigUserFriendlyNew(pageConfig);
+        const res = getPageConfigUserFriendlyV1Desin(pageConfig);
         source = res.source;
         sources = res.sources;
         from = res.from;
@@ -63,11 +72,11 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     assert(!('default' in exports));
     assert(!('default' in exportsAll));
     const pageContextExports = {
+        config: config,
         from,
         source,
         sources,
         // TODO/eventually: deprecate/remove every prop below
-        config,
         configEntries,
         exports,
         exportsAll,
@@ -76,7 +85,7 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     return pageContextExports;
 }
 // V1 design
-function getPageConfigUserFriendlyNew(pageConfig) {
+function getPageConfigUserFriendlyV1Desin(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -151,7 +160,7 @@ function getPageConfigUserFriendlyNew(pageConfig) {
         });
     });
     return {
-        config,
+        config: config,
         configEntries,
         exportsAll,
         source,

package/dist/esm/shared/page-configs/loadConfigValues.js

@@ -1,5 +1,5 @@
 export { loadConfigValues };
-import { objectAssign } from '../utils.js';
+import { assert, objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigs.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
@@ -7,7 +7,11 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const configValuesLoaded = await moduleExports;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!configValuesLoaded)
+        assert(false, { moduleExports, configValuesLoaded, moduleId });
     const configValues = parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);
     Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isAllLoaded: true });

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

@@ -1,7 +1,8 @@
 export { serializeConfigValues };
 export { getConfigValuesBase };
+export type { FilesEnv };
 import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
-declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
 declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
 type ConfigValuesBase = ({
     configValueBase: {
@@ -9,6 +10,7 @@ type ConfigValuesBase = ({
         definedAtData: null;
     };
     value: unknown;
+    configEnv: ConfigEnvInternal;
     configName: string;
 } | {
     configValueBase: {
@@ -25,3 +27,7 @@ type ConfigValuesBase = ({
     sourcesRelevant: ConfigValueSource[];
     configName: string;
 })[];
+type FilesEnv = Map<string, {
+    configEnv: ConfigEnvInternal;
+    configName: string;
+}[]>;

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

@@ -1,8 +1,7 @@
 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';
+import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
@@ -13,20 +12,20 @@ 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.
 assertIsNotProductionRuntime();
-function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace, isEager) {
+function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatch, tabspace, isEager) {
     const lines = [];
     tabspace += '  ';
     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);
+            const { configValueBase, value, configName, configEnv } = entry;
+            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements, filesEnv, configEnv);
             serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
         }
         if (entry.configValueBase.type === 'standard') {
             assert('sourceRelevant' in entry); // Help TS
             const { configValueBase, sourceRelevant, configName } = entry;
-            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements);
+            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements, filesEnv);
             serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
         }
         if (entry.configValueBase.type === 'cumulative') {
@@ -34,7 +33,7 @@ function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspac
             const { configValueBase, sourcesRelevant, configName } = entry;
             const valueDataList = [];
             sourcesRelevant.forEach((source) => {
-                const valueData = getValueSerializedFromSource(source, configName, importStatements);
+                const valueData = getValueSerializedFromSource(source, configName, importStatements, filesEnv);
                 valueDataList.push(valueData);
             });
             serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
@@ -42,14 +41,14 @@ function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspac
     });
     return lines;
 }
-function getValueSerializedFromSource(configValueSource, configName, importStatements) {
+function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     assert(configValueSource.isOverriden === false);
     let valueData;
     if ('value' in configValueSource) {
-        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {
-        valueData = getValueSerializedWithImport(configValueSource, importStatements);
+        valueData = getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName);
     }
     return valueData;
 }
@@ -95,27 +94,27 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function getValueSerializedWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     assert(!configValueSource.valueIsFilePath);
-    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
+    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath, configEnv } = configValueSource;
     assert(valueIsImportedAtRuntime);
     const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
     if (valueIsDefinedByPlusFile)
         assert(fileExportName === undefined);
-    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*');
+    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
     return {
         type: valueIsDefinedByPlusFile ? 'plus-file' : 'pointer-import',
         valueAsJsCode: importName
     };
 }
-function getValueSerializedWithJson(value, configName, definedAtData, importStatements) {
-    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
+function getValueSerializedWithJson(value, configName, definedAtData, importStatements, filesEnv, configEnv) {
+    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements, filesEnv, configEnv);
     return {
         type: 'js-serialized',
         valueAsJsCode
     };
 }
-function valueToJson(value, configName, definedAtData, importStatements) {
+function valueToJson(value, configName, definedAtData, importStatements, filesEnv, configEnv) {
     const valueName = `config${getPropAccessNotation(configName)}`;
     let configValueSerialized;
     try {
@@ -130,7 +129,7 @@ function valueToJson(value, configName, definedAtData, importStatements) {
                 if (typeof value === 'string') {
                     const importData = parsePointerImportData(value);
                     if (importData) {
-                        const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName);
+                        const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName, filesEnv, configEnv, configName);
                         const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
                         return { replacement };
                     }
@@ -167,7 +166,8 @@ function logJsonSerializeError(err, configName, definedAtData) {
 }
 function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
     const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
-        if (!isEnvMatch(valueInfo.configEnv))
+        const { configEnv, value } = valueInfo;
+        if (!isEnvMatch(configEnv))
             return 'SKIP';
         // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
         if (pageConfig.configValueSources[configName])
@@ -176,7 +176,7 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
             type: 'computed',
             definedAtData: null
         };
-        return { configValueBase, value: valueInfo.value, configName };
+        return { configValueBase, value, configName, configEnv };
     });
     const fromSources = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
         const configDef = pageConfig.configDefinitions[configName];
@@ -221,3 +221,54 @@ function getDefinedAtFileSource(source) {
     };
     return definedAtFile;
 }
+/*
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ */
+function addImportStatement(importStatements, importPath, exportName, filesEnv, configEnv, configName) {
+    const importCounter = importStatements.length + 1;
+    const importName = `import${importCounter}`;
+    const importLiteral = (() => {
+        if (exportName === '*') {
+            return `* as ${importName}`;
+        }
+        if (exportName === 'default') {
+            return importName;
+        }
+        return `{ ${exportName} as ${importName} }`;
+    })();
+    const importStatement = `import ${importLiteral} from '${importPath}';`;
+    importStatements.push(importStatement);
+    assertFileEnv(importPath, configEnv, configName, filesEnv);
+    return { importName };
+}
+function assertFileEnv(importPath, configEnv, configName, filesEnv) {
+    const key = importPath;
+    assert(key);
+    assertPosixPath(key);
+    assert(!isRelativeImportPath(key));
+    if (!filesEnv.has(key)) {
+        filesEnv.set(key, []);
+    }
+    const fileEnvs = filesEnv.get(key);
+    const fileEnvNew = { configEnv, configName };
+    fileEnvs.push(fileEnvNew);
+    const fileEnvDiff = fileEnvs.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
+    if (fileEnvDiff) {
+        assertUsage(false, [
+            `${importPath} defines the value of configs living in different environments:`,
+            ...[fileEnvDiff, fileEnvNew].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnv))}`),
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
+        ].join('\n'));
+    }
+}
+// TODO/now dedupe
+function isRelativeImportPath(importPath) {
+    return importPath.startsWith('./') || importPath.startsWith('../');
+}

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

@@ -10,6 +10,7 @@ import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/get
 async function loadPageRoutes(
 // Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
+    // TODO/next-major: remove & make this function sync
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
     const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
     const pageRoutes = getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds);

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

@@ -12,7 +12,6 @@ export * from '../utils/isPlainObject.js';
 export * from '../utils/compareString.js';
 export * from '../utils/isNotNullish.js';
 export * from '../utils/stringifyStringArray.js';
-export * from '../utils/filesystemPathHandling.js';
 export * from '../utils/cast.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';

package/dist/esm/shared/utils.js

@@ -16,7 +16,6 @@ export * from '../utils/isPlainObject.js';
 export * from '../utils/compareString.js';
 export * from '../utils/isNotNullish.js';
 export * from '../utils/stringifyStringArray.js';
-export * from '../utils/filesystemPathHandling.js';
 export * from '../utils/cast.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.220";
+export declare const PROJECT_VERSION: "0.4.221-commit-8577456";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.220';
+export const PROJECT_VERSION = '0.4.221-commit-8577456';

package/dist/esm/utils/assertSetup.js

@@ -32,7 +32,7 @@ function onSetupRuntime() {
     if (!isViteLoaded()) {
         // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
         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 });
-        assertUsage(!setup.vikeVitePlugin, "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.");
+        assertUsage(!setup.vikeVitePlugin, `Loading Vike's Vite plugin (the ${pc.cyan('vike/plugin')} module) is prohibited in production.`);
         // This assert() one of the main goal of this file: it ensures assertIsNotProductionRuntime()
         assert(!setup.shouldNotBeProduction);
     }

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

@@ -0,0 +1,2 @@
+export { catchInfiniteLoop };
+declare function catchInfiniteLoop(functionName: `${string}()`, maxNumberOfCalls?: number, withinSeconds?: number): void;

package/dist/esm/utils/catchInfiniteLoop.js

@@ -0,0 +1,32 @@
+export { catchInfiniteLoop };
+import { assert, assertWarning } from './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) {
+        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
+        assertWarning(false, msg, { onlyOnce: false });
+        tracker.warned = true;
+    }
+}
+function createTracker(now) {
+    const tracker = {
+        count: 0,
+        start: now
+    };
+    return tracker;
+}

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:globalContext", "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:esbuild-resolve", "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"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

@@ -13,6 +13,7 @@ assert(!isBrowser());
 globalThis.__brillout_debug_createDebugger = createDebugger;
 const flags = [
     'vike:error',
+    'vike:esbuild-resolve',
     'vike:extractAssets',
     'vike:extractExportNames',
     'vike:glob',
@@ -25,9 +26,9 @@ const flags = [
     'vike:routing',
     'vike:setup',
     'vike:stream',
-    'vike:virtual-files',
-    'vike:esbuild-resolve'
+    'vike:virtual-files'
 ];
+const flagsSkipWildcard = ['vike:log'];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;
 assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
@@ -72,8 +73,8 @@ function debug_(flag, options, ...msgs) {
 function isDebugActivated(flag) {
     checkType(flag);
     assert(flags.includes(flag));
-    const flagsActivated = getFlagsActivated();
-    const isActivated = flagsActivated.includes(flag);
+    const { flagsActivated, all } = getFlagsActivated();
+    const isActivated = flagsActivated.includes(flag) || (all && !flagsSkipWildcard.includes(flag));
     return isActivated;
 }
 function formatMsg(info, options, padding, position) {
@@ -137,7 +138,7 @@ function replaceFunctionSerializer(_key, value) {
     return value;
 }
 function assertFlagsActivated() {
-    const flagsActivated = getFlagsActivated();
+    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')}`);
     });
@@ -145,7 +146,8 @@ function assertFlagsActivated() {
 function getFlagsActivated() {
     const DEBUG = getDEBUG() ?? '';
     const flagsActivated = DEBUG.match(flagRegex) ?? [];
-    return flagsActivated;
+    const all = DEBUG.includes('vike:*');
+    return { flagsActivated, all };
 }
 function getDEBUG() {
     let DEBUG;

package/dist/esm/utils/findFile.js

@@ -2,7 +2,8 @@ export { findFile };
 import path from 'path';
 import fs from 'fs';
 import { isArray } from './isArray.js';
-import { assertPosixPath } from './filesystemPathHandling.js';
+import { assertPosixPath } from './path.js';
+// We need to be able to crawl the filesystem, regardless of Vike's `$ git ls-files` command call, because we need to fallback if the user didn't setup Git (e.g. we cannot remove the fast-glob fallback).
 function findFile(arg, cwd) {
     assertPosixPath(cwd);
     const filenames = isArray(arg) ? arg : [arg];

package/dist/esm/utils/isDev.js

@@ -1,11 +1,11 @@
 export { isDevCheck };
 export { applyDev };
 export { applyPreview };
-import { assert } from './assert.js';
+import { assertUsage } from './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')`
-    assert(typeof isPreview === 'boolean');
+    // `assertVersion('Vite', version, '5.1.0')` isn't enough: https://github.com/vitejs/vite/pull/19355
+    assertUsage(typeof isPreview === 'boolean', 'You are using an old Vite version; make sure to use Vite 5.1.0 or above.');
     return command === 'serve' && !isPreview;
 }
 function applyDev(_, env) {

package/dist/esm/utils/isFilePathAbsoluteFilesystem.js

@@ -2,7 +2,7 @@ export { assertFilePathAbsoluteFilesystem };
 export { isFilePathAbsolute };
 import path from 'path';
 import { assert } from './assert.js';
-import { assertPosixPath } from './filesystemPathHandling.js';
+import { assertPosixPath } from './path.js';
 /**
  * Asserts that `filePath` is an absolute file path starting from the filesystem root.
  *

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

@@ -0,0 +1,3 @@
+export { makePublicCopy };
+/** Prefix internal properties with `_` + show warning */
+declare function makePublicCopy<Obj extends Record<string, unknown>, PropsPublic extends readonly (keyof Obj)[]>(obj: Obj, objName: string, propsPublic: PropsPublic, propsInternalNoWarning?: (keyof Obj)[]): Pick<Obj, PropsPublic[number]>;

package/dist/esm/utils/makePublicCopy.js

@@ -0,0 +1,30 @@
+export { makePublicCopy };
+import { assertWarning } from './assert.js';
+import { objectKeys } from './objectKeys.js';
+/** Prefix internal properties with `_` + show warning */
+function makePublicCopy(obj, objName, propsPublic, propsInternalNoWarning) {
+    const objPublic = {};
+    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() {
+                        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/esm/utils/objectAssignSafe.d.ts

@@ -0,0 +1 @@
+export declare function objectAssignSafe<Obj extends Record<string, unknown>, ObjNewVals extends Partial<Obj>>(obj: Obj, objNewVals: ObjNewVals): void;

package/dist/esm/utils/objectAssignSafe.js

@@ -0,0 +1,4 @@
+// Same as `Object.assign(obj, objNewVals)` but ensure that `objNewVals` properties alreay exist on `obj`
+export function objectAssignSafe(obj, objNewVals) {
+    Object.assign(obj, objNewVals);
+}