vike 0.4.171 → 0.4.172-commit-ea2b76c

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

@@ -6,9 +6,9 @@ export { getRenderContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { getPageFilesAll } from '../../../shared/getPageFiles.js';
-import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAssign } from '../utils.js';
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
-import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
+import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { getGlobalContext } from '../globalContext.js';
 import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
 import { loadUserFilesServerSide } from './loadUserFilesServerSide.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
@@ -106,9 +105,9 @@ async function prerender404Page(renderContext, pageContextInit_) {
         _debugRouteMatches: []
     };
     const pageContextInit = {
-        urlOriginal: '/fake-404-url', // A URL is needed for `applyViteHtmlTransform`
-        ...pageContextInit_
+        urlOriginal: '/fake-404-url' // A URL is needed for `applyViteHtmlTransform`
     };
+    objectAssign(pageContextInit, pageContextInit_);
     {
         const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
         objectAssign(pageContext, pageContextInitEnhanced);
@@ -116,15 +115,16 @@ async function prerender404Page(renderContext, pageContextInit_) {
     objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     return prerenderPage(pageContext);
 }
-function getPageContextInitEnhanced(pageContextInit, renderContext, { urlComputedPropsNonEnumerable = false, ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
 } } = {}) {
     assert(pageContextInit.urlOriginal);
     const globalContext = getGlobalContext();
-    const pageContextInitEnhanced = {
-        ...pageContextInit,
+    const pageContextInitEnhanced = {};
+    objectAssign(pageContextInitEnhanced, pageContextInit);
+    objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
         // The following is defined on `pageContext` because we can eventually make these non-global (e.g. sot that two pages can have different includeAssetsImportedByServer settings)
         _baseServer: globalContext.baseServer,
@@ -141,8 +141,27 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { urlCompute
         _urlRewrite: urlRewrite,
         _urlHandler: urlHandler,
         isClientSideNavigation
-    };
-    addUrlComputedProps(pageContextInitEnhanced, !urlComputedPropsNonEnumerable);
+    });
+    // pageContext.urlParsed
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContextInitEnhanced);
+    objectAssign(pageContextInitEnhanced, pageContextUrlComputed);
+    // pageContext.headers
+    {
+        let headers;
+        if (pageContextInit.headersOriginal) {
+            headers = normalizeHeaders(pageContextInit.headersOriginal);
+            assertUsage(!('headers' in pageContextInit), "You're defining pageContextInit.headersOriginal as well as pageContextInit.headers but you should only define pageContextInit.headersOriginal instead, see https://vike.dev/headers");
+        }
+        else if (pageContextInit.headers) {
+            headers = pageContextInit.headers;
+            // TODO/next-major-release: assertUsage() instead of assertWarning()
+            assertWarning(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        objectAssign(pageContextInitEnhanced, { headers });
+    }
     return pageContextInitEnhanced;
 }
 // TODO: remove getRenderContext() in favor of getGlobalObject() + reloadGlobalContext()
@@ -151,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/runtime/renderPage.js

@@ -199,7 +199,7 @@ function logHttpRequest(urlOriginal, httpRequestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
 }
 function getRequestInfoMessage(urlOriginal) {
-    return `HTTP request: ${pc.bold(urlOriginal)}`;
+    return `HTTP request: ${prettyUrl(urlOriginal)}`;
 }
 function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
     const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
@@ -215,7 +215,7 @@ function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
             //   - We should show `HTTP response ${urlOriginal} ERR` instead.
             //   - Maybe we can/should make the error available at pageContext.errorWhileRendering
             assert(errorWhileRendering === null || errorWhileRendering === undefined);
-            msg = `HTTP response ${pc.bold(urlOriginal)} ${pc.dim('null')}`;
+            msg = `HTTP response ${prettyUrl(urlOriginal)} ${pc.dim('null')}`;
             // Erroneous value (it shoud sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
             isNominal = true;
         }
@@ -235,7 +235,7 @@ function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
                 const urlRedirect = headerRedirect[1];
                 urlOriginal = urlRedirect;
             }
-            msg = `HTTP ${type} ${pc.bold(urlOriginal)} ${color(statusCode ?? 'ERR')}`;
+            msg = `HTTP ${type} ${prettyUrl(urlOriginal)} ${color(statusCode ?? 'ERR')}`;
         }
     }
     logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error');
@@ -283,12 +283,13 @@ async function renderPageNominal(pageContext) {
 async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, renderContext, httpRequestId) {
     const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, null, httpRequestId);
     assert(errNominalPage);
-    const pageContext = {
-        ...pageContextInitEnhanced,
+    const pageContext = {};
+    objectAssign(pageContext, pageContextInitEnhanced);
+    objectAssign(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
         routeParams: {}
-    };
+    });
     objectAssign(pageContext, {
         _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR'
     });
@@ -340,7 +341,9 @@ function normalizeUrl(pageContextInit, httpRequestId) {
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
     const httpResponse = createHttpResponseObjectRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
-    const pageContextHttpResponse = { ...pageContextInit, httpResponse };
+    const pageContextHttpResponse = {};
+    objectAssign(pageContextHttpResponse, pageContextInit);
+    objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
 function getPermanentRedirect(pageContextInit, httpRequestId) {
@@ -375,7 +378,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     }
     logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
-    const pageContextHttpResponse = { ...pageContextInit, httpResponse };
+    const pageContextHttpResponse = {};
+    objectAssign(pageContextHttpResponse, pageContextInit);
+    objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
@@ -391,11 +396,11 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
             const pageContext = {
-                _pageId: errorPageId,
-                ...pageContextAbort,
-                ...pageContextErrorPageInit,
-                ...renderContext
+                _pageId: errorPageId
             };
+            objectAssign(pageContext, pageContextAbort);
+            objectAssign(pageContext, pageContextErrorPageInit);
+            objectAssign(pageContext, renderContext);
             objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = serializePageContextClientSide(pageContext);
@@ -416,10 +421,9 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = {
-            ...pageContextInit,
-            ...pageContextAbort
-        };
+        const pageContextReturn = {};
+        objectAssign(pageContextReturn, pageContextInit);
+        objectAssign(pageContextReturn, pageContextAbort);
         const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, (() => {
             const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
             const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
@@ -439,9 +443,12 @@ function checkBaseUrl(pageContextInit, httpRequestId) {
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
     if (!hasBaseServer) {
-        logRuntimeInfo?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${pc.bold(urlOriginal)} doesn't start with Base URL ${pc.bold(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
+        logRuntimeInfo?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${prettyUrl(urlOriginal)} doesn't start with Base URL ${prettyUrl(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
         const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
         return pageContextHttpResponseNull;
     }
     return null;
 }
+function prettyUrl(url) {
+    return pc.bold(decodeURI(url));
+}

package/dist/esm/node/runtime/utils.d.ts

@@ -49,3 +49,5 @@ export * from '../../utils/truncateString.js';
 export * from '../../utils/formatHintLog.js';
 export * from '../../utils/joinEnglish.js';
 export * from '../../utils/isArrayOfStrings.js';
+export * from '../../utils/escapeHtml.js';
+export * from '../../utils/normalizeHeaders.js';

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

@@ -52,3 +52,5 @@ export * from '../../utils/truncateString.js';
 export * from '../../utils/formatHintLog.js';
 export * from '../../utils/joinEnglish.js';
 export * from '../../utils/isArrayOfStrings.js';
+export * from '../../utils/escapeHtml.js';
+export * from '../../utils/normalizeHeaders.js';

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/VikeNamespace.d.ts

@@ -9,6 +9,7 @@ declare global {
          *  - You can refine the type of `Config['Page']`.
          *  - You can define the type of custom configurations created with `config.meta` (https://vike.dev/meta)
          *
+         *  https://vike.dev/meta#typescript
          */
         interface Config {
         }
@@ -22,6 +23,14 @@ declare global {
          */
         interface PageContext {
         }
+        /** Refine the `pageContext.config` type.
+         *
+         *  It's used for cumulative configs: the `pageContext.config[configName]` type is an `array` whereas `Config[configName]` isn't.
+         *
+         *  https://vike.dev/meta#typescript
+         */
+        interface ConfigResolved {
+        }
     }
     /** This namespace is only used by:
      *  - `vike-react`

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

@@ -0,0 +1 @@
+export { getPageContext } from './hooks/executeHook.js';

package/dist/esm/shared/getPageContext.js

@@ -0,0 +1 @@
+export { getPageContext } from './hooks/executeHook.js';

package/dist/esm/shared/{addUrlComputedProps.d.ts → getPageContextUrlComputed.d.ts}

@@ -1,9 +1,9 @@
-export { addUrlComputedProps };
-export { assertPageContextUrlComputedProps };
-export type { PageContextUrlComputedPropsInternal };
-export type { PageContextUrlComputedPropsClient };
-export type { PageContextUrlComputedPropsServer };
-export type { PageContextUrlSources };
+export { getPageContextUrlComputed };
+export { assertPageContextUrl };
+export type { PageContextUrlInternal };
+export type { PageContextUrlClient };
+export type { PageContextUrlServer };
+export type { PageContextUrlSource };
 export type { Url };
 type Url = {
     /** The URL origin, e.g. `https://example.com` of `https://example.com/product/42?details=yes#reviews` */
@@ -27,23 +27,24 @@ type Url = {
     /** @deprecated */
     searchString: null | string;
 };
-type PageContextUrlComputedPropsClient = {
+type PageContextUrlComputed = {
+    /** Parsed information about the current URL */
+    urlParsed: Url;
+    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+    urlPathname: string;
     /** @deprecated */
     url: string;
+};
+type PageContextUrl = {
     /** The URL of the HTTP request */
     urlOriginal: string;
-    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
-    urlPathname: string;
-    /** Parsed information about the current URL */
-    urlParsed: Url;
-};
-/** For Vike internal use */
-type PageContextUrlComputedPropsInternal = PageContextUrlComputedPropsClient & {
+} & PageContextUrlComputed;
+type PageContextUrlInternal = PageContextUrl & {
     _urlRewrite: string | null;
 };
-type HashProps = 'hash' | 'hashString' | 'hashOriginal';
-type PageContextUrlComputedPropsServer = PageContextUrlComputedPropsClient & {
-    urlParsed: Omit<PageContextUrlComputedPropsClient['urlParsed'], HashProps> & {
+type PageContextUrlClient = PageContextUrl;
+type PageContextUrlServer = PageContextUrl & {
+    urlParsed: Omit<PageContextUrl['urlParsed'], HashProps> & {
         /** Only available on the client-side */
         hash: '';
         /** Only available on the client-side */
@@ -52,14 +53,15 @@ type PageContextUrlComputedPropsServer = PageContextUrlComputedPropsClient & {
         hashOriginal: null;
     };
 };
-declare function addUrlComputedProps<PageContext extends Record<string, unknown> & PageContextUrlSources>(pageContext: PageContext, enumerable?: boolean): asserts pageContext is PageContext & PageContextUrlComputedPropsInternal;
-type PageContextUrlSources = {
+type HashProps = 'hash' | 'hashString' | 'hashOriginal';
+declare function getPageContextUrlComputed(pageContext: PageContextUrlSource): PageContextUrlComputed;
+type PageContextUrlSource = {
     urlOriginal: string;
     urlLogical?: string;
     _urlRewrite: string | null;
     _baseServer: string;
     _urlHandler: null | ((url: string) => string);
 };
-declare function assertPageContextUrlComputedProps(pageContext: {
+declare function assertPageContextUrl(pageContext: {
     urlOriginal: string;
-} & PageContextUrlComputedPropsClient): void;
+} & PageContextUrlClient): void;

package/dist/esm/shared/{addUrlComputedProps.js → getPageContextUrlComputed.js}

@@ -1,45 +1,31 @@
-// URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
-export { addUrlComputedProps };
-export { assertPageContextUrlComputedProps };
-import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser } from './utils.js';
-function addUrlComputedProps(pageContext, enumerable = true) {
-    assert(pageContext.urlOriginal);
-    if ('urlPathname' in pageContext) {
-        assert(typeof pageContext.urlPathname === 'string');
-        /* If the following assert() fails then it's most likely because Object.assign() was used instead of objectAssign(), i.e.:
-           ```js
-           // Add property getters such as pageContext.urlPathname to pageContext
-           addUrlComputedProps(pageContext)
-           // ❌ Breaks the property getters of pageContext set by addUrlComputedProps() such as pageContext.urlPathname
-           Object.assign(pageContext2, pageContext)
-           // ❌ Also breaks the property getters
-           const pageContext3 = { ...pageContext }
-           // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
-           objectAssign(pageContext2, pageContext)
-           ```
-        */
-        assert(isPropertyGetter(pageContext, 'urlPathname'));
-    }
-    if ('urlParsed' in pageContext)
-        assert(isPropertyGetter(pageContext, 'urlParsed'));
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        assert(isPropertyGetter(pageContext, 'url'));
-    Object.defineProperty(pageContext, 'urlPathname', {
+export { getPageContextUrlComputed };
+export { assertPageContextUrl };
+// =====================
+// File determining the URL logic.
+// URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
+// =====================
+import { objectDefineProperty } from '../utils/objectDefineProperty.js';
+import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser, changeEnumerable } from './utils.js';
+function getPageContextUrlComputed(pageContext) {
+    assert(typeof pageContext.urlOriginal === 'string');
+    assertPageContextUrlComputed(pageContext);
+    const pageContextUrlComputed = {};
+    objectDefineProperty(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'url', {
+    objectDefineProperty(pageContextUrlComputed, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'urlParsed', {
+    objectDefineProperty(pageContextUrlComputed, 'urlParsed', {
         get: urlParsedGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
+    return pageContextUrlComputed;
 }
 function getUrlParsed(pageContext) {
     // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
@@ -90,7 +76,7 @@ function urlParsedGetter() {
     const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
     const hashIsAvailable = isBrowser();
     const warnHashNotAvailable = (prop) => {
-        assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash by design)`, { onlyOnce: true, showStackTrace: true });
+        assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });
     };
     const urlParsed = {
         origin,
@@ -120,21 +106,45 @@ function urlParsedGetter() {
             return searchOriginal;
         }
     };
-    makeNonEnumerable(urlParsed, 'hashString');
-    makeNonEnumerable(urlParsed, 'searchString');
+    changeEnumerable(urlParsed, 'hashString', false);
+    changeEnumerable(urlParsed, 'searchString', false);
     if (!hashIsAvailable) {
-        makeNonEnumerable(urlParsed, 'hash');
-        makeNonEnumerable(urlParsed, 'hashOriginal');
+        changeEnumerable(urlParsed, 'hash', false);
+        changeEnumerable(urlParsed, 'hashOriginal', false);
     }
     return urlParsed;
 }
-function makeNonEnumerable(obj, prop) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
-    Object.defineProperty(obj, prop, { ...descriptor, enumerable: false });
-}
-function assertPageContextUrlComputedProps(pageContext) {
+function assertPageContextUrl(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');
     assert(typeof pageContext.urlPathname === 'string');
     assert(isPlainObject(pageContext.urlParsed));
     assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
+    assertPageContextUrlComputed(pageContext);
+}
+function assertPageContextUrlComputed(pageContext) {
+    /*
+    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
+    ```js
+    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
+  
+    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
+    Object.assign(pageContext, pageContextUrlComputed)
+  
+    // ❌ Also breaks property descriptors/getters
+    const pageContext = { ...pageContextUrlComputed }
+  
+    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
+    objectAssign(pageContext, pageContextUrlComputed)
+    ```
+    */
+    if ('urlPathname' in pageContext) {
+        assert(typeof pageContext.urlPathname === 'string');
+        assert(isPropertyGetter(pageContext, 'urlPathname'));
+        assert(isPropertyGetter(pageContext, 'urlParsed'));
+        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/getPageFiles/getExports.d.ts

@@ -2,6 +2,9 @@ export { getPageContextExports };
 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';
@@ -27,6 +30,9 @@ type ConfigEntries = Record<string, {
     configDefinedByFile: string | null;
 }[]>;
 type PageContextExports = {
+    source: Source;
+    sources: Sources;
+    from: From;
     config: Record<string, unknown>;
     configEntries: ConfigEntries;
     exports: Record<string, unknown>;
@@ -34,4 +40,34 @@ type PageContextExports = {
     /** @deprecated */
     pageExports: Record<string, unknown>;
 };
+type From = {
+    configsStandard: Record<string, // configName
+    SourceConfigsStandard>;
+    configsCumulative: Record<string, // configName
+    SourceConfigsCumulative>;
+    configsComputed: Record<string, // configName
+    SourceConfigsComputed>;
+};
+type Source = Record<string, // configName
+SourceAny>;
+type Sources = Record<string, // configName
+SourceAny[]>;
+type SourceAny = SourceConfigs;
+type SourceConfigs = SourceConfigsStandard | SourceConfigsCumulative | SourceConfigsComputed;
+type SourceConfigsStandard = {
+    type: 'configsStandard';
+    value: unknown;
+    definedAt: string;
+};
+type SourceConfigsCumulative = {
+    type: 'configsCumulative';
+    values: {
+        value: unknown;
+        definedAt: string;
+    }[];
+};
+type SourceConfigsComputed = {
+    type: 'configsComputed';
+    value: unknown;
+};
 declare function getPageContextExports(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageContextExports;

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

@@ -2,7 +2,7 @@ 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 } from '../page-configs/getConfigDefinedAt.js';
+import { getConfigDefinedAtOptional, getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { getConfigValueFilePathToShowToUser } from '../page-configs/helpers.js';
 import pc from '@brillout/picocolors';
 function getPageContextExports(pageFiles, pageConfig) {
@@ -27,6 +27,18 @@ 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: {}
+    };
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
@@ -41,6 +53,39 @@ function getPageContextExports(pageFiles, pageConfig) {
                 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] ?? [];
@@ -70,9 +115,12 @@ function getPageContextExports(pageFiles, pageConfig) {
     assert(!('default' in exports));
     assert(!('default' in exportsAll));
     const pageContextExports = {
+        from,
+        source,
+        sources,
+        // TODO/eventually: deprecate/remove every prop below
         config,
         configEntries,
-        // TODO/v1-release: remove
         exports,
         exportsAll,
         pageExports