vike 0.4.220 → 0.4.221-commit-8577456

package/dist/cjs/node/shared/resolveBase.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveBase = resolveBase;
+exports.resolveBaseRuntime = resolveBaseRuntime;
 exports.resolveBaseFromResolvedConfig = resolveBaseFromResolvedConfig;
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -12,6 +13,12 @@ function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     (0, utils_js_1.assert)(baseViteOriginal === null || typeof baseViteOriginal == 'string');
     return resolveBase(baseViteOriginal, baseServer, baseAssets);
 }
+function resolveBaseRuntime(globalContext) {
+    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
+    const baseServerUnresolved = globalContext.config.baseServer ?? null;
+    const baseAssetsUnresolved = globalContext.config.baseAssets ?? null;
+    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
+}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;

package/dist/cjs/shared/getPageConfigsRuntime.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageConfigsRuntime = getPageConfigsRuntime;
+exports.getAllPageIds = getAllPageIds;
+const parseGlobResults_js_1 = require("./getPageFiles/parseGlobResults.js");
+const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
+const utils_js_1 = require("./utils.js");
+function getPageConfigsRuntime(virtualFileExports) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = (0, parseGlobResults_js_1.parseGlobResults)(virtualFileExports);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    // TODO/now: re-use this call, instead of calling it twice
+    const globalConfig = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)(pageConfigGlobal);
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig };
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = (0, utils_js_1.unique)(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

package/dist/cjs/shared/getPageContextUrlComputed.js

@@ -39,24 +39,29 @@ function getUrlParsed(pageContext) {
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
     // Determine logical URL
+    // TODO/soon: revert https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
+    const assertUrlResolved = (src) => (0, utils_js_1.assert)(urlResolved && typeof urlResolved === 'string', { src, urlResolved });
     let urlResolved;
     let baseToBeRemoved;
     if (pageContext.urlLogical) {
         // Set by onBeforeRoute()
         urlResolved = pageContext.urlLogical;
         baseToBeRemoved = false;
+        assertUrlResolved(1);
     }
     else if (pageContext._urlRewrite) {
         // Set by `throw render()`
         urlResolved = pageContext._urlRewrite;
         baseToBeRemoved = false;
+        assertUrlResolved(2);
     }
     else {
         // Set by renderPage()
         urlResolved = pageContext.urlOriginal;
         baseToBeRemoved = true;
+        assertUrlResolved(3);
     }
-    (0, utils_js_1.assert)(urlResolved && typeof urlResolved === 'string');
+    assertUrlResolved(4);
     // Remove .pageContext.json
     let urlHandler = pageContext._urlHandler;
     if (!urlHandler)

package/dist/cjs/shared/getPageFiles/fileTypes.js

@@ -21,7 +21,6 @@ function isValidFileType(filePath) {
     return ['.js', '.mjs', '.cjs', '.css'].some((ext) => filePath.endsWith(ext));
 }
 function determineFileType(filePath) {
-    (0, utils_js_1.assertPosixPath)(filePath);
     {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {

package/dist/cjs/shared/getPageFiles/getAllPageIdFiles.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageFilesClientSide = getPageFilesClientSide;
 exports.getPageFilesServerSide = getPageFilesServerSide;
 const utils_js_1 = require("../utils.js");
-const assertPageFilePath_js_1 = require("../assertPageFilePath.js");
 function getPageFilesClientSide(pageFilesAll, pageId) {
     return determine(pageFilesAll, pageId, true);
 }
@@ -88,8 +87,6 @@ function getPageFilesSorter(envIsClient, pageId) {
     };
 }
 function getPathDistance(pathA, pathB) {
-    (0, assertPageFilePath_js_1.assertPageFilePath)(pathA);
-    (0, assertPageFilePath_js_1.assertPageFilePath)(pathB);
     // Index of first different character
     let idx = 0;
     for (; idx < pathA.length && idx < pathB.length; idx++) {

package/dist/cjs/shared/getPageFiles/getPageFileObject.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageFileObject = getPageFileObject;
 const determinePageIdOld_js_1 = require("../determinePageIdOld.js");
-const assertPageFilePath_js_1 = require("../assertPageFilePath.js");
 const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("../utils.js");
 const fileTypes_js_1 = require("./fileTypes.js");
@@ -38,19 +37,15 @@ function getPageFileObject(filePath) {
     return pageFile;
 }
 function isDefaultFilePath(filePath) {
-    (0, assertPageFilePath_js_1.assertPageFilePath)(filePath);
     if ((0, error_page_js_1.isErrorPageId)(filePath, false)) {
         return false;
     }
     return filePath.includes('/_default');
 }
 function isRendererFilePath(filePath) {
-    (0, assertPageFilePath_js_1.assertPageFilePath)(filePath);
     return filePath.includes('/renderer/');
 }
 function isAncestorDefaultPage(pageId, defaultPageFilePath) {
-    (0, assertPageFilePath_js_1.assertPageFilePath)(pageId);
-    (0, assertPageFilePath_js_1.assertPageFilePath)(defaultPageFilePath);
     (0, utils_js_1.assert)(!pageId.endsWith('/'));
     (0, utils_js_1.assert)(!defaultPageFilePath.endsWith('/'));
     (0, utils_js_1.assert)(isDefaultFilePath(defaultPageFilePath));

package/dist/cjs/shared/getPageFiles/parseGlobResults.js

@@ -7,6 +7,7 @@ const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js")
 const getPageFileObject_js_1 = require("./getPageFileObject.js");
 const fileTypes_js_1 = require("./fileTypes.js");
 const parsePageConfigs_js_1 = require("../page-configs/serialize/parsePageConfigs.js");
+// TODO/now: rename
 function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesLazy', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesEager', 'object'));
@@ -62,11 +63,11 @@ function parseGlobResults(pageFilesExports) {
     pageFilesExports.pageFilesList.forEach((filePath) => {
         pageFilesMap[filePath] = pageFilesMap[filePath] ?? (0, getPageFileObject_js_1.getPageFileObject)(filePath);
     });
-    const pageFiles = Object.values(pageFilesMap);
-    pageFiles.forEach(({ filePath }) => {
+    const pageFilesAll = Object.values(pageFilesMap);
+    pageFilesAll.forEach(({ filePath }) => {
         (0, utils_js_1.assert)(!filePath.includes('\\'));
     });
-    return { pageFiles, pageConfigs, pageConfigGlobal };
+    return { pageFilesAll, pageConfigs, pageConfigGlobal };
 }
 function parseGlobResult(globObject) {
     const ret = [];

package/dist/cjs/shared/getPageFiles.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageConfigUserFriendly = exports.getPageFilesServerSide = exports.getPageFilesClientSide = void 0;
+exports.getPageFilesServerSide = exports.getPageFilesClientSide = void 0;
 var getAllPageIdFiles_js_1 = require("./getPageFiles/getAllPageIdFiles.js");
 Object.defineProperty(exports, "getPageFilesClientSide", { enumerable: true, get: function () { return getAllPageIdFiles_js_1.getPageFilesClientSide; } });
 var getAllPageIdFiles_js_2 = require("./getPageFiles/getAllPageIdFiles.js");
 Object.defineProperty(exports, "getPageFilesServerSide", { enumerable: true, get: function () { return getAllPageIdFiles_js_2.getPageFilesServerSide; } });
-var getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
-Object.defineProperty(exports, "getPageConfigUserFriendly", { enumerable: true, get: function () { return getPageConfigUserFriendly_js_1.getPageConfigUserFriendly; } });

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

@@ -3,14 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageConfigUserFriendly = getPageConfigUserFriendly;
+exports.getPageConfigUserFriendlyOld = getPageConfigUserFriendlyOld;
 exports.getPageConfigUserFriendlyNew = getPageConfigUserFriendlyNew;
 const assert_exports_old_design_js_1 = require("../getPageFiles/assert_exports_old_design.js");
 const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
 const helpers_js_1 = require("./helpers.js");
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@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
@@ -35,7 +44,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;
@@ -68,11 +77,11 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     (0, utils_js_1.assert)(!('default' in exports));
     (0, utils_js_1.assert)(!('default' in exportsAll));
     const pageContextExports = {
+        config: config,
         from,
         source,
         sources,
         // TODO/eventually: deprecate/remove every prop below
-        config,
         configEntries,
         exports,
         exportsAll,
@@ -81,7 +90,7 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     return pageContextExports;
 }
 // V1 design
-function getPageConfigUserFriendlyNew(pageConfig) {
+function getPageConfigUserFriendlyV1Desin(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -156,7 +165,7 @@ function getPageConfigUserFriendlyNew(pageConfig) {
         });
     });
     return {
-        config,
+        config: config,
         configEntries,
         exportsAll,
         source,

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

@@ -9,7 +9,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)
+        (0, utils_js_1.assert)(false, { moduleExports, configValuesLoaded, moduleId });
     const configValues = (0, parsePageConfigs_js_1.parseConfigValuesSerialized)(configValuesLoaded.configValuesSerialized);
     Object.assign(pageConfig.configValues, configValues);
     (0, utils_js_1.objectAssign)(pageConfig, { isAllLoaded: true });

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

@@ -7,7 +7,6 @@ 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");
 const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
 const helpers_js_1 = require("../helpers.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
@@ -18,20 +17,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.
 (0, assertSetup_js_1.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') {
             (0, utils_js_1.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') {
             (0, utils_js_1.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') {
@@ -39,7 +38,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);
@@ -47,14 +46,14 @@ function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspac
     });
     return lines;
 }
-function getValueSerializedFromSource(configValueSource, configName, importStatements) {
+function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     (0, utils_js_1.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;
 }
@@ -100,27 +99,27 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function getValueSerializedWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
-    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
+    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath, configEnv } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
     const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
     if (valueIsDefinedByPlusFile)
         (0, utils_js_1.assert)(fileExportName === undefined);
-    const { importName } = (0, addImportStatement_js_1.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${(0, utils_js_1.getPropAccessNotation)(configName)}`;
     let configValueSerialized;
     try {
@@ -135,7 +134,7 @@ function valueToJson(value, configName, definedAtData, importStatements) {
                 if (typeof value === 'string') {
                     const importData = (0, transformPointerImports_js_1.parsePointerImportData)(value);
                     if (importData) {
-                        const { importName } = (0, addImportStatement_js_1.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 };
                     }
@@ -172,7 +171,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])
@@ -181,7 +181,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];
@@ -226,3 +226,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;
+    (0, utils_js_1.assert)(key);
+    (0, utils_js_1.assertPosixPath)(key);
+    (0, utils_js_1.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) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
+    if (fileEnvDiff) {
+        (0, utils_js_1.assertUsage)(false, [
+            `${importPath} defines the value of configs living in different environments:`,
+            ...[fileEnvDiff, fileEnvNew].map((c) => `  - config ${picocolors_1.default.code(c.configName)} which value lives in environment ${picocolors_1.default.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/cjs/shared/route/loadPageRoutes.js

@@ -12,6 +12,7 @@ const getHook_js_1 = require("../hooks/getHook.js");
 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/cjs/shared/utils.js

@@ -32,7 +32,6 @@ __exportStar(require("../utils/isPlainObject.js"), exports);
 __exportStar(require("../utils/compareString.js"), exports);
 __exportStar(require("../utils/isNotNullish.js"), exports);
 __exportStar(require("../utils/stringifyStringArray.js"), exports);
-__exportStar(require("../utils/filesystemPathHandling.js"), exports);
 __exportStar(require("../utils/cast.js"), exports);
 __exportStar(require("../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../utils/isPromise.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.220';
+exports.PROJECT_VERSION = '0.4.221-commit-8577456';

package/dist/cjs/utils/assertSetup.js

@@ -37,7 +37,7 @@ function onSetupRuntime() {
     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 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.");
+        (0, assert_js_1.assertUsage)(!setup.vikeVitePlugin, `Loading Vike's Vite plugin (the ${picocolors_1.default.cyan('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);
     }

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

@@ -18,6 +18,7 @@ const isArray_js_1 = require("./isArray.js");
 globalThis.__brillout_debug_createDebugger = createDebugger;
 const flags = [
     'vike:error',
+    'vike:esbuild-resolve',
     'vike:extractAssets',
     'vike:extractExportNames',
     'vike:glob',
@@ -30,9 +31,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) {
@@ -77,8 +78,8 @@ function debug_(flag, options, ...msgs) {
 function isDebugActivated(flag) {
     (0, checkType_js_1.checkType)(flag);
     (0, assert_js_1.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) {
@@ -142,7 +143,7 @@ function replaceFunctionSerializer(_key, value) {
     return value;
 }
 function assertFlagsActivated() {
-    const flagsActivated = getFlagsActivated();
+    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')}`);
     });
@@ -150,7 +151,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/cjs/utils/findFile.js

@@ -7,16 +7,17 @@ exports.findFile = findFile;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const isArray_js_1 = require("./isArray.js");
-const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const path_js_1 = require("./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) {
-    (0, filesystemPathHandling_js_1.assertPosixPath)(cwd);
+    (0, path_js_1.assertPosixPath)(cwd);
     const filenames = (0, isArray_js_1.isArray)(arg) ? arg : [arg];
     let dir = cwd;
     while (true) {
         for (const filename of filenames) {
             const configFilePath = path_1.default.posix.join(dir, `./${filename}`);
             if (fs_1.default.existsSync(configFilePath)) {
-                (0, filesystemPathHandling_js_1.assertPosixPath)(configFilePath);
+                (0, path_js_1.assertPosixPath)(configFilePath);
                 return configFilePath;
             }
         }

package/dist/cjs/utils/isDev.js

@@ -6,8 +6,8 @@ exports.applyPreview = applyPreview;
 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')`
-    (0, assert_js_1.assert)(typeof isPreview === 'boolean');
+    // `assertVersion('Vite', version, '5.1.0')` isn't enough: https://github.com/vitejs/vite/pull/19355
+    (0, assert_js_1.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/cjs/utils/isFilePathAbsoluteFilesystem.js

@@ -7,7 +7,7 @@ exports.assertFilePathAbsoluteFilesystem = assertFilePathAbsoluteFilesystem;
 exports.isFilePathAbsolute = isFilePathAbsolute;
 const path_1 = __importDefault(require("path"));
 const assert_js_1 = require("./assert.js");
-const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const path_js_1 = require("./path.js");
 /**
  * Asserts that `filePath` is an absolute file path starting from the filesystem root.
  *
@@ -19,7 +19,7 @@ function assertFilePathAbsoluteFilesystem(filePath) {
     // - For Linux users assertFilePathAbsoluteFilesystem() will erroneously succeed if `p` is a path absolute from the user root dir.
     //   - But that's okay because the assertion will eventually fail for Windows users.
     (0, assert_js_1.assert)(isFilePathAbsoluteFilesystem(filePath));
-    (0, filesystemPathHandling_js_1.assertPosixPath)(filePath);
+    (0, path_js_1.assertPosixPath)(filePath);
 }
 /**
  * Whether `filePath` is an absolute file path starting from the filesystem root.

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectAssignSafe = objectAssignSafe;
+// Same as `Object.assign(obj, objNewVals)` but ensure that `objNewVals` properties alreay exist on `obj`
+function objectAssignSafe(obj, objNewVals) {
+    Object.assign(obj, objNewVals);
+}