vike 0.4.143 → 0.4.144-commit-e40e9b1

package/dist/cjs/node/prerender/runPrerender.js

@@ -42,7 +42,7 @@ const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const getPageContextRequestUrl_js_1 = require("../../shared/getPageContextRequestUrl.js");
 const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.js");
 const utils_js_2 = require("../../shared/page-configs/utils.js");
-const loadPageCode_js_1 = require("../../shared/page-configs/loadPageCode.js");
+const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const addUrlComputedProps_js_1 = require("../../shared/addUrlComputedProps.js");
 const assertPathIsFilesystemAbsolute_js_1 = require("../../utils/assertPathIsFilesystemAbsolute.js");
@@ -72,7 +72,7 @@ async function runPrerender(options, manuallyTriggered) {
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);
     const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
-    const { outDirClient, outDirRoot } = (0, utils_js_1.getOutDirs_prerender)(viteConfig);
+    const { outDirClient, outDirRoot } = (0, utils_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = configVike.prerender;
     if (!prerenderConfig) {
@@ -115,12 +115,13 @@ async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concu
         const configName = 'prerender';
         const configValue = (0, utils_js_2.getConfigValue)(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
-            const definedAtInfo = (0, utils_js_2.getConfigDefinedAtInfo)(pageConfig, configName);
+            const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
+            (0, utils_js_1.assert)(configValueFilePathToShowToUser);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
                 setByConfigValue: false,
-                setByConfigFile: definedAtInfo.filePath
+                setByConfigFile: configValueFilePathToShowToUser
             });
         }
     });
@@ -171,13 +172,12 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
     // V1 design
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
-        const pageConfigLoaded = await (0, loadPageCode_js_1.loadPageCode)(pageConfig, false);
+        const pageConfigLoaded = await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
         const configValue = (0, utils_js_2.getConfigValue)(pageConfigLoaded, hookName);
         if (!configValue)
             return;
         const hookFn = configValue.value;
-        const definedAtInfo = (0, utils_js_2.getConfigDefinedAtInfo)(pageConfigLoaded, hookName);
-        const hookFilePath = definedAtInfo.filePath;
+        const hookFilePath = (0, utils_js_2.getHookFilePathToShowToUser)(configValue);
         (0, utils_js_1.assert)(hookFilePath);
         (0, getHook_js_1.assertHookFn)(hookFn, { hookName, hookFilePath });
         onBeforePrerenderStartHooks.push({
@@ -309,20 +309,18 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     let onPrerenderStartHook;
     // V1 design
     if (renderContext.pageConfigs.length > 0) {
-        const configValueSource = renderContext.pageConfigGlobal.onPrerenderStart;
-        if (configValueSource) {
-            const hookFn = configValueSource.value;
-            (0, utils_js_1.assert)(!configValueSource.isComputed);
-            const hookFilePath = configValueSource.definedAtInfo.filePath;
-            (0, utils_js_1.assert)(hookFn);
+        const { pageConfigGlobal } = renderContext;
+        const configValue = pageConfigGlobal.configValues.onPrerenderStart;
+        if (configValue?.value) {
+            const { value: hookFn } = configValue;
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            const hookFilePath = (0, utils_js_2.getHookFilePathToShowToUser)(configValue);
             (0, utils_js_1.assert)(hookFilePath);
-            if (hookFn) {
-                onPrerenderStartHook = {
-                    hookFn,
-                    hookName: 'onPrerenderStart',
-                    hookFilePath
-                };
-            }
+            onPrerenderStartHook = {
+                hookFn,
+                hookName: 'onPrerenderStart',
+                hookFilePath
+            };
         }
     }
     // Old design

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -111,7 +111,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     if (!isHtmlOnly) {
         // Don't allow the user to manipulate with injectFilter(): injecting <script type="application/json"> before the stream can break the app when:
         //  - using https://vike.dev/stream#initial-data-after-stream-end
-        //  - `pageContext` is modified during the stream, e.g. /examples/vue-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
+        //  - `pageContext` is modified during the stream, e.g. https://github.com/brillout/vike-with-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
         // The <script> tags are handled separately by vike down below.
         htmlTags.push({
             // Needs to be called after `resolvePageContextPromise()`

package/dist/cjs/node/runtime/renderPage/analyzePage.js

@@ -28,14 +28,14 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
         }
         /* Remove?
         Object.values(pageConfig.configElements).forEach((configElement) => {
-          if (configElement.importFilePath) {
+          if (configElement.importPath) {
             const { env } = configElement
             assert(env)
             const onlyAssets = env === 'server-only'
             const eagerlyImported = env === '_routing-eager'
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
-                id: configElement.importFilePath,
+                id: configElement.importPath,
                 onlyAssets,
                 eagerlyImported
               })

package/dist/cjs/node/runtime/renderPage/loadPageFilesServerSide.js

@@ -9,7 +9,7 @@ const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
 const globalContext_js_1 = require("../globalContext.js");
-const loadPageCode_js_1 = require("../../../shared/page-configs/loadPageCode.js");
+const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
 async function loadPageFilesServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ config, configEntries, exports, exportsAll, pageExports, pageFilesLoaded, pageConfigLoaded }] = await Promise.all([
@@ -85,7 +85,7 @@ async function loadPageFilesServerSide(pageContext) {
 exports.loadPageFilesServerSide = loadPageFilesServerSide;
 async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await (0, loadPageCode_js_1.loadPageCode)(pageConfig, isDev);
+    const pageConfigLoaded = !pageConfig ? null : await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
     const { config, configEntries, exports, exportsAll, pageExports } = (0, getPageFiles_js_1.getExports)(pageFilesServerSide, pageConfigLoaded);
     return {

package/dist/cjs/node/runtime/renderPage/log404/index.js

@@ -72,8 +72,8 @@ function getPagesAndRoutesInfo(pageRoutes) {
         ...entries
     ];
     const terminalWidth = (0, utils_js_1.getTerminalWidth)() || 134;
-    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => routeTypeSrc.length));
-    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => routeDefinedBy.length));
+    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => (0, utils_js_1.stripAnsi)(routeTypeSrc).length));
+    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => (0, utils_js_1.stripAnsi)(routeDefinedBy).length));
     let width1 = terminalWidth - width3 - width2 - 10;
     linesContent.forEach((lineContent) => {
         let { routeStr } = lineContent;
@@ -88,9 +88,9 @@ function getPagesAndRoutesInfo(pageRoutes) {
     });
     width1 = Math.max(...linesContent.map(({ routeStr }) => (0, utils_js_1.stripAnsi)(routeStr).length));
     let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
-        let cell1 = routeStr.padEnd(width1 + (routeStr.length - (0, utils_js_1.stripAnsi)(routeStr).length), ' ');
-        let cell2 = routeTypeSrc.padEnd(width2, ' ');
-        let cell3 = routeDefinedBy.padEnd(width3, ' ');
+        let cell1 = padEnd(routeStr, width1 + ((0, utils_js_1.stripAnsi)(routeStr).length - (0, utils_js_1.stripAnsi)(routeStr).length));
+        let cell2 = padEnd(routeTypeSrc, width2);
+        let cell3 = padEnd(routeDefinedBy, width3);
         const isHeader = i === 0;
         if (isHeader) {
             cell1 = picocolors_1.default.dim(cell1);
@@ -125,6 +125,11 @@ function truncateRouteFunction(routeStr, lenMax) {
     routeStr = (0, utils_js_1.truncateString)(routeStr, lenMax, (s) => picocolors_1.default.dim(s));
     return routeStr;
 }
+/** Same as String.prototype.padEnd but with stripAnsi() */
+function padEnd(str, width) {
+    const padWidth = Math.max(0, width - (0, utils_js_1.stripAnsi)(str).length);
+    return str + ''.padEnd(padWidth, ' ');
+}
 function removeNonAscii(str) {
     // https://stackoverflow.com/questions/20856197/remove-non-ascii-character-in-string/20856346#20856346
     return str.replace(/[^\x00-\x7F]/g, '');

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -21,6 +21,7 @@ const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePa
 const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
 const loadPageRoutes_js_1 = require("../../../shared/route/loadPageRoutes.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_2 = require("../../../shared/page-configs/utils.js");
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -172,9 +173,9 @@ function assertNonMixedDesign(pageFilesAll, pageConfigs) {
     const indent = '- ';
     const v1Files = (0, utils_js_1.unique)(pageConfigs
         .map((p) => Object.values(p.configValues)
-        .map(({ definedAtInfo }) => definedAtInfo)
+        .map(utils_js_2.getConfigValueFilePathToShowToUser)
         .filter(utils_js_1.isNotNullish)
-        .map((definedAtInfo) => indent + definedAtInfo.filePath))
+        .map((filePathToShowToUser) => indent + filePathToShowToUser))
         .flat(2));
     (0, utils_js_1.assertUsage)(false, [
         'Mixing the new V1 design with the old V0.4 design is forbidden.',

package/dist/cjs/node/runtime/renderPage.js

@@ -311,7 +311,7 @@ function getRequestId() {
 }
 function skipRequest(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    (0, utils_js_1.assertWarning)(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
+    (0, utils_js_1.assertWarning)(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
     return (urlOriginal.endsWith('/__vite_ping') ||
         urlOriginal.endsWith('/favicon.ico') ||
         !(0, utils_js_1.isParsable)(urlOriginal) ||

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

@@ -2,17 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getClientEntryFilePath = void 0;
 const utils_js_1 = require("../../shared/page-configs/utils.js");
-const utils_js_2 = require("./utils.js");
 function getClientEntryFilePath(pageConfig) {
     const configName = 'client';
     const configValue = (0, utils_js_1.getConfigValue)(pageConfig, configName, 'string');
     if (!configValue)
         return null;
-    const definedAtInfo = (0, utils_js_1.getConfigDefinedAtInfo)(pageConfig, configName);
-    const { value } = configValue;
-    // Users should be able to suppress client entry by setting its value to null
-    (0, utils_js_2.assert)(value !== null);
-    const clientEntryFilePath = definedAtInfo.filePath;
-    return clientEntryFilePath;
+    return configValue.value;
 }
 exports.getClientEntryFilePath = getClientEntryFilePath;

package/dist/cjs/shared/assertPageContextProvidedByUser.js

@@ -15,7 +15,7 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     (0, utils_js_1.assertUsage)(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
-    (0, utils_js_1.assertWarning)(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext._pageId')} which means that vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
+    (0, utils_js_1.assertWarning)(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext._pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
     (0, utils_js_1.assertUsage)(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext.is404')} which is forbidden, use ${picocolors_1.default.cyan('throw render()')} instead, see https://vike.dev/render`);
 }
 exports.assertPageContextProvidedByUser = assertPageContextProvidedByUser;

package/dist/cjs/shared/error-page.js

@@ -32,7 +32,7 @@ function isErrorPage(pageId, pageConfigs) {
     if (pageConfigs.length > 0) {
         const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
         (0, utils_js_1.assert)(pageConfig);
-        return pageConfig.isErrorPage;
+        return !!pageConfig.isErrorPage;
     }
     else {
         return isErrorPageId(pageId, false);

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExports = exports.getExportUnion = void 0;
 const isScriptFile_js_1 = require("../../utils/isScriptFile.js");
 const utils_js_1 = require("../utils.js");
-const assertExports_js_1 = require("./assertExports.js");
+const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
 const utils_js_2 = require("../page-configs/utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function getExports(pageFiles, pageConfig) {
@@ -33,11 +33,8 @@ function getExports(pageFiles, pageConfig) {
     // V1 design
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            const { value, definedAtInfo } = configValue;
-            let filePath = null;
-            if (definedAtInfo) {
-                filePath = definedAtInfo.filePath;
-            }
+            const { value } = configValue;
+            const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
             const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];
@@ -46,7 +43,7 @@ function getExports(pageFiles, pageConfig) {
             configEntries[configName].push({
                 configValue: value,
                 configDefinedAt,
-                configDefinedByFile: filePath
+                configDefinedByFile: configValueFilePathToShowToUser
             });
             // TODO/v1-release: remove
             const exportName = configName;
@@ -54,8 +51,8 @@ function getExports(pageFiles, pageConfig) {
             exportsAll[exportName].push({
                 exportValue: value,
                 exportSource: configDefinedAt,
-                filePath,
-                _filePath: filePath,
+                filePath: configValueFilePathToShowToUser,
+                _filePath: configValueFilePathToShowToUser,
                 _fileType: null,
                 _isFromDefaultExport: null
             });
@@ -102,7 +99,7 @@ function getExportValues(pageFile) {
             else {
                 (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportValue), `The ${picocolors_1.default.cyan('export default')} of ${filePath} should be an object.`);
                 Object.entries(exportValue).forEach(([defaultExportName, defaultExportValue]) => {
-                    (0, assertExports_js_1.assertDefaultExports)(defaultExportName, filePath);
+                    (0, assert_exports_old_design_js_1.assertDefaultExports)(defaultExportName, filePath);
                     exportValues.push({
                         exportName: defaultExportName,
                         exportValue: defaultExportValue,
@@ -119,7 +116,7 @@ function getExportValues(pageFile) {
         });
     });
     exportValues.forEach(({ exportName, isFromDefaultExport }) => {
-        (0, utils_js_1.assert)(!(isFromDefaultExport && assertExports_js_1.forbiddenDefaultExports.includes(exportName)));
+        (0, utils_js_1.assert)(!(isFromDefaultExport && assert_exports_old_design_js_1.forbiddenDefaultExports.includes(exportName)));
     });
     return exportValues;
 }

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

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGlobResults = void 0;
 const utils_js_1 = require("../utils.js");
-const assertExports_js_1 = require("./assertExports.js");
+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 assertPageConfigs_js_1 = require("./assertPageConfigs.js");
-const parse_1 = require("@brillout/json-serializer/parse");
+const assertPageConfigs_js_1 = require("../page-configs/serialize/assertPageConfigs.js");
+const parsePageConfigs_js_1 = require("../page-configs/serialize/parsePageConfigs.js");
 function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'isGeneratedFile'));
     (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -18,12 +18,12 @@ function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.client') || (0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.server'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesList', 'string[]'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigs'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobal'));
-    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
-    (0, assertPageConfigs_js_1.assertPageConfigs)(pageConfigs);
-    parsePageConfigs(pageConfigs);
-    (0, assertPageConfigs_js_1.assertPageConfigGlobal)(pageConfigGlobal);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigsSerialized'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+    (0, assertPageConfigs_js_1.assertPageConfigsSerialized)(pageConfigsSerialized);
+    (0, assertPageConfigs_js_1.assertPageConfigGlobalSerialized)(pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = (0, parsePageConfigs_js_1.parsePageConfigs)(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
@@ -32,7 +32,7 @@ function parseGlobResults(pageFilesExports) {
         pageFile.loadFile = async () => {
             if (!('fileExports' in pageFile)) {
                 pageFile.fileExports = await loadModule();
-                (0, assertExports_js_1.assertExportValues)(pageFile);
+                (0, assert_exports_old_design_js_1.assertExportValues)(pageFile);
             }
         };
     });
@@ -91,37 +91,3 @@ function parseGlobResult(globObject) {
 function assertLoadModule(globValue) {
     (0, utils_js_1.assert)((0, utils_js_1.isCallable)(globValue));
 }
-function parsePageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            {
-                const { valueSerialized } = configValue;
-                if (valueSerialized !== undefined) {
-                    configValue.value = (0, parse_1.parse)(valueSerialized);
-                }
-            }
-            /*
-            if (configName === 'route') {
-              assertRouteConfigValue(configElement)
-            }
-            */
-        });
-    });
-}
-// TODO: use again
-// function assertRouteConfigValue(configElement: ConfigElement) {
-//   assert(hasProp(configElement, 'configValue')) // route files are eagerly loaded
-//   const { configValue } = configElement
-//   const configValueType = typeof configValue
-//   assertUsage(
-//     configValueType === 'string' || isCallable(configValue),
-//     `${configElement.configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`
-//   )
-//   /* We don't do that to avoid unnecessarily bloating the client-side bundle when using Server Routing
-//    *  - When using Server Routing, this file is loaded as well
-//    *  - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
-//   if (typeof configValue === 'string') {
-//     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
-//   }
-//   */
-// }

package/dist/cjs/shared/hooks/getHook.js

@@ -11,7 +11,9 @@ function getHook(pageContext, hookName) {
     (0, utils_js_1.assert)(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
-    const hookFilePath = file.exportSource;
+    const hookFilePath = file.filePath;
+    (0, utils_js_1.assert)(hookFilePath);
+    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
     assertHookFn(hookFn, { hookName, hookFilePath });
     return { hookFn, hookName, hookFilePath };
 }

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

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExportsOfConfigFile = exports.assertExportsOfValueFile = void 0;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
+    assertExports(fileExports, filePathToShowToUser, configName);
+}
+exports.assertExportsOfValueFile = assertExportsOfValueFile;
+function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
+    assertExports(fileExports, filePathToShowToUser);
+    const exportDefault = fileExports.default;
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportDefault), `The ${picocolors_1.default.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
+}
+exports.assertExportsOfConfigFile = assertExportsOfConfigFile;
+function assertExports(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
+        // !!configName => isValueFile
+        e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsRelevant.length === 1) {
+            return;
+        }
+        else {
+            (0, utils_js_1.assert)(exportsRelevant.length === 0);
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${picocolors_1.default.cyan('export default')}`;
+            if (configName)
+                errMsg += ` or ${picocolors_1.default.cyan(`export { ${configName} }`)}`;
+            (0, utils_js_1.assertUsage)(false, errMsg);
+        }
+    }
+    else {
+        // !configName => isConfigFile
+        if (!configName) {
+            const exportsInvalidStr = exportsInvalid.join(', ');
+            (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} replace ${picocolors_1.default.cyan(`export { ${exportsInvalidStr} }`)} with ${picocolors_1.default.cyan(`export default { ${exportsInvalidStr} }`)}`);
+        }
+        // !!configName => isValueFile
+        else {
+            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+                return;
+            exportsInvalid.forEach((exportInvalid) => {
+                (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} should have only a single export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
+            });
+        }
+    }
+}

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

@@ -2,19 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExportPath = void 0;
 const utils_js_1 = require("../utils.js");
-// TODO: return null instead of 'export default'
-//  - Also return null insead of 'export *'?
-function getExportPath(fileExportPath) {
-    let prefix = '';
-    let suffix = '';
+function getExportPath(fileExportPath, configName) {
+    if (!fileExportPath)
+        return null;
     let [exportName, ...exportObjectPath] = fileExportPath;
     if (!exportName)
         return null;
-    if (exportName === '*') {
-        (0, utils_js_1.assert)(exportObjectPath.length === 0);
-        return 'export *';
-    }
-    else if (exportName === 'default') {
+    if (exportObjectPath.length === 0 && ['*', 'default', configName].includes(exportName))
+        return null;
+    (0, utils_js_1.assert)(exportName !== '*');
+    let prefix = '';
+    let suffix = '';
+    if (exportName === 'default') {
         prefix = 'export default';
     }
     else {

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigValues = void 0;
+const utils_js_1 = require("../utils.js");
+const parseConfigValuesImported_js_1 = require("./serialize/parseConfigValuesImported.js");
+async function loadConfigValues(pageConfig, isDev) {
+    if ('isLoaded' in pageConfig &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const configValuesImported = await pageConfig.loadConfigValuesAll();
+    const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
+    Object.assign(pageConfig.configValues, configValuesAddendum);
+    (0, utils_js_1.objectAssign)(pageConfig, { isLoaded: true });
+    return pageConfig;
+}
+exports.loadConfigValues = loadConfigValues;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPageConfigGlobalSerialized = exports.assertPageConfigsSerialized = void 0;
+const utils_js_1 = require("../../utils.js");
+function assertPageConfigsSerialized(pageConfigsSerialized) {
+    (0, utils_js_1.assert)(Array.isArray(pageConfigsSerialized));
+    pageConfigsSerialized.forEach((pageConfigSerialized) => {
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageConfigSerialized));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'pageId', 'string'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'routeFilesystem'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesSerialized'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesImported'));
+    });
+}
+exports.assertPageConfigsSerialized = assertPageConfigsSerialized;
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobalSerialized, 'configValuesImported'));
+}
+exports.assertPageConfigGlobalSerialized = assertPageConfigGlobalSerialized;

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfigValuesImported = void 0;
+const utils_js_1 = require("../../utils.js");
+const assertExports_js_1 = require("../assertExports.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function parseConfigValuesImported(configValuesImported) {
+    const configValues = {};
+    const addConfigValue = (configName, value, importPath, exportName) => {
+        configValues[configName] = {
+            value,
+            definedAt: {
+                file: {
+                    // importPath cannot be relative to the current file, since the current file is a virtual file
+                    filePathToShowToUser: importPath,
+                    fileExportPath: [configName, 'default'].includes(exportName)
+                        ? []
+                        : // Side-effect config
+                            [exportName]
+                }
+            }
+        };
+        assertIsNotNull(value, configName, importPath);
+    };
+    configValuesImported.forEach((configValueLoaded) => {
+        if (configValueLoaded.isValueFile) {
+            const { exportValues, importPath, configName } = configValueLoaded;
+            if (configName !== 'client') {
+                (0, assertExports_js_1.assertExportsOfValueFile)(exportValues, importPath, configName);
+            }
+            Object.entries(exportValues).forEach(([exportName, exportValue]) => {
+                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
+                const configName = isSideExport ? exportName : configValueLoaded.configName;
+                if (isSideExport && configName in configValues) {
+                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
+                    // Side-exports have the lowest priority.
+                    return;
+                }
+                addConfigValue(configName, exportValue, importPath, exportName);
+            });
+        }
+        else {
+            const { configName, importPath, exportValue, exportName } = configValueLoaded;
+            addConfigValue(configName, exportValue, importPath, exportName);
+        }
+    });
+    return configValues;
+}
+exports.parseConfigValuesImported = parseConfigValuesImported;
+function assertIsNotNull(configValue, configName, importPath) {
+    (0, utils_js_1.assert)(!importPath.includes('+config.'));
+    (0, utils_js_1.assertUsage)(configValue !== null, `Set ${picocolors_1.default.cyan(configName)} to ${picocolors_1.default.cyan('null')} in a +config.h.js file instead of ${importPath}`);
+}