vike 0.4.143-commit-fa295e1 → 0.4.144-commit-e40e9b1

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -11,11 +11,11 @@ const stringify_1 = require("@brillout/json-serializer/stringify");
 const helpers_js_1 = require("./helpers.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
-const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
-const getVirtualFilePageConfigValuesAll_js_1 = require("./getVirtualFilePageConfigValuesAll.js");
+const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
-async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
-    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
+const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
+async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
+    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 exports.getVirtualFilePageConfigs = getVirtualFilePageConfigs;
@@ -33,16 +33,29 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
         lines.push(`    loadConfigValuesAll: async () => (await import(${JSON.stringify(virtualFileIdPageConfigValuesAll)})).default,`);
         lines.push(`    configValuesSerialized: {`);
-        Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+        Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
+            const { value, configEnv } = configValuesComputed;
+            if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
+            if (pageConfig.configValueSources[configName])
+                return;
+            const configValue = pageConfig.configValues[configName];
+            (0, utils_js_1.assert)(configValue);
+            const { definedAt } = configValue;
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+            (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+        });
+        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
             const configValue = pageConfig.configValues[configName];
             if (configValue) {
-                const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig, configName);
+                const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig.configValueSources, configName);
                 (0, utils_js_1.assert)(configEnv, configName);
-                if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+                const isEnvMatch = (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true });
+                if (!isEnvMatch)
                     return;
                 const { value, definedAt } = configValue;
                 const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-                serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+                (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
             }
         });
         lines.push(`    },`);
@@ -56,8 +69,7 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
             (0, utils_js_1.assert)(configValueSource);
             if (configValueSource.configEnv !== '_routing-eager')
                 return;
-            (0, utils_js_1.assert)(!configValueSource.isComputed);
-            lines.push(...(0, getVirtualFilePageConfigValuesAll_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
+            lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);
         // pageConfig end
@@ -86,7 +98,7 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         const configValueSource = sources[0];
         (0, utils_js_1.assert)(configValueSource);
         const whitespace = '    ';
-        lines.push(...(0, getVirtualFilePageConfigValuesAll_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
+        lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push(`  ],`);
     lines.push('};');
@@ -94,29 +106,15 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
     (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function serializeConfigValue(lines, configName, configValueSerialized) {
-    let whitespace = '      ';
-    lines.push(`${whitespace}['${configName}']: {`);
-    whitespace += '  ';
-    Object.entries(configValueSerialized).forEach(([key, val]) => {
-        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
-        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
-    });
-    whitespace = whitespace.slice(2);
-    lines.push(`${whitespace}},`);
-}
 function getConfigValueSerialized(value, configName, definedAt) {
-    let configValueSerialized;
     const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
+    let configValueSerialized;
     try {
         configValueSerialized = (0, stringify_1.stringify)(value, { valueName });
     }
     catch (err) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
         const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)({ definedAt });
-        // definedAt is null when config value is:
-        //  - computed => all computed values defined by Vike can are serializable
-        //  - cumulative => the values are already ensured to be serializable
         (0, utils_js_1.assert)(configValueFilePathToShowToUser);
         (0, utils_js_1.assertUsage)(false, [
             `The value of the config ${picocolors_1.default.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/helpers.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isConfigSet = exports.getConfigEnv = void 0;
 const utils_js_1 = require("../../../utils.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
-function getConfigEnv(pageConfig, configName) {
-    const configValueSource = getConfigValueSource(pageConfig, configName);
+function getConfigEnv(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
     if (configValueSource) {
@@ -23,18 +23,16 @@ function getConfigEnv(pageConfig, configName) {
     }
 }
 exports.getConfigEnv = getConfigEnv;
-function isConfigSet(pageConfig, configName) {
-    const configValueSource = getConfigValueSource(pageConfig, configName);
+function isConfigSet(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
     // Enable users to suppress global config values by overriding the config's value to null
     if (configValueSource?.value === null)
         return false;
     return !!configValueSource;
 }
 exports.isConfigSet = isConfigSet;
-function getConfigValueSource(pageConfig, configName) {
-    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
-    (0, utils_js_1.assert)(pageConfig.configValueSources);
-    const sources = pageConfig.configValueSources[configName];
+function getConfigValueSource(configValueSources, configName) {
+    const sources = configValueSources[configName];
     if (!sources)
         return null;
     const configValueSource = sources[0];

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/isRuntimeEnvMatch.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeEnvMatch = void 0;
+function isRuntimeEnvMatch(configEnv, runtime) {
+    const { isForClientSide, isClientRouting, isEager } = runtime;
+    if (configEnv === 'config-only')
+        return false;
+    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
+        return false;
+    if (configEnv === '_routing-eager' || configEnv === '_routing-lazy') {
+        if (isForClientSide && !isClientRouting)
+            return false;
+        if (isEager !== (configEnv === '_routing-eager'))
+            return false;
+    }
+    return true;
+}
+exports.isRuntimeEnvMatch = isRuntimeEnvMatch;

package/dist/cjs/node/plugin/shared/findPageFiles.js

@@ -9,8 +9,9 @@ const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
+    const { outDirRoot } = (0, utils_js_1.getOutDirs)(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await (0, fast_glob_1.default)(fileTypes.map((fileType) => `**/*${fileType}.${utils_js_1.scriptFileExtensions}`), { ignore: ['**/node_modules/**'], cwd, dot: false });
+    let pageFiles = await (0, fast_glob_1.default)(fileTypes.map((fileType) => `**/*${fileType}.${utils_js_1.scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false });
     pageFiles = pageFiles.map((p) => '/' + (0, utils_js_1.toPosixPath)(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {

package/dist/cjs/node/plugin/utils.js

@@ -1,5 +1,5 @@
 "use strict";
-// Utils needed by vike's Vite plugin.
+// Utils needed by Vike's Vite plugin.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/dist/cjs/node/prerender/runPrerender.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,13 +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 filePath = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
-            (0, utils_js_1.assert)(filePath);
+            const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
+            (0, utils_js_1.assert)(configValueFilePathToShowToUser);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
                 setByConfigValue: false,
-                setByConfigFile: filePath
+                setByConfigFile: configValueFilePathToShowToUser
             });
         }
     });

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/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/getPageFiles/getExports.js

@@ -34,7 +34,7 @@ function getExports(pageFiles, pageConfig) {
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
-            const filePath = (0, utils_js_2.getConfigValueFilePathToShowToUser)(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] ?? [];
@@ -43,7 +43,7 @@ function getExports(pageFiles, pageConfig) {
             configEntries[configName].push({
                 configValue: value,
                 configDefinedAt,
-                configDefinedByFile: filePath
+                configDefinedByFile: configValueFilePathToShowToUser
             });
             // TODO/v1-release: remove
             const exportName = configName;
@@ -51,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
             });

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

@@ -5,8 +5,8 @@ const utils_js_1 = require("../utils.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 parsePageConfigsSerialized_js_1 = require("./parsePageConfigsSerialized.js");
+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.`);
@@ -23,7 +23,7 @@ function parseGlobResults(pageFilesExports) {
     const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
     (0, assertPageConfigs_js_1.assertPageConfigsSerialized)(pageConfigsSerialized);
     (0, assertPageConfigs_js_1.assertPageConfigGlobalSerialized)(pageConfigGlobalSerialized);
-    const { pageConfigs, pageConfigGlobal } = (0, parsePageConfigsSerialized_js_1.parsePageConfigsSerialized)(pageConfigsSerialized, 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;

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");
-function getExportPath(fileExportPath) {
+function getExportPath(fileExportPath, configName) {
     if (!fileExportPath)
         return null;
-    let prefix = '';
-    let suffix = '';
     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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfigValues = void 0;
 const utils_js_1 = require("../utils.js");
-const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.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

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/{getPageFiles → page-configs/serialize}/assertPageConfigs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertPageConfigGlobalSerialized = exports.assertPageConfigsSerialized = void 0;
-const utils_js_1 = require("../utils.js");
+const utils_js_1 = require("../../utils.js");
 function assertPageConfigsSerialized(pageConfigsSerialized) {
     (0, utils_js_1.assert)(Array.isArray(pageConfigsSerialized));
     pageConfigsSerialized.forEach((pageConfigSerialized) => {

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

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (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 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 = {};
@@ -13,10 +13,13 @@ function parseConfigValuesImported(configValuesImported) {
         configValues[configName] = {
             value,
             definedAt: {
-                source: {
-                    // importPath is always relative the user's root directory (it cannot be relative to the current file since the current file is a virtual file)
+                file: {
+                    // importPath cannot be relative to the current file, since the current file is a virtual file
                     filePathToShowToUser: importPath,
-                    fileExportPath: [exportName]
+                    fileExportPath: [configName, 'default'].includes(exportName)
+                        ? []
+                        : // Side-effect config
+                            [exportName]
                 }
             }
         };
@@ -24,11 +27,11 @@ function parseConfigValuesImported(configValuesImported) {
     };
     configValuesImported.forEach((configValueLoaded) => {
         if (configValueLoaded.isValueFile) {
-            const { importFileExports, importPath, configName } = configValueLoaded;
+            const { exportValues, importPath, configName } = configValueLoaded;
             if (configName !== 'client') {
-                (0, assertExports_js_1.assertExportsOfValueFile)(importFileExports, importPath, configName);
+                (0, assertExports_js_1.assertExportsOfValueFile)(exportValues, importPath, configName);
             }
-            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
+            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) {
@@ -40,8 +43,8 @@ function parseConfigValuesImported(configValuesImported) {
             });
         }
         else {
-            const { configName, importPath, importFileExportValue, exportName } = configValueLoaded;
-            addConfigValue(configName, importFileExportValue, importPath, exportName);
+            const { configName, importPath, exportValue, exportName } = configValueLoaded;
+            addConfigValue(configName, exportValue, importPath, exportName);
         }
     });
     return configValues;

package/dist/cjs/shared/{getPageFiles/parsePageConfigsSerialized.js → page-configs/serialize/parsePageConfigs.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePageConfigsSerialized = void 0;
+exports.parsePageConfigs = void 0;
 const parse_1 = require("@brillout/json-serializer/parse");
-const parseConfigValuesImported_js_1 = require("../page-configs/parseConfigValuesImported.js");
-const utils_js_1 = require("../utils.js");
-const utils_js_2 = require("../page-configs/utils.js");
-function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
+const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
+const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../utils.js");
+function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
         {
@@ -44,7 +44,7 @@ function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSeria
     }
     return { pageConfigs, pageConfigGlobal };
 }
-exports.parsePageConfigsSerialized = parsePageConfigsSerialized;
+exports.parsePageConfigs = parsePageConfigs;
 function assertRouteConfigValue(configValues) {
     const configName = 'route';
     const configValue = configValues[configName];

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

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeConfigValueImported = exports.serializeConfigValue = void 0;
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with:
+//   - vike/shared/page-configs/serialize/parsePageConfigs.ts
+//   - vike/shared/page-configs/serialize/parseConfigValuesImported.ts
+// Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
+const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+const path_1 = __importDefault(require("path"));
+const utils_js_1 = require("../../utils.js");
+const generateEagerImport_js_1 = require("../../../node/plugin/plugins/importUserCode/generateEagerImport.js");
+function serializeConfigValue(lines, configName, configValueSerialized) {
+    let whitespace = '      ';
+    lines.push(`${whitespace}['${configName}']: {`);
+    whitespace += '  ';
+    Object.entries(configValueSerialized).forEach(([key, val]) => {
+        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
+        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
+    });
+    whitespace = whitespace.slice(2);
+    lines.push(`${whitespace}},`);
+}
+exports.serializeConfigValue = serializeConfigValue;
+function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
+    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
+    (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
+    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    (0, utils_js_1.assert)(valueIsImportedAtRuntime);
+    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
+    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
+    (0, utils_js_1.assertPosixPath)(importPath);
+    const fileName = path_1.default.posix.basename(importPath);
+    const isValueFile = fileName.startsWith('+');
+    if (isValueFile)
+        (0, utils_js_1.assert)(exportName === undefined);
+    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importPath, varCounterContainer.varCounter++, exportName);
+    importStatements.push(importStatement);
+    const lines = [];
+    lines.push(`  {`);
+    lines.push(`    configName: '${configName}',`);
+    lines.push(`    importPath: '${importPath}',`);
+    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
+    if (isValueFile) {
+        lines.push(`    exportValues: ${importName},`);
+    }
+    else {
+        lines.push(`    exportValue: ${importName},`);
+        (0, utils_js_1.assert)(exportName);
+        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
+    }
+    lines.push(`  },`);
+    return lines;
+}
+exports.serializeConfigValueImported = serializeConfigValueImported;

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

@@ -45,27 +45,27 @@ function getPageConfig(pageId, pageConfigs) {
 }
 exports.getPageConfig = getPageConfig;
 function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
-    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)} defined ${getSourceString(definedAt)}`;
+    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)} defined ${getSourceString(definedAt, configName)}`;
     return configDefinedAt;
 }
 exports.getConfigDefinedAtString = getConfigDefinedAtString;
-function getSourceString(definedAt) {
+function getSourceString(definedAt, configName) {
     if (definedAt.isComputed) {
         return 'internally';
     }
-    let sources;
+    let files;
     if (definedAt.isCumulative) {
-        sources = definedAt.sources;
+        files = definedAt.files;
     }
     else {
-        sources = [definedAt.source];
+        files = [definedAt.file];
     }
-    (0, utils_js_1.assert)(sources.length >= 1);
-    const sourceString = sources
+    (0, utils_js_1.assert)(files.length >= 1);
+    const sourceString = files
         .map((source) => {
         const { filePathToShowToUser, fileExportPath } = source;
         let s = filePathToShowToUser;
-        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
+        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath, configName);
         if (exportPath) {
             s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
         }
@@ -77,8 +77,8 @@ function getSourceString(definedAt) {
         .join(' / ');
     return `at ${sourceString}`;
 }
-function getDefinedAtString(configValue) {
-    let sourceString = getSourceString(configValue.definedAt);
+function getDefinedAtString(configValue, configName) {
+    let sourceString = getSourceString(configValue.definedAt, configName);
     if (sourceString.startsWith('at '))
         sourceString = sourceString.slice('at '.length);
     return sourceString;
@@ -90,8 +90,7 @@ function getConfigValueFilePathToShowToUser({ definedAt }) {
     //  - computed values don't have any file path
     if (definedAt.isComputed || definedAt.isCumulative)
         return null;
-    const { source } = definedAt;
-    const { filePathToShowToUser } = source;
+    const { filePathToShowToUser } = definedAt.file;
     (0, utils_js_1.assert)(filePathToShowToUser);
     return filePathToShowToUser;
 }

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

@@ -34,7 +34,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue);
+                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,

package/dist/cjs/utils/getOutDirs.js

@@ -3,30 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveOutDir = exports.getOutDirs_prerender = exports.getOutDirs = void 0;
+exports.resolveOutDir = exports.getOutDirs = void 0;
 const viteIsSSR_js_1 = require("./viteIsSSR.js");
 const assert_js_1 = require("./assert.js");
 const path_shim_js_1 = require("./path-shim.js");
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function getOutDirs(config) {
-    const outDir = getOutDirFromResolvedConfig(config);
-    assertOutDirResolved(outDir, config);
-    (0, assert_js_1.assert)(outDir.endsWith('/server') || outDir.endsWith('/client'));
-    (0, assert_js_1.assert)('/client'.length === '/server'.length);
-    const outDirRoot = outDir.slice(0, -1 * '/client'.length);
+    let outDirRoot;
+    {
+        const outDir = getOutDirFromViteResolvedConfig(config);
+        if (isOutDirRoot(outDir)) {
+            outDirRoot = outDir;
+        }
+        else {
+            assertOutDirResolved(outDir, config);
+            (0, assert_js_1.assert)(outDir.endsWith('/server') || outDir.endsWith('/client'));
+            (0, assert_js_1.assert)('/client'.length === '/server'.length);
+            outDirRoot = outDir.slice(0, -1 * '/client'.length);
+        }
+    }
     return getOutDirsAll(outDirRoot, config.root);
 }
 exports.getOutDirs = getOutDirs;
-function getOutDirs_prerender(config) {
-    const outDirRoot = getOutDirFromResolvedConfig(config);
-    (0, assert_js_1.assert)(isOutDirRoot(outDirRoot));
-    return getOutDirsAll(outDirRoot, config.root);
-}
-exports.getOutDirs_prerender = getOutDirs_prerender;
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config) {
-    const outDir = getOutDirFromUserConfig(config) || 'dist';
+    const outDir = getOutDirFromViteUserConfig(config) || 'dist';
     // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
     if (!isOutDirRoot(outDir)) {
         assertOutDirResolved(outDir, config);
@@ -45,6 +47,7 @@ function resolveOutDir(config) {
 exports.resolveOutDir = resolveOutDir;
 function determineOutDirs(outDirRoot) {
     (0, filesystemPathHandling_js_1.assertPosixPath)(outDirRoot);
+    (0, assert_js_1.assert)(!outDirRoot.endsWith('/'));
     (0, assert_js_1.assert)(isOutDirRoot(outDirRoot));
     const outDirClient = (0, path_shim_js_1.pathJoin)(outDirRoot, 'client');
     const outDirServer = (0, path_shim_js_1.pathJoin)(outDirRoot, 'server');
@@ -95,18 +98,22 @@ function assertOutDirResolved(outDir, config) {
         (0, assert_js_1.assertUsage)(outDir.endsWith('/client'), wrongUsage);
     }
 }
-function getOutDirFromUserConfig(config) {
+function getOutDirFromViteUserConfig(config) {
     let outDir = config.build?.outDir;
     if (outDir === undefined)
         return undefined;
-    // I believe Vite normalizes config.build.outDir only if config is ResolvedConfig
-    outDir = (0, filesystemPathHandling_js_1.toPosixPath)(outDir);
+    outDir = normalize(outDir);
     return outDir;
 }
-function getOutDirFromResolvedConfig(config) {
+function getOutDirFromViteResolvedConfig(config) {
     let outDir = config.build.outDir;
-    // Vite seems to be buggy and doesn't always normalize config.build.outDir
+    (0, assert_js_1.assert)(outDir);
+    outDir = normalize(outDir);
+    return outDir;
+}
+function normalize(outDir) {
     outDir = (0, filesystemPathHandling_js_1.toPosixPath)(outDir);
+    outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
     return outDir;
 }
 function outDirIsAbsolutePath(outDir) {

package/dist/cjs/utils/getValuePrintable.js

@@ -4,7 +4,7 @@ exports.getValuePrintable = void 0;
 function getValuePrintable(value) {
     if ([null, undefined].includes(value))
         return String(value);
-    if (['undefined', 'boolean', 'number', 'string'].includes(typeof value))
+    if (['boolean', 'number', 'string'].includes(typeof value))
         return JSON.stringify(value);
     return null;
 }