vike 0.4.218 → 0.4.220

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

@@ -1,5 +1,5 @@
 export { assertRuntimeManifest };
-import { assert, castType, checkType, hasProp, isBaseAssets, isBaseServer, isObject } from './utils.js';
+import { assert, checkType, hasProp, isBaseAssets, isBaseServer, isObject } from './utils.js';
 function assertRuntimeManifest(obj) {
     assert(obj);
     assert(isObject(obj));
@@ -8,8 +8,6 @@ function assertRuntimeManifest(obj) {
     assert(isBaseServer(obj.baseServer));
     assert(isBaseAssets(obj.baseAssets));
     assert(hasProp(obj, 'includeAssetsImportedByServer', 'boolean'));
-    assert(hasProp(obj, 'redirects', 'object'));
-    castType(obj);
     assert(hasProp(obj, 'trailingSlash', 'boolean'));
     assert(hasProp(obj, 'disableUrlNormalization', 'boolean'));
     checkType(obj);

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

@@ -1,5 +1,5 @@
 export { analyzeClientSide };
-import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { analyzePageClientSide } from './analyzePageClientSide.js';
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design

package/dist/esm/shared/getPageFiles/{setPageFiles.d.ts → getPageFiles.d.ts}

@@ -1,8 +1,9 @@
+export { getPageFilesAll };
 export { setPageFiles };
 export { setPageFilesAsync };
-export { getPageFilesAll };
 import type { PageFile } from './getPageFileObject.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import { type ConfigUserFriendly } from '../page-configs/getPageConfigUserFriendly.js';
 declare function setPageFiles(pageFilesExports: unknown): void;
 declare function setPageFilesAsync(getPageFilesExports: () => Promise<unknown>): void;
 declare function getPageFilesAll(isClientSide: boolean, isProduction?: boolean): Promise<{
@@ -10,4 +11,5 @@ declare function getPageFilesAll(isClientSide: boolean, isProduction?: boolean):
     allPageIds: string[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
+    globalConfig: ConfigUserFriendly;
 }>;

package/dist/esm/shared/getPageFiles/{setPageFiles.js → getPageFiles.js}

@@ -1,16 +1,18 @@
+export { getPageFilesAll };
 export { setPageFiles };
 export { setPageFilesAsync };
-export { getPageFilesAll };
 import { assert, unique } from '../utils.js';
 import { parseGlobResults } from './parseGlobResults.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { getPageConfigUserFriendlyNew } from '../page-configs/getPageConfigUserFriendly.js';
 const globalObject = getGlobalObject('setPageFiles.ts', {});
-// TODO:v1-design-release: rename setPageFiles() getPageFilesAll() parseGlobResult()
 function setPageFiles(pageFilesExports) {
     const { pageFiles, pageConfigs, pageConfigGlobal } = parseGlobResults(pageFilesExports);
     globalObject.pageFilesAll = pageFiles;
     globalObject.pageConfigs = pageConfigs;
     globalObject.pageConfigGlobal = pageConfigGlobal;
+    // TODO/now: re-use this call, instead of calling it twice
+    globalObject.globalConfig = getPageConfigUserFriendlyNew(pageConfigGlobal);
 }
 function setPageFilesAsync(getPageFilesExports) {
     globalObject.pageFilesGetter = async () => {
@@ -23,18 +25,18 @@ async function getPageFilesAll(isClientSide, isProduction) {
         assert(isProduction === undefined);
     }
     else {
-        assert(globalObject.pageFilesGetter);
         assert(typeof isProduction === 'boolean');
         if (!globalObject.pageFilesAll ||
             // We reload all glob imports in dev to make auto-reload work
             !isProduction) {
+            assert(globalObject.pageFilesGetter);
             await globalObject.pageFilesGetter();
         }
     }
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = globalObject;
-    assert(pageFilesAll && pageConfigs && pageConfigGlobal);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal, globalConfig } = globalObject;
+    assert(pageFilesAll && pageConfigs && pageConfigGlobal && globalConfig);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal };
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig };
 }
 function getAllPageIds(allPageFiles, pageConfigs) {
     const fileIds = allPageFiles.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);

package/dist/esm/shared/getPageFiles.d.ts

@@ -1,8 +1,5 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, PageContextExports } from './getPageFiles/getExports.js';
-export { getPageFilesAll } from './getPageFiles/setPageFiles.js';
-export { setPageFiles } from './getPageFiles/setPageFiles.js';
-export { setPageFilesAsync } from './getPageFiles/setPageFiles.js';
+export type { ExportsAll, PageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';
-export { getPageContextExports } from './getPageFiles/getExports.js';
+export { getPageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';

package/dist/esm/shared/getPageFiles.js

@@ -1,6 +1,3 @@
-export { getPageFilesAll } from './getPageFiles/setPageFiles.js';
-export { setPageFiles } from './getPageFiles/setPageFiles.js';
-export { setPageFilesAsync } from './getPageFiles/setPageFiles.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';
-export { getPageContextExports } from './getPageFiles/getExports.js';
+export { getPageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';

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

@@ -9,7 +9,7 @@ export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
-import type { PageContextExports } from '../getPageFiles.js';
+import type { PageConfigUserFriendly } from '../getPageFiles.js';
 import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
@@ -26,10 +26,10 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHook(pageContext: PageContextExports, hookName: HookName): null | Hook;
+declare function getHook(pageContext: PageConfigUserFriendly, hookName: HookName): 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 & {
+declare function assertHook<TPageContext extends PageConfigUserFriendly, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;
 };
 declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;

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

@@ -8,7 +8,7 @@ export { getHook_setIsPrerenderering };
 export { getHookTimeoutDefault };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
-import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('getHook.ts', {});

package/dist/esm/shared/page-configs/Config/PageContextConfig.d.ts

@@ -1,11 +1,15 @@
 export type { PageContextConfig };
+export type { ConfigResolved };
 import type { VikePackages } from '../../VikeNamespace.js';
-import type { ConfigBuiltIn, ImportString } from '../Config.js';
+import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
 import type { Combine, IsNotEmpty, XOR5 } from './helpers.js';
-type WithoutImportString<T> = {
-    [K in keyof T]: Exclude<T[K], ImportString>;
-};
-type PageContextConfig = ConfigBuiltIn & Vike.ConfigResolved & WithoutImportString<Omit<Vike.Config, keyof Vike.ConfigResolved>> & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+type PageContextConfig = ConfigResolved & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
+type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
+type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
 type ConfigVikePackagesIntersection = VikePackages.ConfigVikeReact & VikePackages.ConfigVikeVue & VikePackages.ConfigVikeSolid & VikePackages.ConfigVikeSvelte & VikePackages.ConfigVikeAngular;
 type ConfigVikePackagesCombined = Combine<VikePackages.ConfigVikeReact, Combine<VikePackages.ConfigVikeVue, Combine<VikePackages.ConfigVikeSolid, Combine<VikePackages.ConfigVikeSvelte, VikePackages.ConfigVikeAngular>>>>;
 type ConfigVikePackagesNotEmptyXor = XOR5<IsNotEmpty<VikePackages.ConfigVikeReact>, IsNotEmpty<VikePackages.ConfigVikeVue>, IsNotEmpty<VikePackages.ConfigVikeSolid>, IsNotEmpty<VikePackages.ConfigVikeSvelte>, IsNotEmpty<VikePackages.ConfigVikeAngular>>;
+type WithoutImportString<T> = {
+    [K in keyof T]: Exclude<T[K], ImportString>;
+};

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

@@ -1,6 +1,8 @@
 export type { Config };
 export type { ConfigBuiltIn };
+export type { ConfigBuiltInResolved };
 export type { ConfigNameBuiltIn };
+export type { ConfigNameGlobal };
 export type { ConfigMeta };
 export type { HookName };
 export type { HookNamePage };
@@ -35,15 +37,17 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
+import type { InlineConfig } from 'vite';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
 type HookNameOldDesign = 'render' | 'prerender';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
 /** Hook for fetching data.
  *
@@ -344,6 +348,16 @@ type ConfigBuiltIn = {
      * https://vike.dev/meta
      */
     meta?: ConfigMeta | ImportString;
+    /** Vite configuration.
+     *
+     * https://vite.dev/config/
+     */
+    vite?: InlineConfig;
+    /** Permanent redirections (HTTP status code 301)
+     *
+     * https://vike.dev/redirects
+     */
+    redirects?: Record<string, string>;
     /**
      * @experimental DON'T USE: the API *will* have breaking changes upon any minor version release.
      *
@@ -390,5 +404,9 @@ type ConfigBuiltIn = {
      */
     keepScrollPosition?: KeepScrollPosition;
 };
+type ConfigBuiltInResolved = {
+    passToClient?: string[][];
+    redirects?: Record<string, string>[];
+};
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;

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

@@ -54,6 +54,7 @@ type PageConfigGlobalRuntime = {
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
     configDefinitions: ConfigDefinitions;
+    configValuesComputed?: undefined;
 };
 /** In what environment(s) the config value is loaded.
  *
@@ -70,6 +71,8 @@ type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
     /** Load value only in production, or only in development. */
     production?: boolean;
 };
+type ConfigValueSources = Record<string, // configName
+ConfigValueSource[]>;
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
@@ -85,11 +88,13 @@ type ConfigValueSource = {
 type DefinedAtFilePath = DefinedAtFile & FilePath & {
     fileExportName?: string;
 };
-type ConfigValueSources = Record<string, ConfigValueSource[]>;
-type ConfigValuesComputed = Record<string, {
+type ConfigValuesComputed = Record<string, // configName
+{
     configEnv: ConfigEnvInternal;
     value: unknown;
 }>;
+type ConfigValues = Record<string, // configName
+ConfigValue>;
 type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComputed;
 /** Defined by a unique source (thus unique file path). */
 type ConfigValueStandard = {
@@ -109,7 +114,6 @@ type ConfigValueComputed = {
     value: unknown;
     definedAtData: null;
 };
-type ConfigValues = Record<string, ConfigValue>;
 type DefinedAtData = DefinedAtFile | DefinedAtFile[] | null;
 type DefinedAtFile = {
     filePathToShowToUser: string;

package/dist/esm/shared/{getPageFiles/getExports.d.ts → page-configs/getPageConfigUserFriendly.d.ts}

@@ -1,14 +1,17 @@
-export { getPageContextExports };
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyNew };
+export type { ConfigUserFriendly };
+export type { PageConfigUserFriendly };
+export type { Source };
+export type { Sources };
+export type { From };
 export type { ExportsAll };
-export type { PageContextExports };
 export type { ConfigEntries };
-export type { From };
-export type { Sources };
-export type { Source };
-import type { FileType } from './fileTypes.js';
-import type { PageConfigRuntimeLoaded } from './../page-configs/PageConfig.js';
-import type { PageFile } from './getPageFileObject.js';
-import { type ConfigDefinedAtOptional } from '../page-configs/getConfigDefinedAt.js';
+import type { FileType } from '../getPageFiles/fileTypes.js';
+import type { PageFile } from '../getPageFiles/getPageFileObject.js';
+import type { ConfigValues, PageConfigRuntimeLoaded } from './PageConfig.js';
+import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
+import type { ConfigResolved } from './Config/PageContextConfig.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
@@ -29,11 +32,11 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type PageContextExports = {
+type PageConfigUserFriendly = {
+    config: Record<string, unknown>;
     source: Source;
     sources: Sources;
     from: From;
-    config: Record<string, unknown>;
     configEntries: ConfigEntries;
     exports: Record<string, unknown>;
     exportsAll: ExportsAll;
@@ -70,4 +73,15 @@ type SourceConfigsComputed = {
     type: 'configsComputed';
     value: unknown;
 };
-declare function getPageContextExports(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageContextExports;
+declare function getPageConfigUserFriendly(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageConfigUserFriendly;
+type ConfigUserFriendly = {
+    config: ConfigResolved;
+    configEntries: ConfigEntries;
+    exportsAll: ExportsAll;
+    source: Source;
+    sources: Sources;
+    from: From;
+};
+declare function getPageConfigUserFriendlyNew(pageConfig: {
+    configValues: ConfigValues;
+}): ConfigUserFriendly;

package/dist/esm/shared/{getPageFiles/getExports.js → page-configs/getPageConfigUserFriendly.js}

@@ -1,14 +1,14 @@
-export { getPageContextExports };
-import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
-import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
-import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
-import { getConfigDefinedAtOptional, getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
-import { getConfigValueFilePathToShowToUser } from '../page-configs/helpers.js';
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyNew };
+import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
+import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
+import { getConfigValueFilePathToShowToUser } from './helpers.js';
+import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getPageContextExports(pageFiles, pageConfig) {
-    const configEntries = {};
+function getPageConfigUserFriendly(pageFiles, pageConfig) {
     const config = {};
-    const exportsAll = {};
+    const configEntries = {}; // TODO/v1-release: remove
+    const exportsAll = {}; // TODO/v1-release: remove
     // V0.4 design
     // TODO/v1-release: remove
     pageFiles.forEach((pageFile) => {
@@ -26,78 +26,26 @@ function getPageContextExports(pageFiles, pageConfig) {
             });
         });
     });
-    // V1 design
-    const source = {};
-    const sources = {};
-    const addSrc = (src, configName) => {
-        source[configName] = src;
-        sources[configName] ?? (sources[configName] = []);
-        sources[configName].push(src);
-    };
-    const from = {
-        configsStandard: {},
-        configsCumulative: {},
-        configsComputed: {}
-    };
+    let source;
+    let sources;
+    let from;
     if (pageConfig) {
-        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            const { value } = configValue;
-            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
-            const configDefinedAt = getConfigDefinedAtOptional('Config', configName, configValue.definedAtData);
-            config[configName] = config[configName] ?? value;
-            configEntries[configName] = configEntries[configName] ?? [];
-            // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
-            assert(configEntries[configName].length === 0);
-            configEntries[configName].push({
-                configValue: value,
-                configDefinedAt,
-                configDefinedByFile: configValueFilePathToShowToUser
-            });
-            if (configValue.type === 'standard') {
-                const src = {
-                    type: 'configsStandard',
-                    value: configValue.value,
-                    definedAt: getDefinedAtString(configValue.definedAtData, configName)
-                };
-                addSrc(src, configName);
-                from.configsStandard[configName] = src;
-            }
-            if (configValue.type === 'cumulative') {
-                const src = {
-                    type: 'configsCumulative',
-                    values: configValue.value.map((value, i) => {
-                        const definedAtFile = configValue.definedAtData[i];
-                        assert(definedAtFile);
-                        const definedAt = getDefinedAtString(definedAtFile, configName);
-                        return {
-                            value,
-                            definedAt
-                        };
-                    })
-                };
-                addSrc(src, configName);
-                from.configsCumulative[configName] = src;
-            }
-            if (configValue.type === 'computed') {
-                const src = {
-                    type: 'configsComputed',
-                    value: configValue.value
-                };
-                addSrc(src, configName);
-                from.configsComputed[configName] = src;
-            }
-            // TODO/v1-release: remove
-            const exportName = configName;
-            exportsAll[exportName] = exportsAll[exportName] ?? [];
-            exportsAll[exportName].push({
-                exportValue: value,
-                exportSource: configDefinedAt,
-                filePath: configValueFilePathToShowToUser,
-                _filePath: configValueFilePathToShowToUser,
-                _fileType: null,
-                _isFromDefaultExport: null
-            });
-        });
+        const res = getPageConfigUserFriendlyNew(pageConfig);
+        source = res.source;
+        sources = res.sources;
+        from = res.from;
+        Object.assign(config, res.config);
+        Object.assign(configEntries, res.configEntries);
+        Object.assign(exportsAll, res.exportsAll);
+    }
+    else {
+        source = {};
+        sources = {};
+        from = {
+            configsStandard: {},
+            configsCumulative: {},
+            configsComputed: {}
+        };
     }
     const pageExports = createObjectWithDeprecationWarning();
     const exports = {};
@@ -127,6 +75,90 @@ function getPageContextExports(pageFiles, pageConfig) {
     };
     return pageContextExports;
 }
+// V1 design
+function getPageConfigUserFriendlyNew(pageConfig) {
+    const config = {};
+    const configEntries = {};
+    const exportsAll = {};
+    const source = {};
+    const sources = {};
+    const from = {
+        configsStandard: {},
+        configsCumulative: {},
+        configsComputed: {}
+    };
+    const addSrc = (src, configName) => {
+        source[configName] = src;
+        sources[configName] ?? (sources[configName] = []);
+        sources[configName].push(src);
+    };
+    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+        const { value } = configValue;
+        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
+        const configDefinedAt = getConfigDefinedAtOptional('Config', configName, configValue.definedAtData);
+        config[configName] = config[configName] ?? value;
+        configEntries[configName] = configEntries[configName] ?? [];
+        // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
+        assert(configEntries[configName].length === 0);
+        configEntries[configName].push({
+            configValue: value,
+            configDefinedAt,
+            configDefinedByFile: configValueFilePathToShowToUser
+        });
+        if (configValue.type === 'standard') {
+            const src = {
+                type: 'configsStandard',
+                value: configValue.value,
+                definedAt: getDefinedAtString(configValue.definedAtData, configName)
+            };
+            addSrc(src, configName);
+            from.configsStandard[configName] = src;
+        }
+        if (configValue.type === 'cumulative') {
+            const src = {
+                type: 'configsCumulative',
+                values: configValue.value.map((value, i) => {
+                    const definedAtFile = configValue.definedAtData[i];
+                    assert(definedAtFile);
+                    const definedAt = getDefinedAtString(definedAtFile, configName);
+                    return {
+                        value,
+                        definedAt
+                    };
+                })
+            };
+            addSrc(src, configName);
+            from.configsCumulative[configName] = src;
+        }
+        if (configValue.type === 'computed') {
+            const src = {
+                type: 'configsComputed',
+                value: configValue.value
+            };
+            addSrc(src, configName);
+            from.configsComputed[configName] = src;
+        }
+        // TODO/v1-release: remove
+        const exportName = configName;
+        exportsAll[exportName] = exportsAll[exportName] ?? [];
+        exportsAll[exportName].push({
+            exportValue: value,
+            exportSource: configDefinedAt,
+            filePath: configValueFilePathToShowToUser,
+            _filePath: configValueFilePathToShowToUser,
+            _fileType: null,
+            _isFromDefaultExport: null
+        });
+    });
+    return {
+        config,
+        configEntries,
+        exportsAll,
+        source,
+        sources,
+        from
+    };
+}
 function getExportValues(pageFile) {
     const { filePath, fileExports } = pageFile;
     assert(fileExports); // assume pageFile.loadFile() was called

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

@@ -1,7 +1,27 @@
 export { serializeConfigValues };
-import type { ConfigEnvInternal, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
-declare function serializeConfigValues(pageConfig: PageConfigBuildTime | (PageConfigGlobalBuildTime & {
-    configValuesComputed?: undefined;
-}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, { isEager }: {
-    isEager: boolean;
-}, tabspace: string): string[];
+export { getConfigValuesBase };
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
+declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
+type ConfigValuesBase = ({
+    configValueBase: {
+        type: 'computed';
+        definedAtData: null;
+    };
+    value: unknown;
+    configName: string;
+} | {
+    configValueBase: {
+        type: 'standard';
+        definedAtData: DefinedAtFile;
+    };
+    sourceRelevant: ConfigValueSource;
+    configName: string;
+} | {
+    configValueBase: {
+        type: 'cumulative';
+        definedAtData: DefinedAtFile[];
+    };
+    sourcesRelevant: ConfigValueSource[];
+    configName: string;
+})[];