vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

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

@@ -0,0 +1,155 @@
+export { redirect };
+export { render };
+export { RenderErrorPage };
+export { isAbortError };
+export { isAbortPageContext };
+export { logAbortErrorHandled };
+export { getPageContextFromAllRewrites };
+export { AbortRender };
+export { assertNoInfiniteAbortLoop };
+import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, joinEnglish, objectAssign, projectInfo, truncateString } from './utils.js';
+import pc from '@brillout/picocolors';
+/**
+ * Abort the rendering of the current page, and redirect the user to another URL instead.
+ *
+ * https://vike.dev/redirect
+ *
+ * @param url The URL to redirect to.
+ * @param statusCode By default a temporary redirection (`302`) is performed. For permanent redirections (`301`), use `config.redirects` https://vike.dev/redirects instead or, alternatively, set the `statusCode` argument to `301`.
+ */
+function redirect(url, statusCode) {
+    const abortCaller = 'throw redirect()';
+    const args = [JSON.stringify(url)];
+    if (!statusCode) {
+        statusCode = 302;
+    }
+    else {
+        assertStatusCode(statusCode, [301, 302], 'redirect');
+        args.push(String(statusCode));
+    }
+    const pageContextAbort = {};
+    objectAssign(pageContextAbort, {
+        _abortCaller: abortCaller,
+        _abortCall: `throw redirect(${args.join(', ')})`,
+        _urlRedirect: {
+            url,
+            statusCode
+        }
+    });
+    return AbortRender(pageContextAbort);
+}
+function render(value, abortReason) {
+    const args = [typeof value === 'number' ? String(value) : JSON.stringify(value)];
+    if (abortReason !== undefined)
+        args.push(truncateString(JSON.stringify(abortReason), 30, null));
+    const abortCaller = 'throw render()';
+    const abortCall = `throw render(${args.join(', ')})`;
+    return render_(value, abortReason, abortCall, abortCaller);
+}
+function render_(value, abortReason, abortCall, abortCaller, pageContextAddendum) {
+    const pageContextAbort = {
+        abortReason,
+        _abortCaller: abortCaller,
+        _abortCall: abortCall
+    };
+    if (pageContextAddendum) {
+        assert(pageContextAddendum._isLegacyRenderErrorPage === true);
+        objectAssign(pageContextAbort, pageContextAddendum);
+    }
+    if (typeof value === 'string') {
+        const url = value;
+        objectAssign(pageContextAbort, {
+            _urlRewrite: url
+        });
+        return AbortRender(pageContextAbort);
+    }
+    else {
+        const abortStatusCode = value;
+        assertStatusCode(value, [401, 403, 404, 410, 429, 500, 503], 'render');
+        objectAssign(pageContextAbort, {
+            abortStatusCode,
+            is404: abortStatusCode === 404
+        });
+        return AbortRender(pageContextAbort);
+    }
+}
+function AbortRender(pageContextAbort) {
+    const err = new Error('AbortRender');
+    objectAssign(err, { _pageContextAbort: pageContextAbort, [stamp]: true });
+    checkType(err);
+    return err;
+}
+// TODO/v1-release: remove
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+function RenderErrorPage({ pageContext = {} } = {}) {
+    assertWarning(false, `${pc.cyan('throw RenderErrorPage()')} is deprecated and will be removed in the next major release. Use ${pc.cyan('throw render()')} or ${pc.cyan('throw redirect()')} instead, see https://vike.dev/render`, { onlyOnce: false });
+    let abortStatusCode = 404;
+    let abortReason = 'Page Not Found';
+    if (pageContext.is404 === false || pageContext.pageProps?.is404 === false) {
+        abortStatusCode = 500;
+        abortReason = 'Something went wrong';
+    }
+    objectAssign(pageContext, { _isLegacyRenderErrorPage: true });
+    return render_(abortStatusCode, abortReason, 'throw RenderErrorPage()', 'throw RenderErrorPage()', pageContext);
+}
+const stamp = '_isAbortError';
+function isAbortError(thing) {
+    return typeof thing === 'object' && thing !== null && stamp in thing;
+}
+function isAbortPageContext(pageContext) {
+    if (!(pageContext._urlRewrite || pageContext._urlRedirect || pageContext.abortStatusCode)) {
+        return false;
+    }
+    assert(hasProp(pageContext, '_abortCall', 'string'));
+    /* Isn't needed and is missing on the client-side
+    assert(hasProp(pageContext, '_abortCaller', 'string'))
+    */
+    checkType(pageContext);
+    return true;
+}
+function logAbortErrorHandled(err, isProduction, pageContext) {
+    if (isProduction)
+        return;
+    const urlCurrent = pageContext._urlRewrite ?? pageContext.urlOriginal;
+    assert(urlCurrent);
+    const abortCall = err._pageContextAbort._abortCall;
+    assertInfo(false, `${pc.cyan(abortCall)} intercepted while rendering ${pc.cyan(urlCurrent)}`, { onlyOnce: false });
+}
+function assertStatusCode(statusCode, expected, caller) {
+    const expectedEnglish = joinEnglish(expected.map((s) => s.toString()), 'or');
+    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at ${projectInfo.githubRepository}/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
+}
+function getPageContextFromAllRewrites(pageContextsFromRewrite) {
+    assertNoInfiniteLoop(pageContextsFromRewrite);
+    const pageContextFromAllRewrites = { _urlRewrite: null };
+    pageContextsFromRewrite.forEach((pageContextFromRewrite) => {
+        Object.assign(pageContextFromAllRewrites, pageContextFromRewrite);
+    });
+    return pageContextFromAllRewrites;
+}
+function assertNoInfiniteLoop(pageContextsFromRewrite) {
+    const urlRewrites = [];
+    pageContextsFromRewrite.forEach((pageContext) => {
+        const urlRewrite = pageContext._urlRewrite;
+        {
+            const idx = urlRewrites.indexOf(urlRewrite);
+            if (idx !== -1) {
+                const loop = [...urlRewrites.slice(idx), urlRewrite].map((url) => `render('${url}')`).join(' => ');
+                assertUsage(false, `Infinite loop of render() calls: ${loop}`);
+            }
+        }
+        urlRewrites.push(urlRewrite);
+    });
+}
+function assertNoInfiniteAbortLoop(rewriteCount, redirectCount) {
+    const abortCalls = [
+        // prettier-ignore
+        rewriteCount > 0 && pc.cyan("throw render('/some-url')"),
+        redirectCount > 0 && pc.cyan("throw redirect('/some-url')")
+    ]
+        .filter(Boolean)
+        .join(' and ');
+    assertUsage(rewriteCount + redirectCount <= 7, `Maximum chain length of 7 ${abortCalls} exceeded. Did you define an infinite loop of ${abortCalls}?`);
+}

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

@@ -0,0 +1,3 @@
+export { debug };
+import type { Debug } from '../../utils/debug.js';
+declare function debug(...args: Parameters<Debug>): void;

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

@@ -0,0 +1,11 @@
+export { debug };
+var _debug;
+function debug(...args) {
+    if (!_debug) {
+        // We use this trick instead of `import { createDebugger } from '../../utils/debug` in order to ensure that the `debug` mechanism is only loaded on the server-side
+        _debug = globalThis.__brillout_debug_createDebugger?.('vike:routing');
+    }
+    if (_debug) {
+        _debug(...args);
+    }
+}

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

@@ -0,0 +1,7 @@
+export { deduceRouteStringFromFilesystemPath };
+export type { FilesystemRoot };
+type FilesystemRoot = {
+    filesystemRoot: string;
+    urlRoot: string;
+};
+declare function deduceRouteStringFromFilesystemPath(pageId: string, filesystemRoots: FilesystemRoot[]): string;

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

@@ -0,0 +1,50 @@
+// Unit tests at ./deduceRouteStringFromFilesystemPath.spec.ts
+import { assert, higherFirst, slice } from './utils.js';
+export { deduceRouteStringFromFilesystemPath };
+// TODO/next-major-update: remove this and whole filesystemRoot mechanism
+function deduceRouteStringFromFilesystemPath(pageId, filesystemRoots) {
+    // Handle Filesystem Routing Root
+    const filesystemRootsMatch = filesystemRoots
+        .filter(({ filesystemRoot }) => pageId.startsWith(filesystemRoot))
+        .sort(higherFirst(({ filesystemRoot }) => filesystemRoot.length));
+    const fsBase = filesystemRootsMatch[0];
+    let filesystemRoute;
+    if (fsBase) {
+        // Example values:
+        //  - `{"pageId":"/pages/index","filesystemRoot":"/","urlRoot":"/client_portal"}`
+        const { filesystemRoot, urlRoot } = fsBase;
+        const debugInfo = { pageId, filesystemRoot, urlRoot };
+        assert(urlRoot.startsWith('/') && pageId.startsWith('/') && filesystemRoot.startsWith('/'), debugInfo);
+        assert(pageId.startsWith(filesystemRoot), debugInfo);
+        if (filesystemRoot !== '/') {
+            assert(!filesystemRoot.endsWith('/'), debugInfo);
+            filesystemRoute = slice(pageId, filesystemRoot.length, 0);
+        }
+        else {
+            filesystemRoute = pageId;
+        }
+        assert(filesystemRoute.startsWith('/'), debugInfo);
+        filesystemRoute = urlRoot + (urlRoot.endsWith('/') ? '' : '/') + slice(filesystemRoute, 1, 0);
+    }
+    else {
+        filesystemRoute = pageId;
+    }
+    assert(filesystemRoute.startsWith('/'));
+    // Remove `pages/`, `index/, and `src/`, directories
+    filesystemRoute = filesystemRoute
+        .split('/')
+        .filter((dir) => dir !== 'pages' && dir !== 'src' && dir !== 'index')
+        .join('/');
+    // Hanlde `/index.page.*` suffix
+    assert(!filesystemRoute.includes('.page.'));
+    assert(!filesystemRoute.endsWith('.'));
+    if (filesystemRoute.endsWith('/index')) {
+        filesystemRoute = slice(filesystemRoute, 0, -'/index'.length);
+    }
+    if (filesystemRoute === '') {
+        filesystemRoute = '/';
+    }
+    assert(filesystemRoute.startsWith('/'));
+    assert(!filesystemRoute.endsWith('/') || filesystemRoute === '/');
+    return filesystemRoute;
+}

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

@@ -0,0 +1,8 @@
+export { executeGuardHook };
+import type { PageContextExports, PageFile } from '../getPageFiles.js';
+import type { PageConfig } from '../page-configs/PageConfig.js';
+declare function executeGuardHook<T extends PageContextExports & {
+    _pageId: string;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfig[];
+}>(pageContext: T, prepareForUserConsumption: (pageConfig: T) => T | void): Promise<void>;

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

@@ -0,0 +1,37 @@
+export { executeGuardHook };
+import { getHook } from '../hooks/getHook.js';
+import { assert, assertUsage, executeHook, isCallable } from './utils.js';
+async function executeGuardHook(pageContext, prepareForUserConsumption) {
+    let hook;
+    if (pageContext._pageFilesAll.length > 0) {
+        // V0.4 design
+        assert(pageContext._pageConfigs.length === 0);
+        hook = findPageGuard(pageContext._pageId, pageContext._pageFilesAll);
+    }
+    else {
+        // V1 design
+        hook = getHook(pageContext, 'guard');
+    }
+    if (!hook)
+        return;
+    const guard = hook.hookFn;
+    let pageContextForUserConsumption = pageContext;
+    const res = prepareForUserConsumption(pageContext);
+    if (res)
+        pageContextForUserConsumption = res;
+    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), 'guard', hook.hookFilePath);
+    assertUsage(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
+}
+function findPageGuard(pageId, pageFilesAll) {
+    const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
+    if (!pageRouteFile)
+        return null;
+    const { filePath, fileExports } = pageRouteFile;
+    assert(fileExports); // loadPageRoutes() should already have been called
+    const hookFn = fileExports.guard;
+    if (!hookFn)
+        return null;
+    const hookFilePath = filePath;
+    assertUsage(isCallable(hookFn), `guard() defined by ${hookFilePath} should be a function`);
+    return { hookFn, hookName: 'guard', hookFilePath };
+}

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

@@ -0,0 +1,17 @@
+export { executeOnBeforeRouteHook };
+export type { OnBeforeRouteHook };
+type OnBeforeRouteHook = {
+    hookFilePath: string;
+    onBeforeRoute: (pageContext: {
+        urlOriginal: string;
+    } & Record<string, unknown>) => unknown;
+};
+declare function executeOnBeforeRouteHook(onBeforeRouteHook: OnBeforeRouteHook, pageContext: {
+    urlOriginal: string;
+    _allPageIds: string[];
+}): Promise<null | {
+    urlOriginal?: string;
+    _urlOriginalPristine?: string;
+    _pageId?: string | null;
+    routeParams?: Record<string, string>;
+}>;

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

@@ -0,0 +1,50 @@
+import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish } from './utils.js';
+import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
+import pc from '@brillout/picocolors';
+export { executeOnBeforeRouteHook };
+async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
+    let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
+    assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
+    hookReturn = await hookReturn;
+    const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
+    assertUsage(hookReturn === null ||
+        hookReturn === undefined ||
+        (isObjectWithKeys(hookReturn, ['pageContext']) && hasProp(hookReturn, 'pageContext')), `${errPrefix} should return ${pc.cyan('null')}, ${pc.cyan('undefined')}, or a plain JavaScript object ${pc.cyan('{ pageContext: { /* ... */ } }')}`);
+    if (hookReturn === null || hookReturn === undefined) {
+        return null;
+    }
+    assertUsage(hasProp(hookReturn, 'pageContext', 'object'), `${errPrefix} returned ${pc.cyan('{ pageContext }')} but pageContext should be a plain JavaScript object.`);
+    if (hasProp(hookReturn.pageContext, '_pageId') && !hasProp(hookReturn.pageContext, '_pageId', 'null')) {
+        const errPrefix2 = `${errPrefix} returned ${pc.cyan('{ pageContext: { _pageId } }')} but ${pc.cyan('_pageId')} should be`;
+        assertUsage(hasProp(hookReturn.pageContext, '_pageId', 'string'), `${errPrefix2} a string or null`);
+        assertUsage(pageContext._allPageIds.includes(hookReturn.pageContext._pageId), `${errPrefix2} ${joinEnglish(pageContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
+    }
+    if (hasProp(hookReturn.pageContext, 'routeParams')) {
+        assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);
+    }
+    const pageContextAddendumHook = {};
+    if (hasProp(hookReturn.pageContext, 'url')) {
+        assertWarning(false, `${errPrefix} returned ${pc.cyan('{ pageContext: { url } }')} but ${pc.cyan('pageContext.url')} has been renamed to ${pc.cyan('pageContext.urlOriginal')}. Return ${pc.cyan('{ pageContext: { urlOriginal } }')} instead. (See https://vike.dev/migration/0.4.23 for more information.)`, { onlyOnce: true });
+        hookReturn.pageContext.urlOriginal = hookReturn.pageContext.url;
+        delete hookReturn.pageContext.url;
+    }
+    if (hasProp(hookReturn.pageContext, 'urlOriginal')) {
+        assertUsageUrl(hookReturn.pageContext.urlOriginal, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlOriginal } }')} but ${pc.cyan('urlOriginal')}`);
+        // Ugly workaround: ideally urlOriginal should be immutable.
+        //  - Instead of using pageContext._urlOriginalPristine, maybe we can keep pageContext.urlOriginal immutable while re-using `pageContext._urlRewrite`.
+        //  - Or better yet we rename pageContext._urlRewrite to pageContext.urlLogical and we allow the user to override pageContext.urlLogical, and we rename pageContext.urlOriginal => `pageContext.urlReal`.
+        //    - pageContext.urlReal / pageContext.urlLogical
+        //                         VS
+        //      pageContext.urlReal / pageContext.urlModified
+        //                         VS
+        //      pageContext.urlOriginal / pageContext.urlModified
+        objectAssign(pageContextAddendumHook, { _urlOriginalPristine: pageContext.urlOriginal });
+    }
+    assertPageContextProvidedByUser(hookReturn.pageContext, {
+        hookFilePath: onBeforeRouteHook.hookFilePath,
+        hookName: 'onBeforeRoute'
+    });
+    objectAssign(pageContextAddendumHook, hookReturn.pageContext);
+    return pageContextAddendumHook;
+}

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

@@ -0,0 +1,31 @@
+export { route };
+export type { PageRoutes, PageContextForRoute, RouteMatches };
+import type { PageFile } from '../getPageFiles.js';
+import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
+import { type OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
+import type { PageRoutes, RouteType } from './loadPageRoutes.js';
+import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+type PageContextForRoute = PageContextUrlComputedPropsInternal & {
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfig[];
+    _allPageIds: string[];
+    _pageConfigGlobal: PageConfigGlobal;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: OnBeforeRouteHook | null;
+} & PageContextUrlSources;
+type RouteMatch = {
+    pageId: string;
+    routeString?: string;
+    precedence?: number | null;
+    routeType: RouteType;
+    routeParams: Record<string, string>;
+};
+type RouteMatches = 'CUSTOM_ROUTE' | RouteMatch[];
+declare function route(pageContext: PageContextForRoute): Promise<{
+    pageContextAddendum: {
+        _pageId: string | null;
+        routeParams: Record<string, string>;
+        _routingProvidedByOnBeforeRouteHook: boolean;
+        _routeMatches: RouteMatches;
+    } & Record<string, unknown>;
+}>;

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

@@ -0,0 +1,113 @@
+export { route };
+// Ensure we don't bloat runtime of Server Routing
+import { assertClientRouting } from '../../utils/assertRoutingType.js';
+import { isBrowser } from '../../utils/isBrowser.js';
+if (isBrowser()) {
+    assertClientRouting();
+}
+import { assert, assertUsage, hasProp, isPlainObject, objectAssign } from './utils.js';
+import { addUrlComputedProps } from '../addUrlComputedProps.js';
+import { resolvePrecendence } from './resolvePrecedence.js';
+import { resolveRouteString } from './resolveRouteString.js';
+import { resolveRouteFunction } from './resolveRouteFunction.js';
+import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
+import { debug } from './debug.js';
+import pc from '@brillout/picocolors';
+async function route(pageContext) {
+    addUrlComputedProps(pageContext);
+    debug('Pages routes:', pageContext._pageRoutes);
+    const pageContextAddendum = {};
+    if (pageContext._onBeforeRouteHook) {
+        const pageContextAddendumHook = await executeOnBeforeRouteHook(pageContext._onBeforeRouteHook, pageContext);
+        if (pageContextAddendumHook) {
+            objectAssign(pageContextAddendum, pageContextAddendumHook);
+            if (hasProp(pageContextAddendum, '_pageId', 'string') || hasProp(pageContextAddendum, '_pageId', 'null')) {
+                // We bypass Vike's routing
+                if (!hasProp(pageContextAddendum, 'routeParams')) {
+                    objectAssign(pageContextAddendum, { routeParams: {} });
+                }
+                else {
+                    assert(hasProp(pageContextAddendum, 'routeParams', 'object'));
+                }
+                objectAssign(pageContextAddendum, {
+                    _routingProvidedByOnBeforeRouteHook: true,
+                    _routeMatches: 'CUSTOM_ROUTE'
+                });
+                return { pageContextAddendum };
+            }
+            // We already assign so that `pageContext.urlOriginal === pageContextAddendum.urlOriginal`; enabling the `onBeforeRoute()` hook to mutate `pageContext.urlOriginal` before routing.
+            objectAssign(pageContext, pageContextAddendum);
+        }
+    }
+    objectAssign(pageContextAddendum, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    // Vike's routing
+    const allPageIds = pageContext._allPageIds;
+    assert(allPageIds.length >= 0);
+    assertUsage(pageContext._pageFilesAll.length > 0 || pageContext._pageConfigs.length > 0, 'No *.page.js file found. You must create at least one *.page.js file.');
+    assertUsage(allPageIds.length > 0, "You must create at least one *.page.js file that isn't _default.page.*");
+    const { urlPathname } = pageContext;
+    assert(urlPathname.startsWith('/'));
+    const routeMatches = [];
+    await Promise.all(pageContext._pageRoutes.map(async (pageRoute) => {
+        const { pageId, routeType } = pageRoute;
+        // Filesytem Routing
+        if (pageRoute.routeType === 'FILESYSTEM') {
+            const { routeString } = pageRoute;
+            const match = resolveRouteString(routeString, urlPathname);
+            if (match) {
+                const { routeParams } = match;
+                routeMatches.push({ pageId, routeParams, routeString, routeType });
+            }
+            return;
+        }
+        // Route String defined in `.page.route.js`
+        if (pageRoute.routeType === 'STRING') {
+            const { routeString } = pageRoute;
+            const match = resolveRouteString(routeString, urlPathname);
+            if (match) {
+                const { routeParams } = match;
+                assert(routeType === 'STRING');
+                routeMatches.push({
+                    pageId,
+                    routeString,
+                    routeParams,
+                    routeType
+                });
+            }
+            return;
+        }
+        // Route Function defined in `.page.route.js`
+        if (pageRoute.routeType === 'FUNCTION') {
+            const { routeFunction, routeDefinedAt } = pageRoute;
+            const match = await resolveRouteFunction(routeFunction, pageContext, routeDefinedAt);
+            if (match) {
+                const { routeParams, precedence } = match;
+                routeMatches.push({ pageId, precedence, routeParams, routeType });
+            }
+            return;
+        }
+        assert(false);
+    }));
+    resolvePrecendence(routeMatches);
+    const winner = routeMatches[0];
+    debug(`Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
+    objectAssign(pageContextAddendum, { _routeMatches: routeMatches });
+    if (!winner) {
+        objectAssign(pageContextAddendum, {
+            _pageId: null,
+            routeParams: {}
+        });
+        return { pageContextAddendum };
+    }
+    {
+        const { routeParams } = winner;
+        assert(isPlainObject(routeParams));
+        objectAssign(pageContextAddendum, {
+            _pageId: winner.pageId,
+            routeParams: winner.routeParams
+        });
+    }
+    return { pageContextAddendum };
+}

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

@@ -0,0 +1,29 @@
+export { loadPageRoutes };
+export type { PageRoutes };
+export type { RouteType };
+import type { PageFile } from '../getPageFiles.js';
+import type { OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
+import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+type PageRoute = {
+    pageId: string;
+    comesFromV1PageConfig: boolean;
+} & ({
+    routeString: string;
+    routeDefinedAt: null;
+    routeType: 'FILESYSTEM';
+    routeFilesystemDefinedBy: string;
+} | {
+    routeString: string;
+    routeDefinedAt: string;
+    routeType: 'STRING';
+} | {
+    routeFunction: Function;
+    routeDefinedAt: string;
+    routeType: 'FUNCTION';
+});
+type PageRoutes = PageRoute[];
+type RouteType = 'STRING' | 'FUNCTION' | 'FILESYSTEM';
+declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, allPageIds: string[]): Promise<{
+    pageRoutes: PageRoutes;
+    onBeforeRouteHook: null | OnBeforeRouteHook;
+}>;