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

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.d.ts

@@ -1,8 +1,3 @@
 export { getVirtualFilePageConfigValuesAll };
-export { serializeConfigValueImported };
-import type { ConfigValueSource } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
-declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;
-declare function serializeConfigValueImported(configValueSource: ConfigValueSource, configName: string, whitespace: string, varCounterContainer: {
-    varCounter: number;
-}, importStatements: string[]): string[];
+declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, outDirRoot: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -1,16 +1,14 @@
 export { getVirtualFilePageConfigValuesAll };
-export { serializeConfigValueImported };
-import { assert, assertPosixPath } from '../../../utils.js';
-import { generateEagerImport } from '../generateEagerImport.js';
+import { assert } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import path from 'path';
 import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
 import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
-import { isConfigEnvMatch } from './isConfigEnvMatch.js';
-async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
+import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, isDev, configVike) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
     /* This assertion fails when using includeAssetsImportedByServer
@@ -20,7 +18,7 @@ async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configV
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
+    const { pageConfigs } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
@@ -40,7 +38,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
             return;
         if (configValueSource.valueIsFilePath)
             return;
-        if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+        if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false }))
             return;
         const whitespace = '  ';
         lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
@@ -52,33 +50,3 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
-function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
-    assert(!configValueSource.valueIsFilePath);
-    assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
-    assert(valueIsImportedAtRuntime);
-    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
-    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
-    assertPosixPath(importPath);
-    const fileName = path.posix.basename(importPath);
-    const isValueFile = fileName.startsWith('+');
-    if (isValueFile)
-        assert(exportName === undefined);
-    const { importName, importStatement } = 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(`    importFileExports: ${importName},`);
-    }
-    else {
-        lines.push(`    importFileExportValue: ${importName},`);
-        assert(exportName);
-        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
-    }
-    lines.push(`  },`);
-    return lines;
-}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.d.ts

@@ -2,5 +2,5 @@ export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
 import type { DefinedAt } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
-declare function getVirtualFilePageConfigs(userRootDir: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
+declare function getVirtualFilePageConfigs(userRootDir: string, outDirRoot: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
 declare function getConfigValueSerialized(value: unknown, configName: string, definedAt: DefinedAt): string;

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

@@ -7,11 +7,11 @@ import { stringify } from '@brillout/json-serializer/stringify';
 import { getConfigEnv } from './helpers.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
-import { isConfigEnvMatch } from './isConfigEnvMatch.js';
-import { serializeConfigValueImported } from './getVirtualFilePageConfigValuesAll.js';
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/utils.js';
-async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
+import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
@@ -28,12 +28,25 @@ 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 (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
+            if (pageConfig.configValueSources[configName])
+                return;
+            const configValue = pageConfig.configValues[configName];
+            assert(configValue);
+            const { definedAt } = configValue;
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+            serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+        });
+        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
             const configValue = pageConfig.configValues[configName];
             if (configValue) {
-                const configEnv = getConfigEnv(pageConfig, configName);
+                const configEnv = getConfigEnv(pageConfig.configValueSources, configName);
                 assert(configEnv, configName);
-                if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+                const isEnvMatch = isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true });
+                if (!isEnvMatch)
                     return;
                 const { value, definedAt } = configValue;
                 const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
@@ -51,7 +64,6 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
             assert(configValueSource);
             if (configValueSource.configEnv !== '_routing-eager')
                 return;
-            assert(!configValueSource.isComputed);
             lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);
@@ -89,29 +101,15 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
     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${getPropAccessNotation(configName)}`;
+    let configValueSerialized;
     try {
         configValueSerialized = stringify(value, { valueName });
     }
     catch (err) {
         assert(hasProp(err, 'messageCore', 'string'));
         const configValueFilePathToShowToUser = 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
         assert(configValueFilePathToShowToUser);
         assertUsage(false, [
             `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/helpers.d.ts

@@ -1,5 +1,5 @@
 export { getConfigEnv };
 export { isConfigSet };
-import type { ConfigEnvInternal, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
-declare function getConfigEnv(pageConfig: PageConfigBuildTime, configName: string): null | ConfigEnvInternal;
-declare function isConfigSet(pageConfig: PageConfigBuildTime, configName: string): boolean;
+import type { ConfigEnvInternal, ConfigValueSources } from '../../../../../shared/page-configs/PageConfig.js';
+declare function getConfigEnv(configValueSources: ConfigValueSources, configName: string): null | ConfigEnvInternal;
+declare function isConfigSet(configValueSources: ConfigValueSources, configName: string): boolean;

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

@@ -2,8 +2,8 @@ export { getConfigEnv };
 export { isConfigSet };
 import { assert, assertIsNotProductionRuntime } from '../../../utils.js';
 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) {
@@ -21,17 +21,15 @@ function getConfigEnv(pageConfig, configName) {
         */
     }
 }
-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;
 }
-function getConfigValueSource(pageConfig, configName) {
-    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
-    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/esm/node/plugin/plugins/importUserCode/v1-design/isRuntimeEnvMatch.d.ts

@@ -0,0 +1,7 @@
+export { isRuntimeEnvMatch };
+import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageConfig.js';
+declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+    isEager: boolean;
+}): boolean;

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

@@ -0,0 +1,15 @@
+export { isRuntimeEnvMatch };
+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;
+}

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

@@ -1,11 +1,12 @@
 export { findPageFiles };
 import glob from 'fast-glob';
-import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
+import { assertWarning, toPosixPath, scriptFileExtensions, getOutDirs } from '../utils.js';
 import pc from '@brillout/picocolors';
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
+    const { outDirRoot } = getOutDirs(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**'], cwd, dot: false });
+    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {

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

@@ -1,4 +1,4 @@
-// Utils needed by vike's Vite plugin.
+// Utils needed by Vike's Vite plugin.
 // We assume all runtime entries will load this utils.ts file
 import { onLoad } from './onLoad.js';
 onLoad();

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

@@ -5,7 +5,7 @@ export { prerenderForceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs_prerender, hasPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, hasPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -44,7 +44,7 @@ async function runPrerender(options, manuallyTriggered) {
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);
     const configVike = await getConfigVike(viteConfig);
-    const { outDirClient, outDirRoot } = getOutDirs_prerender(viteConfig);
+    const { outDirClient, outDirRoot } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = configVike.prerender;
     if (!prerenderConfig) {
@@ -87,13 +87,13 @@ async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concu
         const configName = 'prerender';
         const configValue = getConfigValue(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
-            const filePath = getConfigValueFilePathToShowToUser(configValue);
-            assert(filePath);
+            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue);
+            assert(configValueFilePathToShowToUser);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
                 setByConfigValue: false,
-                setByConfigFile: filePath
+                setByConfigFile: configValueFilePathToShowToUser
             });
         }
     });

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

@@ -305,7 +305,7 @@ function getRequestId() {
 }
 function skipRequest(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    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 });
+    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') ||
         !isParsable(urlOriginal) ||

package/dist/esm/shared/assertPageContextProvidedByUser.js

@@ -10,6 +10,6 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     assertUsage(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.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?
-    assertWarning(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.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 });
+    assertWarning(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.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 });
     assertUsage(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.is404')} which is forbidden, use ${pc.cyan('throw render()')} instead, see https://vike.dev/render`);
 }

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

@@ -30,7 +30,7 @@ function getExports(pageFiles, pageConfig) {
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
-            const filePath = getConfigValueFilePathToShowToUser(configValue);
+            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue);
             const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];
@@ -39,7 +39,7 @@ function getExports(pageFiles, pageConfig) {
             configEntries[configName].push({
                 configValue: value,
                 configDefinedAt,
-                configDefinedByFile: filePath
+                configDefinedByFile: configValueFilePathToShowToUser
             });
             // TODO/v1-release: remove
             const exportName = configName;
@@ -47,8 +47,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/esm/shared/getPageFiles/parseGlobResults.js

@@ -3,8 +3,8 @@ import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../uti
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from './assertPageConfigs.js';
-import { parsePageConfigsSerialized } from './parsePageConfigsSerialized.js';
+import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigs.js';
+import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'isGeneratedFile'));
     assert(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -21,7 +21,7 @@ function parseGlobResults(pageFilesExports) {
     const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
     assertPageConfigsSerialized(pageConfigsSerialized);
     assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
-    const { pageConfigs, pageConfigGlobal } = parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;

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

@@ -1,23 +1,20 @@
 export type { PageConfigRuntime };
 export type { PageConfigRuntimeLoaded };
-export type { PageConfigRuntimeSerialized };
 export type { PageConfigBuildTime };
-export type { ConfigEnvInternal };
 export type { ConfigEnv };
+export type { ConfigEnvInternal };
 export type { PageConfigGlobalRuntime };
-export type { PageConfigGlobalRuntimeSerialized };
 export type { PageConfigGlobalBuildTime };
-export type { ConfigSource };
 export type { ConfigValue };
-export type { ConfigValueSerialized };
-export type { ConfigValueImported };
 export type { ConfigValues };
 export type { ConfigValueSource };
 export type { ConfigValueSources };
+export type { ConfigValueComputed };
+export type { ConfigValuesComputed };
 export type { DefinedAt };
-export type { DefinedAtInfoNew };
-export type { DefinedAtInfoFull };
-export type { DefinedAtInfoFull as DefinedAtInfo };
+export type { DefinedAtFile };
+export type { DefinedAtFileInfo };
+import type { ConfigValueImported } from './serialize/PageConfigSerialized.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -31,34 +28,23 @@ type PageConfigRuntime = PageConfigBase & {
     /** Loaded config values */
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: LoadConfigValuesAll;
+    loadConfigValuesAll: () => Promise<ConfigValueImported[]>;
 };
 /** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
 type PageConfigRuntimeLoaded = PageConfigRuntime & {
     /** Whether loadConfigValuesAll() was called */
     isLoaded: true;
 };
-/** page config data structure available and used at build-time */
+/** Page config data structure available and used at build-time */
 type PageConfigBuildTime = PageConfigBase & {
     configValues: ConfigValues;
     configValueSources: ConfigValueSources;
+    configValuesComputed: ConfigValuesComputed;
 };
-/** page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
-type PageConfigRuntimeSerialized = PageConfigBase & {
-    /** Config values that are loaded eagerly and serializable such as config.passToClient */
-    configValuesSerialized: Record<string, ConfigValueSerialized>;
-    /** Config values imported eagerly such as config.route */
-    configValuesImported: ConfigValueImported[];
-    /** Config values imported lazily such as config.page */
-    loadConfigValuesAll: LoadConfigValuesAll;
-};
-/** page config that applies to all pages */
+/** Page config that applies to all pages */
 type PageConfigGlobalRuntime = {
     configValues: ConfigValues;
 };
-type PageConfigGlobalRuntimeSerialized = {
-    configValuesImported: ConfigValueImported[];
-};
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
 };
@@ -66,36 +52,33 @@ type ConfigEnv = 'client-only' | 'server-only' | 'server-and-client' | 'config-o
 /** For Vike internal use */
 type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
 type ConfigValueSource = {
-    configEnv: ConfigEnvInternal;
     value?: unknown;
+    configEnv: ConfigEnvInternal;
+    definedAtInfo: DefinedAtFileInfo;
+    /** Wether the config value is loaded at run-time, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
+    /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
-} & ({
-    isComputed: false;
-    definedAtInfo: DefinedAtInfoFull;
-} | {
-    isComputed: true;
-    definedAtInfo: null;
-    valueIsImportedAtRuntime: false;
-});
+};
+type ConfigValueComputed = {
+    configEnv: ConfigEnvInternal;
+    value: unknown;
+};
+type ConfigValuesComputed = Record<string, ConfigValueComputed>;
 type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValue = {
     value: unknown;
     definedAt: DefinedAt;
 };
-type ConfigValueSerialized = {
-    valueSerialized: string;
-    definedAt: DefinedAt;
-};
 type ConfigValues = Record<string, ConfigValue>;
 type DefinedAt = {
-    source: DefinedAtInfoNew;
+    file: DefinedAtFile;
     isEffect?: true;
     isComputed?: undefined;
     isCumulative?: undefined;
 } | {
     isCumulative: true;
-    sources: DefinedAtInfoNew[];
+    files: DefinedAtFile[];
     isEffect?: undefined;
     isComputed?: undefined;
 } | {
@@ -103,11 +86,12 @@ type DefinedAt = {
     isEffect?: undefined;
     isCumulative?: undefined;
 };
-type DefinedAtInfoNew = {
+type DefinedAtFile = {
     filePathToShowToUser: string;
     fileExportPath: null | string[];
 };
-type DefinedAtInfoFull = ({
+type DefinedAtFileInfo = // TODO: replace filePathRelativeToUserRootDir and importPathAbsolute with following?
+({
     filePathRelativeToUserRootDir: string;
     filePathAbsolute: string;
     importPathAbsolute: null;
@@ -119,24 +103,3 @@ type DefinedAtInfoFull = ({
     exportName?: string;
     fileExportPath: null | string[];
 };
-type ConfigSource = {
-    configSourceFile: string;
-} & ({
-    configSourceFileExportName: string;
-    configSourceFileDefaultExportKey?: undefined;
-} | {
-    configSourceFileDefaultExportKey: string;
-    configSourceFileExportName?: undefined;
-});
-type LoadConfigValuesAll = () => Promise<ConfigValueImported[]>;
-type ConfigValueImported = {
-    configName: string;
-    importPath: string;
-} & ({
-    isValueFile: true;
-    importFileExports: Record<string, unknown>;
-} | {
-    isValueFile: false;
-    exportName: string;
-    importFileExportValue: unknown;
-});

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

@@ -1,2 +1,2 @@
 export { getExportPath };
-declare function getExportPath(fileExportPath: null | string[]): null | string;
+declare function getExportPath(fileExportPath: null | string[], configName: string): null | string;

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

@@ -1,18 +1,17 @@
 export { getExportPath };
 import { assert } from '../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 === '*') {
-        assert(exportObjectPath.length === 0);
-        return 'export *';
-    }
-    else if (exportName === 'default') {
+    if (exportObjectPath.length === 0 && ['*', 'default', configName].includes(exportName))
+        return null;
+    assert(exportName !== '*');
+    let prefix = '';
+    let suffix = '';
+    if (exportName === 'default') {
         prefix = 'export default';
     }
     else {

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

@@ -1,6 +1,6 @@
 export { loadConfigValues };
 import { objectAssign } from '../utils.js';
-import { parseConfigValuesImported } from './parseConfigValuesImported.js';
+import { parseConfigValuesImported } from './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/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -0,0 +1,32 @@
+export type { PageConfigRuntimeSerialized };
+export type { PageConfigGlobalRuntimeSerialized };
+export type { ConfigValueSerialized };
+export type { ConfigValueImported };
+import type { DefinedAt, PageConfigRuntime } from '../PageConfig.js';
+/** page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
+type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
+    /** Config values that are loaded eagerly and serializable such as config.passToClient */
+    configValuesSerialized: Record<string, ConfigValueSerialized>;
+    /** Config values imported eagerly such as config.route */
+    configValuesImported: ConfigValueImported[];
+};
+type PageConfigGlobalRuntimeSerialized = {
+    configValuesImported: ConfigValueImported[];
+};
+/** Value is serialized. */
+type ConfigValueSerialized = {
+    valueSerialized: string;
+    definedAt: DefinedAt;
+};
+/** Value is imported. */
+type ConfigValueImported = {
+    configName: string;
+    importPath: string;
+} & ({
+    isValueFile: true;
+    exportValues: Record<string, unknown>;
+} | {
+    isValueFile: false;
+    exportName: string;
+    exportValue: unknown;
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/{getPageFiles → page-configs/serialize}/assertPageConfigs.d.ts

@@ -1,5 +1,5 @@
 export { assertPageConfigsSerialized };
 export { assertPageConfigGlobalSerialized };
-import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from '../page-configs/PageConfig.js';
+import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
 declare function assertPageConfigsSerialized(pageConfigsSerialized: unknown): asserts pageConfigsSerialized is PageConfigRuntimeSerialized[];
 declare function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized: unknown): asserts pageConfigGlobalSerialized is PageConfigGlobalRuntimeSerialized;

package/dist/esm/shared/{getPageFiles → page-configs/serialize}/assertPageConfigs.js

@@ -1,6 +1,6 @@
 export { assertPageConfigsSerialized };
 export { assertPageConfigGlobalSerialized };
-import { assert, isObject, hasProp } from '../utils.js';
+import { assert, isObject, hasProp } from '../../utils.js';
 function assertPageConfigsSerialized(pageConfigsSerialized) {
     assert(Array.isArray(pageConfigsSerialized));
     pageConfigsSerialized.forEach((pageConfigSerialized) => {

package/dist/esm/shared/page-configs/{parseConfigValuesImported.d.ts → serialize/parseConfigValuesImported.d.ts}

@@ -1,3 +1,4 @@
 export { parseConfigValuesImported };
-import type { ConfigValueImported, ConfigValues } from './PageConfig.js';
+import type { ConfigValues } from '../PageConfig.js';
+import type { ConfigValueImported } from './PageConfigSerialized.js';
 declare function parseConfigValuesImported(configValuesImported: ConfigValueImported[]): ConfigValues;