vike 0.4.171-commit-f9548df → 0.4.171-commit-6e37128

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

@@ -4,12 +4,16 @@ import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageC
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getGlobalContext } from '../globalContext.js';
-import { getClientEntry } from '../../shared/getClientEntry.js';
+import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValue.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
         const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
-        const clientFilePath = getClientEntry(pageConfig);
-        const clientEntry = !isClientSideRenderable ? clientFilePath : getVikeClientEntry(isClientRouting);
+        const clientEntries = [];
+        const clientFilePath = getConfigValueRuntime(pageConfig, 'client', 'string')?.value ?? null;
+        if (clientFilePath)
+            clientEntries.push(clientFilePath);
+        if (isClientSideRenderable)
+            clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
@@ -41,15 +45,13 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           }
         })
         */
-        const clientEntries = [];
-        if (clientEntry) {
+        clientEntries.forEach((clientEntry) => {
             clientDependencies.push({
                 id: clientEntry,
                 onlyAssets: false,
                 eagerlyImported: false
             });
-            clientEntries.push(clientEntry);
-        }
+        });
         return {
             isHtmlOnly: !isClientSideRenderable,
             isClientRouting,

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

@@ -1,13 +1,13 @@
 export { getCacheControl };
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValue.js';
 const defaultValue = 'no-store, max-age=0';
 function getCacheControl(pageId, pageConfigs) {
     // TODO/v1-release: remove
     if (pageConfigs.length === 0)
         return defaultValue;
     const pageConfig = getPageConfig(pageId, pageConfigs);
-    const configValue = getConfigValue(pageConfig, 'cacheControl', 'string');
+    const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
     const value = configValue?.value;
     if (value)
         return value;

package/dist/esm/node/runtime/renderPage/loadUserFilesServerSide.d.ts

@@ -14,7 +14,7 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
     _pageId: string;
-} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageContextExports & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.d.ts

@@ -65,7 +65,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -116,7 +116,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -168,7 +168,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -219,7 +219,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];

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

@@ -21,7 +21,6 @@ import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
-import { assertV1Design } from '../../shared/assertV1Design.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -171,7 +170,8 @@ async function getRenderContext() {
     const globalContext = getGlobalContext();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await getPageFilesAll(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    assertV1Design(pageFilesAll.length > 0, pageConfigs, pageFilesAll);
+    // We assume assertV1Design() was already called at build-time
+    assert(pageFilesAll.length === 0 || pageConfigs.length === 0);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,

package/dist/esm/node/shared/assertV1Design.d.ts

@@ -1,4 +1,4 @@
 export { assertV1Design };
 import { PageFile } from '../../shared/getPageFiles.js';
-import type { PageConfigBuildTime, PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-declare function assertV1Design(isOldDesign: boolean, pageConfigs: (PageConfigRuntime | PageConfigBuildTime)[], pageFilesAll?: PageFile[]): void;
+import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function assertV1Design(isOldDesign: boolean, pageConfigs: PageConfigBuildTime[], pageFilesAll?: PageFile[]): void;

package/dist/esm/node/shared/assertV1Design.js

@@ -1,5 +1,4 @@
 export { assertV1Design };
-import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { assert, assertUsage, assertWarning, isNotNullish, unique } from './utils.js';
 function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
     const isV1Design = pageConfigs.length > 0;
@@ -9,10 +8,10 @@ function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
             assert(pageFilesAll.length > 0);
             const indent = '- ';
             const filesV1 = unique(pageConfigs
-                .map((p) => Object.values(p.configValues)
-                .map((c) => getConfigValueFilePathToShowToUser(c.definedAtData))
+                .map((p) => Object.values(p.configValueSources).map((sources) => sources
+                .map((c) => c.definedAtFilePath.filePathAbsoluteUserRootDir)
                 .filter(isNotNullish)
-                .map((filePathToShowToUser) => indent + filePathToShowToUser))
+                .map((filePathToShowToUser) => indent + filePathToShowToUser)))
                 .flat(2));
             const filesOld = pageFilesAll.map((p) => indent + p.filePath);
             lines.push(...['V1 design files:', ...filesV1, 'Old design files:', ...filesOld]);

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -127,22 +127,24 @@ function assertPageContextUrlComputed(pageContext) {
     ```js
     const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
   
-    // ❌ Breaks the property getters of pageContext set by getPageContextUrlComputed() such as pageContext.urlPathname
+    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
     Object.assign(pageContext, pageContextUrlComputed)
   
-    // ❌ Also breaks property getters
+    // ❌ Also breaks property descriptors/getters
     const pageContext = { ...pageContextUrlComputed }
   
-    // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
+    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
     objectAssign(pageContext, pageContextUrlComputed)
     ```
     */
     if ('urlPathname' in pageContext) {
         assert(typeof pageContext.urlPathname === 'string');
         assert(isPropertyGetter(pageContext, 'urlPathname'));
-    }
-    if ('urlParsed' in pageContext)
         assert(isPropertyGetter(pageContext, 'urlParsed'));
-    if ('url' in pageContext)
         assert(isPropertyGetter(pageContext, 'url'));
+    }
+    else {
+        assert(!('urlParsed' in pageContext));
+        assert(!('url' in pageContext));
+    }
 }

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

@@ -1,11 +1,11 @@
 export { analyzeClientSide };
-import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { analyzePageClientSide } from './analyzePageClientSide.js';
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
     if (pageConfig) {
-        const isClientRouting = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-        const isClientSideRenderable = getConfigValue(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
+        const isClientRouting = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        const isClientSideRenderable = getConfigValueRuntime(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
         return { isClientSideRenderable, isClientRouting };
     }
     else {

package/dist/esm/shared/hooks/getHook.d.ts

@@ -11,7 +11,7 @@ export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
 import type { PageContextExports } from '../getPageFiles.js';
 import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
-import type { PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
     hookFn: HookFn;
     hookTimeout: HookTimeout;
@@ -27,7 +27,7 @@ type HookTimeout = {
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
 declare function getHook(pageContext: PageContextExports, hookName: HookName): null | Hook;
-declare function getHookFromPageConfig(pageConfig: PageConfigRuntime | PageConfigBuildTime, hookName: HookNamePage): null | Hook;
+declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
 declare function assertHook<TPageContext extends PageContextExports, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;

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

@@ -8,7 +8,7 @@ export { setIsPrerenderering };
 export { getHookTimeoutDefault };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
-import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('getHook.ts', {
@@ -32,8 +32,8 @@ function getHook(pageContext, hookName) {
     return { hookFn, hookName, hookFilePath, hookTimeout };
 }
 function getHookFromPageConfig(pageConfig, hookName) {
-    const configValue = getConfigValue(pageConfig, hookName);
-    const hooksTimeout = getConfigValue(pageConfig, 'hooksTimeout')?.value;
+    const configValue = getConfigValueRuntime(pageConfig, hookName);
+    const hooksTimeout = getConfigValueRuntime(pageConfig, 'hooksTimeout')?.value;
     if (!configValue)
         return null;
     const hookFn = configValue.value;

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

@@ -16,9 +16,10 @@ export type { ConfigValuesComputed };
 export type { DefinedAtData };
 export type { DefinedAtFile };
 export type { DefinedAtFilePath };
-import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
+import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
+import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -26,13 +27,12 @@ type PageConfigBase = {
         routeString: string;
         definedBy: string;
     };
-    configValues: ConfigValues;
 };
 /** Page config data structure available at runtime */
 type PageConfigRuntime = PageConfigBase & {
+    configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
     loadConfigValuesAll: () => Promise<{
-        configValuesImported: ConfigValueImported[];
         configValuesSerialized: Record<string, ConfigValueSerialized>;
     }>;
 };
@@ -43,6 +43,7 @@ type PageConfigRuntimeLoaded = PageConfigRuntime & {
 };
 /** Page config data structure available at build-time */
 type PageConfigBuildTime = PageConfigBase & {
+    configDefinitions: ConfigDefinitions;
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
 };
@@ -52,6 +53,7 @@ type PageConfigGlobalRuntime = {
 };
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
+    configDefinitions: ConfigDefinitions;
 };
 /** In what environment(s) the config value is loaded.
  *
@@ -65,18 +67,22 @@ type ConfigEnv = {
 /** For Vike internal use */
 type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
     client?: boolean | 'if-client-routing';
+    /** Always load value, not matter what page is loaded. */
     eager?: boolean;
+    /** Load value only in production or only in development. */
+    production?: boolean;
 };
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAtFilePath: DefinedAtFilePath;
     locationId: LocationId;
+    isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
-    valueIsDefinedByValueFile: boolean;
+    valueIsDefinedByPlusFile: boolean;
 };
 type DefinedAtFilePath = DefinedAtFile & FilePath & {
     fileExportName?: string;

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

@@ -1,14 +1,14 @@
-export { getConfigValue };
-import type { PageConfigRuntime, PageConfigBuildTime, ConfigValue } from './PageConfig.js';
+export { getConfigValueRuntime };
+export { getConfigValueTyped };
+export type { TypeAsString };
+import { type ResolveTypeAsString } from '../utils.js';
+import type { PageConfigRuntime, ConfigValue } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
-type PageConfigCommon = PageConfigRuntime | PageConfigBuildTime;
 type ConfigName = ConfigNameBuiltIn;
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | ConfigValue & {
-    value: string;
-};
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | ConfigValue & {
-    value: boolean;
-};
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | ConfigValue & {
-    value: unknown;
-};
+type TypeAsString = 'string' | 'boolean' | undefined;
+declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigName, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});
+declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});

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

@@ -1,18 +1,24 @@
-export { getConfigValue };
+export { getConfigValueRuntime };
+export { getConfigValueTyped };
 import { assert, assertUsage, getValuePrintable } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtOptional } from './getConfigDefinedAt.js';
-// prettier-ignore
-// biome-ignore format:
-function getConfigValue(pageConfig, configName, type) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    if (configValue === null)
-        return null;
+function getConfigValueTyped(configValue, configName, type) {
+    /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null) return null
+    */
     const { value, definedAtData } = configValue;
     if (type)
         assertConfigValueType(value, type, configName, definedAtData);
     return configValue;
 }
+function getConfigValueRuntime(pageConfig, configName, type) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    return getConfigValueTyped(configValue, configName, type);
+}
 function assertConfigValueType(value, type, configName, definedAtData) {
     assert(value !== null);
     const typeActual = typeof value;
@@ -26,12 +32,3 @@ function assertConfigValueType(value, type, configName, definedAtData) {
     const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
     assertUsage(false, errMsg);
 }
-function getConfigValueEntry(pageConfig, configName) {
-    const configValue = pageConfig.configValues[configName];
-    if (!configValue)
-        return null;
-    // Enable users to suppress global config values by setting the local config value to null
-    if (configValue.value === null)
-        return null;
-    return configValue;
-}

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

@@ -0,0 +1,9 @@
+export { getConfigValueBuildTime };
+import { type ResolveTypeAsString } from '../utils.js';
+import type { PageConfigBuildTime, ConfigValue } from './PageConfig.js';
+import type { ConfigNameBuiltIn } from './Config.js';
+import { type TypeAsString } from './getConfigValue.js';
+type ConfigName = ConfigNameBuiltIn;
+declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});

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

@@ -0,0 +1,67 @@
+export { getConfigValueBuildTime };
+import { assert } from '../utils.js';
+import { getConfigValueTyped } from './getConfigValue.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+assertIsNotProductionRuntime();
+function getConfigValueBuildTime(pageConfig, configName, type) {
+    const configValue = getConfigValue(pageConfig, configName);
+    if (!configValue)
+        return null;
+    return getConfigValueTyped(configValue, configName, type);
+}
+function getConfigValue(pageConfig, configName) {
+    const { configValueSources, configValuesComputed, configDefinitions } = pageConfig;
+    const configValueComputed = configValuesComputed[configName];
+    if (configValueComputed) {
+        return {
+            type: 'computed',
+            value: configValueComputed.value,
+            definedAtData: null
+        };
+    }
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    assert(sources.every((s) => s.configEnv.config === true));
+    const configDef = configDefinitions[configName];
+    assert(configDef);
+    if (!configDef.cumulative) {
+        const configValueSource = sources[0];
+        assert(configValueSource);
+        assert(configValueSource.isOverriden === false);
+        assert(sources.slice(1).every((s) => s.isOverriden === true));
+        assert('value' in configValueSource);
+        return {
+            type: 'standard',
+            value: configValueSource.value,
+            definedAtData: getDefinedAtFile(configValueSource)
+        };
+    }
+    else {
+        const { value, definedAtData } = mergeCumulative(sources);
+        assert(value.length === definedAtData.length);
+        return {
+            type: 'cumulative',
+            value,
+            definedAtData
+        };
+    }
+}
+function mergeCumulative(configValueSources) {
+    const value = [];
+    const definedAtData = [];
+    configValueSources.forEach((configValueSource) => {
+        assert(configValueSource.isOverriden === false);
+        assert(configValueSource.configEnv.config === true);
+        assert('value' in configValueSource);
+        value.push(configValueSource.value);
+        definedAtData.push(getDefinedAtFile(configValueSource));
+    });
+    return { value, definedAtData };
+}
+function getDefinedAtFile(configValueSource) {
+    return {
+        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+    };
+}

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

@@ -1,7 +1,6 @@
 export { loadConfigValues };
 import { objectAssign } from '../utils.js';
-import { parseConfigValuesImported } from './serialize/parseConfigValuesImported.js';
-import { parseConfigValuesSerialized } from './serialize/parseConfigValuesSerialized.js';
+import { parseConfigValuesSerialized } from './serialize/parsePageConfigs.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
@@ -9,16 +8,8 @@ async function loadConfigValues(pageConfig, isDev) {
         return pageConfig;
     }
     const configValuesLoaded = await pageConfig.loadConfigValuesAll();
-    {
-        const { configValuesImported } = configValuesLoaded;
-        const configValuesAddendum = parseConfigValuesImported(configValuesImported);
-        Object.assign(pageConfig.configValues, configValuesAddendum);
-    }
-    {
-        const { configValuesSerialized } = configValuesLoaded;
-        const configValuesAddendum = parseConfigValuesSerialized(configValuesSerialized);
-        Object.assign(pageConfig.configValues, configValuesAddendum);
-    }
+    const configValues = parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);
+    Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isAllLoaded: true });
     return pageConfig;
 }

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

@@ -1,35 +1,31 @@
 export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
-export type { ConfigValueImported };
+export type { ValueSerialized };
 import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, 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 serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
-    /** Config values imported eagerly such as config.route */
-    configValuesImported: ConfigValueImported[];
 };
 type PageConfigGlobalRuntimeSerialized = {
-    configValuesImported: ConfigValueImported[];
+    configValuesSerialized: Record<string, ConfigValueSerialized>;
+};
+type ValueSerialized = {
+    type: 'js-serialized';
+    value: unknown;
+} | {
+    type: 'plus-file';
+    exportValues: Record<string, unknown>;
+} | {
+    type: 'pointer-import';
+    value: unknown;
 };
 /** Value is serialized */
 type ConfigValueSerialized = (Omit<ConfigValueStandard, 'value'> & {
-    valueSerialized: string;
+    valueSerialized: ValueSerialized;
 }) | (Omit<ConfigValueCumulative, 'value'> & {
-    valueSerialized: string;
+    valueSerialized: ValueSerialized[];
 }) | (Omit<ConfigValueComputed, 'value'> & {
-    valueSerialized: string;
-});
-/** Value is imported */
-type ConfigValueImported = {
-    configName: string;
-    importPath: string;
-} & ({
-    isValueFile: true;
-    exportValues: Record<string, unknown>;
-} | {
-    isValueFile: false;
-    exportName: string;
-    exportValue: unknown;
+    valueSerialized: ValueSerialized;
 });

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

@@ -8,9 +8,8 @@ function assertPageConfigsSerialized(pageConfigsSerialized) {
         assert(hasProp(pageConfigSerialized, 'pageId', 'string'));
         assert(hasProp(pageConfigSerialized, 'routeFilesystem'));
         assert(hasProp(pageConfigSerialized, 'configValuesSerialized'));
-        assert(hasProp(pageConfigSerialized, 'configValuesImported'));
     });
 }
 function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
-    assert(hasProp(pageConfigGlobalSerialized, 'configValuesImported'));
+    assert(hasProp(pageConfigGlobalSerialized, 'configValuesSerialized'));
 }

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

@@ -1,6 +1,9 @@
 export { parsePageConfigs };
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
+export { parseConfigValuesSerialized };
+import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
+import type { ConfigValueSerialized } from './PageConfigSerialized.js';
+declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;
 declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;