vike 0.4.250-commit-2686732 → 0.4.250-commit-7552006

package/dist/shared-server-client/hooks/execHook.js

@@ -1,55 +1,51 @@
-// TODO: rename all exports
 export { execHook };
 export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-export { execHookBase };
+export { execHookList };
+export { execHookSingle };
+export { execHookSingleSync };
+export { execHookSingleWithReturn };
+export { execHookSingleWithoutPageContext };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
-// TODO: minor refactor — maybe completely remove (some) utils.js files?
 import { assert, getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
-import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
-import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
+import { getHooksFromPageConfigGlobalCumulative, getHooksFromPageContextNew } from './getHook.js';
+import { getPageContextPublicShared } from '../getPageContextPublicShared.js';
 const globalObject = getGlobalObject('utils/execHook.ts', {
     userHookErrors: new WeakMap(),
     pageContext: null,
 });
-// TODO/refactor: export new type PageContextExecHookMinimum instead of PageContextPrepareMinimum ?
-async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
-    const hooks = getHookFromPageContextNew(hookName, pageContext);
-    return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
+async function execHook(hookName, pageContext, getPageContextPublic) {
+    const hooks = getHooksFromPageContextNew(hookName, pageContext);
+    return await execHookList(hooks, pageContext, getPageContextPublic);
 }
-async function execHookGlobal(hookName, globalContext, pageContext, hookArg, prepareForPublicUsage) {
-    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, hookName);
-    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+async function execHookGlobal(hookName, globalContext, getGlobalContextPublic) {
+    const hooks = getHooksFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, hookName);
+    const globalContextPublic = getGlobalContextPublic(globalContext);
     await Promise.all(hooks.map(async (hook) => {
-        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, globalContext, pageContext);
+        await execHookBaseAsync(() => hook.hookFn(globalContextPublic), hook, globalContext, null);
     }));
 }
-async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
+async function execHookList(hooks, pageContext, getPageContextPublic) {
     if (!hooks.length)
         return [];
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    const pageContextPublic = getPageContextPublic(pageContext);
     const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
+        const hookReturn = await execHookBaseAsync(() => hook.hookFn(pageContextPublic), hook, pageContext._globalContext, pageContextPublic);
         return { ...hook, hookReturn };
     }));
     return hooksWithResult;
 }
-async function execHookDirectSingle(hook, pageContext, preparePageContextForPublicUsage) {
-    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+async function execHookSingle(hook, pageContext, getPageContextPublic) {
+    const hooksWithResult = await execHookList([hook], pageContext, getPageContextPublic);
     const { hookReturn } = hooksWithResult[0];
     assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
-async function execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
-    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+async function execHookSingleWithReturn(hook, pageContext, getPageContextPublic) {
+    const hooksWithResult = await execHookList([hook], pageContext, getPageContextPublic);
     const { hookReturn } = hooksWithResult[0];
     return { hookReturn };
 }
@@ -58,12 +54,18 @@ function isUserHookError(err) {
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-async function execHookDirectWithoutPageContext(hookFnCaller, hook, globalContext) {
+async function execHookSingleWithoutPageContext(hook, globalContext, hookFnCaller) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, globalContext, null);
+    const hookReturn = await execHookBaseAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, globalContext, null);
     return hookReturn;
 }
-function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPublicUsage) {
+function execHookSingleSync(hook, globalContext, pageContext, getPageContextPublic, hookFnCaller) {
+    const pageContextPublic = pageContext && getPageContextPublic(pageContext);
+    hookFnCaller ?? (hookFnCaller = () => hook.hookFn(pageContextPublic));
+    const hookReturn = execHookBase(hookFnCaller, hook, globalContext, pageContextPublic);
+    return { hookReturn };
+}
+function execHookBaseAsync(hookFnCaller, hook, globalContext, pageContextPublic) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -94,7 +96,7 @@ function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPu
         }, timeoutErr);
     (async () => {
         try {
-            const ret = await execHookBase(hookFnCaller, hook, globalContext, pageContextForPublicUsage);
+            const ret = await execHookBase(hookFnCaller, hook, globalContext, pageContextPublic);
             resolve(ret);
         }
         catch (err) {
@@ -106,12 +108,7 @@ function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPu
     })();
     return promise;
 }
-function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    const hookReturn = execHookBase(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
-    return { hookReturn };
-}
-// Every execHook* variant should call this
+// Every execHook* function should be based on this
 function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
     const { hookName, hookFilePath } = hook;
     assert(hookName !== 'onHookCall'); // ensure no infinite loop
@@ -134,6 +131,7 @@ function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
         }
         catch (err) {
             originalError = err;
+            throw err;
         }
         return originalReturn;
     };
@@ -147,20 +145,22 @@ function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
                     await onHookCall(hookPublic, pageContext);
                 }
                 catch (err) {
-                    console.error(err);
-                    /* TO-DO/eventually: use dependency injection to be able to use logErrorServer() when this function runs on the server-side.
-                    if (
-                      !globalThis.__VIKE__IS_CLIENT &&
-                      pageContext &&
-                      // Avoid infinite loop
-                      hookName !== 'onError'
-                    ) {
-                      assert(!pageContext.isClientSide)
-                      logErrorServer(err, pageContext)
-                    } else {
-                      logErrorClient(err)
+                    if (err !== originalError) {
+                        console.error(err);
+                        /* TO-DO/eventually: use dependency injection to be able to use logErrorServer() when this function runs on the server-side.
+                        if (
+                          !globalThis.__VIKE__IS_CLIENT &&
+                          pageContext &&
+                          // Avoid infinite loop
+                          hookName !== 'onError'
+                        ) {
+                          assert(!pageContext.isClientSide)
+                          logErrorServer(err, pageContext)
+                        } else {
+                          logErrorClient(err)
+                        }
+                        //*/
                     }
-                    //*/
                 }
             })();
             // +onHookCall must run hook.call() before any `await` — https://github.com/vikejs/vike/pull/2978#discussion_r2645232953
@@ -181,11 +181,11 @@ function getPageContext_sync() {
     const { pageContext } = globalObject;
     if (!pageContext)
         return null;
-    const pageContextForPublicUsage = pageContext._isProxyObject
+    const pageContextPublic = pageContext._isProxyObject
         ? // providePageContext() is called on the user-land (e.g. it's called by `vike-{react,vue,solid}`) thus it's already a proxy
             pageContext
-        : preparePageContextForPublicUsage(pageContext);
-    return pageContextForPublicUsage;
+        : getPageContextPublicShared(pageContext);
+    return pageContextPublic;
 }
 /**
  * Provide `pageContext` for universal hooks.

package/dist/shared-server-client/hooks/getHook.d.ts

@@ -1,8 +1,8 @@
 export { getHookFromPageContext };
-export { getHookFromPageContextNew };
+export { getHooksFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
-export { getHookFromPageConfigGlobalCumulative };
+export { getHooksFromPageConfigGlobalCumulative };
 export { getHook_setIsPrerenderering };
 export type { Hook };
 export type { HookLoc };
@@ -12,9 +12,9 @@ export { getHookTimeoutDefault };
 import type { PageContextConfig } from '../getPageFiles.js';
 import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../types/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
-import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
-type HookArgDefault = PageContextPrepareMinimum;
+import type { GlobalContextPublicMinimum } from '../getGlobalContextPublicShared.js';
+import type { PageContextPublicMinimum } from '../getPageContextPublicShared.js';
+type HookArgDefault = PageContextPublicMinimum;
 type Hook<HookArg = HookArgDefault> = HookLoc & {
     hookFn: HookFn<HookArg>;
     hookTimeout: HookTimeout;
@@ -30,9 +30,9 @@ type HookTimeout = {
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
 declare function getHookFromPageContext(pageContext: PageContextConfig, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
+declare function getHooksFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
-declare function getHookFromPageConfigGlobalCumulative<HookArg = GlobalContextPrepareMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
+declare function getHooksFromPageConfigGlobalCumulative<HookArg = GlobalContextPublicMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
 declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
 declare function getHook_setIsPrerenderering(): void;

package/dist/shared-server-client/hooks/getHook.js

@@ -1,8 +1,8 @@
 export { getHookFromPageContext };
-export { getHookFromPageContextNew };
+export { getHooksFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
-export { getHookFromPageConfigGlobalCumulative };
+export { getHooksFromPageConfigGlobalCumulative };
 export { getHook_setIsPrerenderering };
 // TO-DO/next-major-release: remove
 // We export for old V0.4 design which doesn't support config.hooksTimeout
@@ -10,7 +10,11 @@ export { getHookTimeoutDefault };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
-import { assert, assertUsage, checkType, isArray, isCallable, isObject } from '../utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { checkType } from '../../utils/checkType.js';
+import { isArray } from '../../utils/isArray.js';
+import { isCallable } from '../../utils/isCallable.js';
+import { isObject } from '../../utils/isObject.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('hooks/getHook.ts', {});
 function getHookFromPageContext(pageContext, hookName) {
@@ -29,8 +33,8 @@ function getHookFromPageContext(pageContext, hookName) {
     assert(hookFilePath);
     return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
-// TO-DO/eventually: remove getHookFromPageContext() in favor of getHookFromPageContextNew()
-function getHookFromPageContextNew(hookName, pageContext) {
+// TO-DO/eventually: remove getHookFromPageContext() in favor of getHooksFromPageContextNew()
+function getHooksFromPageContextNew(hookName, pageContext) {
     const { hooksTimeout } = pageContext.config;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
     const hooks = [];
@@ -67,7 +71,7 @@ function getHookFromPageConfigGlobal(pageConfigGlobal, hookName) {
     const hookTimeout = getHookTimeoutGlobal(hookName);
     return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
-function getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName) {
+function getHooksFromPageConfigGlobalCumulative(pageConfigGlobal, hookName) {
     const configValue = pageConfigGlobal.configValues[hookName];
     if (!configValue?.value)
         return [];

package/dist/shared-server-client/modifyUrl.js

@@ -1,6 +1,6 @@
 export { modifyUrl };
 import { modifyUrlSameOrigin } from './modifyUrlSameOrigin.js';
-import { createUrlFromComponents, parseUrl } from './utils.js';
+import { parseUrl, createUrlFromComponents } from '../utils/parseUrl.js';
 /**
  * Modify a URL.
  *

package/dist/shared-server-client/modifyUrlSameOrigin.js

@@ -1,7 +1,9 @@
 export { modifyUrlSameOrigin };
 // We don't move modifyUrlSameOrigin() to the modifyUrl.ts file because we plan to use modifyUrlSameOrigin() on the client-side:
 // https://github.com/vikejs/vike/blob/c5a2de5e85262771f97851767c00ac35da69c64b/packages/vike/client/runtime-client-routing/navigate.ts#L4
-import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathAbsolute, } from './utils.js';
+import { createUrlFromComponents, assertUsageUrlPathAbsolute, parseUrl } from '../utils/parseUrl.js';
+import { isNotNullish_keyVal } from '../utils/isNullish.js';
+import { objectFilter } from '../utils/objectFilter.js';
 function modifyUrlSameOrigin(url, modify) {
     const urlParsed = parseUrl(url, '/');
     // Pathname

package/dist/shared-server-client/page-configs/assertPlusFileExport.js

@@ -1,5 +1,5 @@
 export { assertPlusFileExport };
-import { assert, assertUsage, assertWarning } from '../utils.js';
+import { assert, assertUsage, assertWarning } from '../../utils/assert.js';
 import pc from '@brillout/picocolors';
 const SIDE_EXPORTS_TOLERATE = [
     // vite-plugin-solid adds `export { $$registrations }`

package/dist/shared-server-client/page-configs/findPageConfig.js

@@ -1,5 +1,5 @@
 export { findPageConfig };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 function findPageConfig(pageConfigs, pageId) {
     const result = pageConfigs.filter((p) => p.pageId === pageId);
     assert(result.length <= 1);

package/dist/shared-server-client/page-configs/getConfigDefinedAt.js

@@ -2,7 +2,9 @@ export { getConfigDefinedAt };
 export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
 export { getDefinedByString };
-import { assert, checkType, isArray } from '../utils.js';
+import { assert } from '../../utils/assert.js';
+import { checkType } from '../../utils/checkType.js';
+import { isArray } from '../../utils/isArray.js';
 import pc from '@brillout/picocolors';
 import { getExportPath } from './getExportPath.js';
 function getConfigDefinedAt(sentenceBegin, configName, definedAtData) {

package/dist/shared-server-client/page-configs/getConfigValueBuildTime.d.ts

@@ -1,5 +1,5 @@
 export { getConfigValueBuildTime };
-import { type ResolveTypeAsString } from '../utils.js';
+import type { ResolveTypeAsString } from '../../utils/hasProp.js';
 import type { PageConfigBuildTime, ConfigValue } from '../../types/PageConfig.js';
 import type { ConfigNameBuiltIn } from '../../types/Config.js';
 import { type TypeAsString } from './getConfigValueTyped.js';

package/dist/shared-server-client/page-configs/getConfigValueBuildTime.js

@@ -1,5 +1,5 @@
 export { getConfigValueBuildTime };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 import { getConfigValueTyped } from './getConfigValueTyped.js';
 assertIsNotProductionRuntime();

package/dist/shared-server-client/page-configs/getConfigValueRuntime.d.ts

@@ -1,5 +1,5 @@
 export { getConfigValueRuntime };
-import { type ResolveTypeAsString } from '../utils.js';
+import type { ResolveTypeAsString } from '../../utils/hasProp.js';
 import type { PageConfigRuntime, ConfigValue } from '../../types/PageConfig.js';
 import type { ConfigNameBuiltIn } from '../../types/Config.js';
 import { type TypeAsString } from './getConfigValueTyped.js';

package/dist/shared-server-client/page-configs/getConfigValueTyped.d.ts

@@ -1,6 +1,6 @@
 export { getConfigValueTyped };
 export type { TypeAsString };
-import { type ResolveTypeAsString } from '../utils.js';
+import type { ResolveTypeAsString } from '../../utils/hasProp.js';
 import type { ConfigValue } from '../../types/PageConfig.js';
 import type { ConfigNameBuiltIn } from '../../types/Config.js';
 type TypeAsString = 'string' | 'boolean' | undefined;

package/dist/shared-server-client/page-configs/getConfigValueTyped.js

@@ -1,5 +1,6 @@
 export { getConfigValueTyped };
-import { assert, assertUsage, getValuePrintable } from '../utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { getValuePrintable } from '../../utils/getValuePrintable.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtOptional } from './getConfigDefinedAt.js';
 function getConfigValueTyped(configValue, configName, type) {

package/dist/shared-server-client/page-configs/getExportPath.js

@@ -1,5 +1,5 @@
 export { getExportPath };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 function getExportPath(fileExportPathToShowToUser, configName) {
     if (!fileExportPathToShowToUser)
         return null;

package/dist/shared-server-client/page-configs/helpers.js

@@ -1,7 +1,8 @@
 export { getPageConfig };
 export { getConfigValueFilePathToShowToUser };
 export { getHookFilePathToShowToUser };
-import { assert, isArray } from '../utils.js';
+import { assert } from '../../utils/assert.js';
+import { isArray } from '../../utils/isArray.js';
 function getPageConfig(pageId, pageConfigs) {
     const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
     assert(pageConfigs.length > 0);

package/dist/shared-server-client/page-configs/loadAndParseVirtualFilePageEntry.js

@@ -1,5 +1,5 @@
 export { loadAndParseVirtualFilePageEntry };
-import { objectAssign } from '../utils.js';
+import { objectAssign } from '../../utils/objectAssign.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
 import { assertVirtualFileExports } from '../assertVirtualFileExports.js';
 async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {

package/dist/shared-server-client/page-configs/resolveVikeConfigPublic.js

@@ -6,7 +6,12 @@ export { resolveGlobalContextConfig };
 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, objectDefineProperty, } from '../utils.js';
+import { assert, assertWarning, assertUsage } from '../../utils/assert.js';
+import { makeLast } from '../../utils/sorter.js';
+import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
+import { objectDefineProperty } from '../../utils/objectDefineProperty.js';
+import { isBrowser } from '../../utils/isBrowser.js';
+import { isObject } from '../../utils/isObject.js';
 import pc from '@brillout/picocolors';
 function resolveGlobalConfigPublicPage(pageConfigGlobalValues, pageConfig, pageConfigValues) {
     const pageConfigPublic_ = resolvePageConfigPublic({ pageConfigGlobalValues, pageConfigValues });

package/dist/shared-server-client/page-configs/serialize/parsePageConfigsSerialized.js

@@ -1,6 +1,7 @@
 export { parsePageConfigsSerialized };
 export { parseConfigValuesSerialized };
-import { assert, assertUsage, isCallable } from '../../utils.js';
+import { assert, assertUsage } from '../../../utils/assert.js';
+import { isCallable } from '../../../utils/isCallable.js';
 import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
 import { parseTransform } from '@brillout/json-serializer/parse';
 import { assertPlusFileExport } from '../assertPlusFileExport.js';

package/dist/shared-server-client/page-configs/serialize/serializeConfigValues.js

@@ -2,7 +2,12 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assert, assertIsNotBrowser, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative, } from '../../../node/vite/utils.js';
+import { assert, assertUsage } from '../../../utils/assert.js';
+import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
+import { assertPosixPath } from '../../../utils/path.js';
+import { deepEqual } from '../../../utils/deepEqual.js';
+import { getPropAccessNotation } from '../../../utils/getPropAccessNotation.js';
+import { isImportPathRelative } from '../../../utils/isImportPath.js';
 import { parsePointerImportData } from '../../../node/vite/shared/resolveVikeConfigInternal/pointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';

package/dist/shared-server-client/route/abort.js

@@ -8,7 +8,15 @@ export { getPageContextAddendumAbort };
 export { addNewPageContextAborted };
 export { AbortRender };
 import { isUserHookError } from '../hooks/execHook.js';
-import { assert, assertInfo, assertUsage, assertUsageUrlPathAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, unique, } from './utils.js';
+import { assert, assertInfo, assertUsage, assertWarning } from '../../utils/assert.js';
+import { assertUsageUrlPathAbsolute, assertUsageUrlRedirectTarget } from '../../utils/parseUrl.js';
+import { checkType } from '../../utils/checkType.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isBrowser } from '../../utils/isBrowser.js';
+import { joinEnglish } from '../../utils/joinEnglish.js';
+import { objectAssign } from '../../utils/objectAssign.js';
+import { truncateString } from '../../utils/truncateString.js';
+import { unique } from '../../utils/unique.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.

package/dist/shared-server-client/route/deduceRouteStringFromFilesystemPath.js

@@ -1,5 +1,7 @@
 // Unit tests at ./deduceRouteStringFromFilesystemPath.spec.ts
-import { assert, higherFirst, slice } from './utils.js';
+import { assert } from '../../utils/assert.js';
+import { slice } from '../../utils/slice.js';
+import { higherFirst } from '../../utils/sorter.js';
 export { deduceRouteStringFromFilesystemPath };
 // TO-DO/next-major-release: remove this and whole filesystemRoot mechanism
 function deduceRouteStringFromFilesystemPath(pageId, filesystemRoots) {

package/dist/shared-server-client/route/execHookGuard.d.ts

@@ -1,8 +1,9 @@
 export { execHookGuard };
+import type { PageContextConfig } from '../getPageFiles.js';
 import { type PageContextExecHook } from '../hooks/execHook.js';
 import type { GlobalContextInternal } from '../createGlobalContextShared.js';
 declare function execHookGuard<PageContext extends {
     pageId: string;
 } & {
     _globalContext: GlobalContextInternal;
-} & PageContextExecHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;
+} & PageContextExecHook & PageContextConfig>(pageContext: PageContext, getPageContextPublic: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/shared-server-client/route/execHookGuard.js

@@ -1,9 +1,10 @@
 export { execHookGuard };
 import { getHookFromPageContext, getHookTimeoutDefault } from '../hooks/getHook.js';
-import { assert, assertUsage, isCallable } from './utils.js';
-import { execHookDirectSingle } from '../hooks/execHook.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { isCallable } from '../../utils/isCallable.js';
+import { execHookSingle } from '../hooks/execHook.js';
 const errIntro = 'The guard() hook defined by';
-async function execHookGuard(pageContext, prepareForPublicUsage) {
+async function execHookGuard(pageContext, getPageContextPublic) {
     let hook;
     if (pageContext._globalContext._pageFilesAll.length > 0) {
         // TO-DO/next-major-release: remove
@@ -17,7 +18,7 @@ async function execHookGuard(pageContext, prepareForPublicUsage) {
     }
     if (!hook)
         return;
-    await execHookDirectSingle(hook, pageContext, prepareForPublicUsage);
+    await execHookSingle(hook, pageContext, getPageContextPublic);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

package/dist/shared-server-client/route/execHookOnBeforeRoute.js

@@ -1,10 +1,15 @@
 export { execHookOnBeforeRoute };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlAbsolute, joinEnglish, assert, } from './utils.js';
+import { assertUsage, assertWarning, assert } from '../../utils/assert.js';
+import { assertUsageUrlAbsolute } from '../../utils/parseUrl.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isObjectWithKeys } from '../../utils/isObjectWithKeys.js';
+import { joinEnglish } from '../../utils/joinEnglish.js';
+import { objectAssign } from '../../utils/objectAssign.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
-import { execHookDirectSync } from '../hooks/execHook.js';
-import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
+import { execHookSingleSync } from '../hooks/execHook.js';
+import { getPageContextPublicShared } from '../getPageContextPublicShared.js';
 async function execHookOnBeforeRoute(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._globalContext._onBeforeRouteHook)
@@ -33,7 +38,7 @@ async function execHookOnBeforeRoute(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let { hookReturn } = execHookDirectSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
+    let { hookReturn } = execHookSingleSync(onBeforeRouteHook, pageContext._globalContext, pageContext, getPageContextPublicShared);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TO-DO/next-major-release: make execHookOnBeforeRoute() and route() sync
     hookReturn = await hookReturn;

package/dist/shared-server-client/route/index.d.ts

@@ -3,7 +3,7 @@ export type { PageContextBeforeRoute };
 export type { PageContextAfterRoute };
 export type { PageRoutes };
 export type { RouteMatches };
-import { type PageContextUrlInternal, type PageContextUrlSource } from '../getPageContextUrlComputed.js';
+import type { PageContextUrlInternal, PageContextUrlSource } from '../getPageContextUrlComputed.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
 import type { GlobalContextInternal } from '../createGlobalContextShared.js';
 type PageContextBeforeRoute = PageContextUrlInternal & {

package/dist/shared-server-client/route/index.js

@@ -5,7 +5,10 @@ import { isBrowser } from '../../utils/isBrowser.js';
 if (isBrowser()) {
     assertClientRouting();
 }
-import { assert, assertUsage, isPlainObject, objectAssign, debug } from './utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { debug } from '../../utils/debug.js';
+import { isPlainObject } from '../../utils/isPlainObject.js';
+import { objectAssign } from '../../utils/objectAssign.js';
 import { resolvePrecedence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';

package/dist/shared-server-client/route/loadPageRoutes.js

@@ -1,9 +1,12 @@
 export { loadPageRoutes };
 export { loadPageRoutesSync };
 import { isErrorPageId } from '../error-page.js';
-import { assert, assertUsage, hasProp, slice } from './utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isArray } from '../../utils/isArray.js';
+import { isCallable } from '../../utils/isCallable.js';
+import { slice } from '../../utils/slice.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
-import { isArray, isCallable } from '../utils.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';

package/dist/shared-server-client/route/resolvePrecedence.js

@@ -1,8 +1,7 @@
 export { resolvePrecedence };
 // export type { RouteMatch }
 import { analyzeRouteString } from './resolveRouteString.js';
-import { higherFirst, lowerFirst } from './utils.js';
-import { makeFirst } from './utils.js';
+import { higherFirst, lowerFirst, makeFirst } from '../../utils/sorter.js';
 import { isStaticRouteString } from './resolveRouteString.js';
 // See https://vike.dev/route-function#precedence
 function resolvePrecedence(routeMatches) {

package/dist/shared-server-client/route/resolveRoute.js

@@ -1,5 +1,5 @@
 export { resolveRoute };
-import { assertUsage } from './utils.js';
+import { assertUsage } from '../../utils/assert.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import pc from '@brillout/picocolors';
 function resolveRoute(routeString, urlPathname) {

package/dist/shared-server-client/route/resolveRouteFunction.js

@@ -2,16 +2,19 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { execHookDirectSync } from '../hooks/execHook.js';
-import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
-import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise } from './utils.js';
+import { execHookSingleSync } from '../hooks/execHook.js';
+import { getPageContextPublicShared } from '../getPageContextPublicShared.js';
+import { assert, assertUsage, assertWarning } from '../../utils/assert.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isPlainObject } from '../../utils/isPlainObject.js';
+import { isPromise } from '../../utils/isPromise.js';
 import pc from '@brillout/picocolors';
 async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
-    let { hookReturn: result } = execHookDirectSync({
+    let { hookReturn: result } = execHookSingleSync({
         hookFn: routeFunction,
         hookFilePath: routeFunctionFilePath,
         hookName: 'route',
-    }, pageContext, preparePageContextForPublicUsage);
+    }, pageContext._globalContext, pageContext, getPageContextPublicShared);
     assertSyncRouting(result, `The Route Function ${routeFunctionFilePath}`);
     // TO-DO/next-major-release: make resolveRouteFunction() and route() sync
     //* We disallow asynchronous routing, because we need to check whether a link is a Vike link in a synchronous fashion before calling ev.preventDefault() in the 'click' event listener

package/dist/shared-server-client/route/resolveRouteString.js

@@ -4,8 +4,9 @@ export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
 export { getRouteStringParameterList };
-import { assertWarning, isBrowser, escapeRegex } from '../utils.js';
-import { assert, assertUsage } from './utils.js';
+import { assertWarning, assert, assertUsage } from '../../utils/assert.js';
+import { escapeRegex } from '../../utils/escapeRegex.js';
+import { isBrowser } from '../../utils/isBrowser.js';
 import pc from '@brillout/picocolors';
 const PARAM_TOKEN_NEW = '@';
 // TO-DO/next-major-release: remove