vike 0.4.171 → 0.4.172

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

@@ -0,0 +1,192 @@
+export { serializeConfigValues };
+import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
+import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
+import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
+import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js';
+import { getConfigValueFilePathToShowToUser } from '../helpers.js';
+import { stringify } from '@brillout/json-serializer/stringify';
+import pc from '@brillout/picocolors';
+const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
+const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
+// - vike/shared/page-configs/serialize/parsePageConfigs.ts
+// - parsePageConfigs() is loaded on both the client- and server-side.
+assertIsNotProductionRuntime();
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace) {
+    const lines = [];
+    tabspace += '  ';
+    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
+        if (!isEnvMatch(configValuesComputed.configEnv))
+            return;
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return;
+        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+    });
+    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        assert(configDef);
+        if (!configDef.cumulative) {
+            const configValueSource = sources[0];
+            assert(configValueSource);
+            assert(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(configValueSource.configEnv))
+                return;
+            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        else {
+            const valueDataList = [];
+            const definedAtData = [];
+            sources
+                .filter((s) => !s.isOverriden)
+                .forEach((configValueSource) => {
+                if (!isEnvMatch(configValueSource.configEnv))
+                    return;
+                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+                valueDataList.push(valueData);
+                definedAtData.push(definedAtFile);
+            });
+            if (valueDataList.length === 0)
+                return;
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
+        }
+    });
+    return lines;
+}
+function serializeConfigValueSource(configValueSource, configName, importStatements) {
+    assert(configValueSource.isOverriden === false);
+    let valueData;
+    if ('value' in configValueSource) {
+        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+    }
+    else {
+        valueData = serializeWithImport(configValueSource, importStatements);
+    }
+    const definedAtFile = {
+        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return { valueData, definedAtFile };
+}
+function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
+    lineAdd(`[${JSON.stringify(configName)}]: {`);
+    {
+        tab();
+        lineAdd(`type: "${configValueBase.type}",`);
+        lineAdd(`definedAtData: ${JSON.stringify(configValueBase.definedAtData)},`);
+        lineAdd(`valueSerialized:`);
+        if (!Array.isArray(valueData)) {
+            serializeValueData(valueData);
+        }
+        else {
+            lineAppend(' [');
+            valueData.forEach(serializeValueData);
+            lineAppend(` ],`);
+        }
+        untab();
+    }
+    lineAdd('},');
+    return;
+    function serializeValueData(valueData) {
+        lineAppend(` {`);
+        tab();
+        lineAdd(`type: "${valueData.type}",`);
+        const valueProp = valueData.type !== 'plus-file' ? 'value' : 'exportValues';
+        lineAdd(`${valueProp}: ${valueData.valueAsJsCode},`);
+        untab();
+        lineAdd(`},`);
+    }
+    function lineAppend(str) {
+        const i = lines.length - 1;
+        lines[i] = lines[i] += str;
+    }
+    function lineAdd(str) {
+        lines.push(`${tabspace}${str}`);
+    }
+    function tab() {
+        tabspace += '  ';
+    }
+    function untab() {
+        tabspace = tabspace.slice(2);
+    }
+}
+function serializeWithImport(configValueSource, importStatements) {
+    assert(!configValueSource.valueIsFilePath);
+    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
+    assert(valueIsImportedAtRuntime);
+    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
+    if (valueIsDefinedByPlusFile)
+        assert(fileExportName === undefined);
+    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*');
+    return {
+        type: valueIsDefinedByPlusFile ? 'plus-file' : 'pointer-import',
+        valueAsJsCode: importName
+    };
+}
+function serializeWithJson(value, configName, definedAtData, importStatements) {
+    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
+    return {
+        type: 'js-serialized',
+        valueAsJsCode
+    };
+}
+function valueToJson(value, configName, definedAtData, importStatements) {
+    const valueName = `config${getPropAccessNotation(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = stringify(value, {
+            valueName,
+            forbidReactElements: true,
+            replacer(_, value) {
+                if (typeof value === 'string') {
+                    const importData = parsePointerImportData(value);
+                    if (importData) {
+                        const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName);
+                        const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
+                        return { replacement };
+                    }
+                }
+            }
+        });
+    }
+    catch (err) {
+        logJsonSerializeError(err, configName, definedAtData);
+        assert(false);
+    }
+    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
+    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
+    assert(!configValueSerialized.includes(REPLACE_ME_BEFORE));
+    assert(!configValueSerialized.includes(REPLACE_ME_AFTER));
+    return configValueSerialized;
+}
+function logJsonSerializeError(err, configName, definedAtData) {
+    /*
+    // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
+    let serializationErrMsg = ''
+    if (isJsonSerializerError(err)) {
+      serializationErrMsg = err.messageCore
+    } else {
+      // When a property getter throws an error
+      console.error('Serialization error:')
+      console.error(err)
+      serializationErrMsg = 'see serialization error printed above'
+    }
+    //*/
+    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
+    assert(configValueFilePathToShowToUser);
+    assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
+}

package/dist/esm/shared/route/executeGuardHook.js

@@ -21,7 +21,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook, pageContext);
     assertUsage(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 function findPageGuard(pageId, pageFilesAll) {

package/dist/esm/shared/route/executeOnBeforeRouteHook.js

@@ -36,7 +36,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook);
+    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook, pageContext);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
         hookReturn === undefined ||

package/dist/esm/shared/route/index.d.ts

@@ -4,18 +4,18 @@ export type { PageContextFromRoute };
 export type { PageRoutes };
 export type { RouteMatches };
 import type { PageFile } from '../getPageFiles.js';
-import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
+import { type PageContextUrlInternal, type PageContextUrlSource } from '../getPageContextUrlComputed.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 import type { Hook } from '../hooks/getHook.js';
-type PageContextForRoute = PageContextUrlComputedPropsInternal & {
+type PageContextForRoute = PageContextUrlInternal & {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _allPageIds: string[];
     _pageConfigGlobal: PageConfigGlobalRuntime;
     _pageRoutes: PageRoutes;
     _onBeforeRouteHook: Hook | null;
-} & PageContextUrlSources;
+} & PageContextUrlSource;
 type PageContextFromRoute = {
     _pageId: string | null;
     routeParams: Record<string, string>;

package/dist/esm/shared/route/index.js

@@ -6,7 +6,7 @@ if (isBrowser()) {
     assertClientRouting();
 }
 import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
-import { addUrlComputedProps } from '../addUrlComputedProps.js';
+import { assertPageContextUrl } from '../getPageContextUrlComputed.js';
 import { resolvePrecendence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';
@@ -15,7 +15,7 @@ import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
 async function route(pageContextForRoute) {
     debug('Pages routes:', pageContextForRoute._pageRoutes);
-    addUrlComputedProps(pageContextForRoute);
+    assertPageContextUrl(pageContextForRoute);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(pageContextForRoute);

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

@@ -3,7 +3,7 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
@@ -28,7 +28,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = getConfigValue(pageConfig, configName);
+                const configValue = getConfigValueRuntime(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
                     assert(configValue.definedAtData);
@@ -44,7 +44,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         assert(isCallable(route));
-                        if (getConfigValue(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if (getConfigValueRuntime(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             warnDeprecatedAllowKey();
                         pageRoute = {
                             pageId,

package/dist/esm/shared/route/resolveRouteFunction.d.ts

@@ -2,8 +2,8 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { PageContextUrlComputedPropsInternal } from '../addUrlComputedProps.js';
-declare function resolveRouteFunction(routeFunction: Function, pageContext: PageContextUrlComputedPropsInternal, routeDefinedAtString: string): Promise<null | {
+import { PageContextUrlInternal } from '../getPageContextUrlComputed.js';
+declare function resolveRouteFunction(routeFunction: Function, pageContext: PageContextUrlInternal, routeDefinedAtString: string): Promise<null | {
     precedence: number | null;
     routeParams: Record<string, string>;
 }>;

package/dist/esm/shared/route/resolveRouteFunction.js

@@ -2,11 +2,11 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { assertPageContextUrlComputedProps } from '../addUrlComputedProps.js';
+import { assertPageContextUrl } from '../getPageContextUrlComputed.js';
 import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise } from './utils.js';
 import pc from '@brillout/picocolors';
 async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString) {
-    assertPageContextUrlComputedProps(pageContext);
+    assertPageContextUrl(pageContext);
     let result = routeFunction(pageContext);
     assertSyncRouting(result, `The Route Function ${routeDefinedAtString}`);
     // TODO/v1-release: make resolveRouteFunction() and route() sync

package/dist/esm/shared/sortPageContext.js

@@ -2,13 +2,9 @@ import { compareString } from './utils.js';
 export { sortPageContext };
 // Sort `pageContext` keys alphabetically, in order to make reading `console.log(pageContext)` easier
 function sortPageContext(pageContext) {
-    const entries = Object.entries(pageContext);
-    for (const key in pageContext) {
+    let descriptors = Object.getOwnPropertyDescriptors(pageContext);
+    for (const key of Object.keys(pageContext))
         delete pageContext[key];
-    }
-    entries
-        .sort(([key1], [key2]) => compareString(key1, key2))
-        .forEach(([key, val]) => {
-        pageContext[key] = val;
-    });
+    descriptors = Object.fromEntries(Object.entries(descriptors).sort(([key1], [key2]) => compareString(key1, key2)));
+    Object.defineProperties(pageContext, descriptors);
 }

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

@@ -7,8 +7,8 @@ export { PageContextBuiltInServerInternal };
 export { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
-import type { PageContextUrlComputedPropsInternal, PageContextUrlComputedPropsClient, PageContextUrlComputedPropsServer } from './addUrlComputedProps.js';
-import type { ConfigEntries, ExportsAll } from './getPageFiles/getExports.js';
+import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
+import type { ConfigEntries, ExportsAll, From, Source, Sources } from './getPageFiles/getExports.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
@@ -59,6 +59,26 @@ type PageContextBuiltInCommon<Data> = {
      * https://vike.dev/renderPage
      */
     urlOriginal: string;
+    /**
+     * The HTTP Headers of the incoming HTTP Request.
+     *
+     * As a string object normalized by Vike.
+     *
+     * See also:
+     * - https://vike.dev/headers
+     * - `pageContext.headersOriginal`
+     */
+    headers: Record<string, string> | null;
+    /**
+     * The HTTP Headers of the incoming HTTP Request.
+     *
+     * The original object provided by the server.
+     *
+     * See also:
+     * - https://vike.dev/headers
+     * - `pageContext.headers`
+     */
+    headersOriginal?: unknown;
     /** If an error occurs, whether the error is a `404 Page Not Found`.
      *
      * https://vike.dev/error-page
@@ -88,13 +108,19 @@ type PageContextBuiltInCommon<Data> = {
      * https://vike.dev/errors
      */
     errorWhileRendering?: unknown;
+    /** @experimental https://github.com/vikejs/vike/issues/1268 */
+    from: From;
+    /** @experimental https://github.com/vikejs/vike/issues/1268 */
+    source: Source;
+    /** @experimental https://github.com/vikejs/vike/issues/1268 */
+    sources: Sources;
     /** @deprecated */
     url: string;
     /** @deprecated */
     pageExports: Record<string, unknown>;
 };
-type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlComputedPropsServer;
-type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data'> & {
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer;
+type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'source' | 'sources' | 'from'> & {
     /** Whether the current page is already rendered to HTML */
     isHydration: boolean;
     /**
@@ -103,7 +129,7 @@ type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltI
      * The value is `true` when the user clicks on his browser's backward navigation button, or when invoking `history.back()`.
      */
     isBackwardNavigation: boolean | null;
-} & PageContextUrlComputedPropsClient;
+} & PageContextUrlClient;
 type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'data'> & {
     /**
      * Whether the current page is already rendered to HTML.
@@ -119,7 +145,7 @@ type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltI
     isBackwardNavigation: null;
 };
 /** For Vike internal use */
-type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlComputedPropsInternal, 'data'>;
+type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data'>;
 /** @deprecated
  * Replace:
  *   ```

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

@@ -21,3 +21,5 @@ export * from '../utils/checkType.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';
 export * from '../utils/isArray.js';
+export * from '../utils/changeEnumerable.js';
+export * from '../utils/objectDefineProperty.js';

package/dist/esm/shared/utils.js

@@ -25,3 +25,5 @@ export * from '../utils/checkType.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';
 export * from '../utils/isArray.js';
+export * from '../utils/changeEnumerable.js';
+export * from '../utils/objectDefineProperty.js';

package/dist/esm/types/index.d.ts

@@ -10,7 +10,7 @@ export type { Config, ConfigMeta as Meta, DataAsync, DataSync, GuardAsync, Guard
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
-export type { Url } from '../shared/addUrlComputedProps.js';
+export type { Url } from '../shared/getPageContextUrlComputed.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';
 import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';

package/dist/esm/utils/assert.js

@@ -92,7 +92,7 @@ function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
     }
     globalObject.onBeforeLog?.();
     if (showStackTrace) {
-        const err = new Error(msg);
+        const err = createErrorWithCleanStackTrace(msg, numberOfStackTraceLinesToRemove);
         globalObject.showStackTraceList.add(err);
         globalObject.logger(err, 'warn');
     }

package/dist/esm/utils/assertNodeVersion.js

@@ -6,5 +6,5 @@ function assertNodeVersion() {
     if (!isNodeJS())
         return;
     const version = process.versions.node;
-    assertVersion('Node.js', version, '16.0.0');
+    assertVersion('Node.js', version, '18.0.0');
 }

package/dist/esm/utils/changeEnumerable.d.ts

@@ -0,0 +1,2 @@
+/** Change enumerability of an object property. */
+export declare function changeEnumerable(obj: Object, prop: string, enumerable: boolean): void;

package/dist/esm/utils/changeEnumerable.js

@@ -0,0 +1,5 @@
+/** Change enumerability of an object property. */
+export function changeEnumerable(obj, prop, enumerable) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    Object.defineProperty(obj, prop, { ...descriptor, enumerable });
+}

package/dist/esm/utils/escapeHtml.d.ts

@@ -0,0 +1 @@
+export declare function escapeHtml(unsafeString: string): string;

package/dist/esm/utils/escapeHtml.js

@@ -0,0 +1,10 @@
+// Copied from https://stackoverflow.com/questions/6234773/can-i-escape-html-special-chars-in-javascript/6234804#6234804
+export function escapeHtml(unsafeString) {
+    const safe = unsafeString
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+    return safe;
+}

package/dist/esm/utils/getPropAccessNotation.d.ts

@@ -1,2 +1 @@
-export { getPropAccessNotation };
-declare function getPropAccessNotation(key: string): `.${string}` | `[${string}]`;
+export declare function getPropAccessNotation(key: unknown): `.${string}` | `[${string}]`;

package/dist/esm/utils/getPropAccessNotation.js

@@ -1,7 +1,3 @@
-export { getPropAccessNotation };
-function getPropAccessNotation(key) {
-    return isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
-}
-function isKeyDotNotationCompatible(key) {
-    return /^[a-z0-9\$_]+$/i.test(key);
+export function getPropAccessNotation(key) {
+    return typeof key === 'string' && /^[a-z0-9\$_]+$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
 }

package/dist/esm/utils/hasProp.d.ts

@@ -1,15 +1,6 @@
 export { hasProp };
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'boolean'): obj is ObjectType & Record<PropName, boolean>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'number'): obj is ObjectType & Record<PropName, number>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string'): obj is ObjectType & Record<PropName, string>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'object'): obj is ObjectType & Record<PropName, Record<string, unknown>>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'array'): obj is ObjectType & Record<PropName, unknown[]>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string[]'): obj is ObjectType & Record<PropName, string[]>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string{}'): obj is ObjectType & Record<PropName, Record<string, string>>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'function'): obj is ObjectType & Record<PropName, (...args: any[]) => unknown>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'undefined'): obj is ObjectType & Record<PropName, undefined>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'null'): obj is ObjectType & Record<PropName, null>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'true'): obj is ObjectType & Record<PropName, true>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'false'): obj is ObjectType & Record<PropName, false>;
+export type { ResolveTypeAsString };
+type TypeAsString = 'object' | 'string{}' | 'string[]' | 'array' | 'function' | 'number' | 'string' | 'boolean' | 'true' | 'false' | 'null' | 'undefined' | undefined;
+type ResolveTypeAsString<Type extends TypeAsString = undefined> = Type extends 'object' ? Record<string, unknown> : Type extends 'string{}' ? Record<string, string> : Type extends 'string[]' ? string[] : Type extends 'array' ? unknown[] : Type extends 'function' ? (...args: any[]) => unknown : Type extends 'number' ? number : Type extends 'string' ? string : Type extends 'boolean' ? boolean : Type extends 'true' ? true : Type extends 'false' ? false : Type extends 'null' ? null : Type extends 'undefined' ? undefined : Type extends undefined ? unknown : never;
+declare function hasProp<ObjectType, PropName extends PropertyKey, Type extends TypeAsString = undefined>(obj: ObjectType, prop: PropName, type?: Type): obj is ObjectType & Record<PropName, ResolveTypeAsString<Type>>;
 declare function hasProp<ObjectType, PropName extends PropertyKey, Enum>(obj: ObjectType, prop: PropName, type: Enum[]): obj is ObjectType & Record<PropName, Enum>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName): obj is ObjectType & Record<PropName, unknown>;

package/dist/esm/utils/hasProp.js

@@ -1,21 +1,22 @@
 export { hasProp };
-// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
-// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
 import { isCallable } from './isCallable.js';
 import { isObject } from './isObject.js';
 import { isArrayOfStrings } from './isArrayOfStrings.js';
 import { isObjectOfStrings } from './isObjectOfStrings.js';
 import { isArray } from './isArray.js';
-function hasProp(obj, prop, type = 'unknown') {
+function hasProp(obj, prop, type) {
     if (!isObject(obj))
         return false;
     if (!(prop in obj)) {
         return type === 'undefined';
     }
-    if (type === 'unknown') {
+    if (type === undefined) {
         return true;
     }
     const propValue = obj[prop];
+    if (type === 'undefined') {
+        return propValue === undefined;
+    }
     if (type === 'array') {
         return isArray(propValue);
     }
@@ -37,9 +38,6 @@ function hasProp(obj, prop, type = 'unknown') {
     if (type === 'null') {
         return propValue === null;
     }
-    if (type === 'undefined') {
-        return propValue === undefined;
-    }
     if (type === 'true') {
         return propValue === true;
     }

package/dist/esm/utils/normalizeHeaders.d.ts

@@ -0,0 +1 @@
+export declare function normalizeHeaders(headersOriginal: unknown): Record<string, string>;

package/dist/esm/utils/normalizeHeaders.js

@@ -0,0 +1,9 @@
+export function normalizeHeaders(
+/* This type is precise, too precise which can be annoying: e.g. cannot pass a string[][] argument because it doesn't match the more precise [string,string][] type.
+headersOriginal ConstructorParameters<typeof Headers>[0]
+*/
+headersOriginal) {
+    const headersStandard = new Headers(headersOriginal);
+    const headers = Object.fromEntries(headersStandard.entries());
+    return headers;
+}

package/dist/esm/utils/objectAssign.js

@@ -1,7 +1,7 @@
 export { objectAssign };
 // Same as Object.assign() but:
 //  - With type inference
-//  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
+//  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
 function objectAssign(obj, objAddendum) {
     if (objAddendum) {
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));

package/dist/esm/utils/objectDefineProperty.d.ts

@@ -0,0 +1,4 @@
+/** Like Object.defineProperty() but with type inference */
+export declare function objectDefineProperty<Obj extends object, Prop extends PropertyKey, PropertyType>(obj: Obj, prop: Prop, { get, ...args }: {
+    get: () => PropertyType;
+} & Omit<PropertyDescriptor, 'set' | 'get'>): asserts obj is Obj & Record<Prop, PropertyType>;

package/dist/esm/utils/objectDefineProperty.js

@@ -0,0 +1,4 @@
+/** Like Object.defineProperty() but with type inference */
+export function objectDefineProperty(obj, prop, { get, ...args }) {
+    Object.defineProperty(obj, prop, { ...args, get });
+}

package/dist/esm/utils/objectKeys.d.ts

@@ -1,10 +1,8 @@
 export { objectEntries };
 export { objectFromEntries };
 export { objectKeys };
-type ValueOf<T> = T[keyof T];
-type Entries<T> = [keyof T, ValueOf<T>][];
 /** Same as Object.entries() but with type inference */
-declare function objectEntries<T extends object>(obj: T): Entries<T>;
+declare function objectEntries<T extends object>(obj: T): [keyof T, T[keyof T]][];
 /** Same as Object.fromEntries() but with type inference */
 declare function objectFromEntries<T extends [PropertyKey, unknown][]>(arr: T): Record<T[number][0], T[number][1]>;
 /** Same as Object.keys() but with type inference */

package/dist/esm/utils/objectKeys.js

@@ -1,6 +1,7 @@
 export { objectEntries };
 export { objectFromEntries };
 export { objectKeys };
+// export { forEach }
 // https://stackoverflow.com/questions/60141960/typescript-key-value-relation-preserving-object-entries-type/75337277#75337277
 /** Same as Object.entries() but with type inference */
 function objectEntries(obj) {
@@ -16,8 +17,11 @@ function objectFromEntries(arr) {
 function objectKeys(obj) {
     return Object.keys(obj);
 }
-/*
-function objectKeys2<T extends Record<string, unknown>>(obj: T): Array<keyof T> {
-  return Object.keys(obj)
+/* Not used yet, but can be quite useful.
+function forEach<Obj extends object>(
+  obj: Obj,
+  iterator: <Key extends keyof Obj>(key: Key, val: Obj[Key]) => void
+): void {
+  Object.entries(obj).forEach(([key, val]) => iterator(key as keyof Obj, val))
 }
-*/
+//*/