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

package/dist/cjs/shared/notSerializable.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notSerializable = void 0;
+// TODO: move to ../node/runtime/html/notSerializable.ts once code is distributed as ESM
+exports.notSerializable = 'not-serializable';

package/dist/cjs/shared/page-configs/Config/PageContextConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/page-configs/Config/helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/page-configs/Config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/page-configs/PageConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/page-configs/findPageConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPageConfig = void 0;
+const utils_js_1 = require("../utils.js");
+function findPageConfig(pageConfigs, pageId) {
+    const result = pageConfigs.filter((p) => p.pageId === pageId);
+    (0, utils_js_1.assert)(result.length <= 1);
+    const pageConfig = result[0] ?? null;
+    return pageConfig;
+}
+exports.findPageConfig = findPageConfig;

package/dist/cjs/shared/page-configs/getExportPath.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExportPath = void 0;
+const utils_js_1 = require("../utils.js");
+// TODO: return null instead of 'export default'
+//  - Also return null insead of 'export *'?
+function getExportPath(fileExportPath) {
+    let prefix = '';
+    let suffix = '';
+    let [exportName, ...exportObjectPath] = fileExportPath;
+    if (!exportName)
+        return null;
+    if (exportName === '*') {
+        (0, utils_js_1.assert)(exportObjectPath.length === 0);
+        return 'export *';
+    }
+    else if (exportName === 'default') {
+        prefix = 'export default';
+    }
+    else {
+        prefix = 'export';
+        exportObjectPath = [exportName, ...exportObjectPath];
+    }
+    exportObjectPath.forEach((prop) => {
+        prefix = `${prefix} { ${prop}`;
+        suffix = ` }${suffix}`;
+    });
+    const exportPath = prefix + suffix;
+    return exportPath;
+}
+exports.getExportPath = getExportPath;

package/dist/cjs/shared/page-configs/loadPageCode.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPageCode = void 0;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function loadPageCode(pageConfig, isDev) {
+    if (pageConfig.isLoaded &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const codeFiles = await pageConfig.loadConfigValuesAll();
+    // TODO: remove?
+    // pageConfig.configValuesOld = pageConfig.configValuesOld.filter((val) => !val.definedByCodeFile)
+    const addConfigValue = (configName, value, filePath, exportName) => {
+        /* TODO
+        assert(!isAlreadyDefined(val.configName), val.configName) // Conflicts are resolved upstream
+        */
+        pageConfig.configValues[configName] = {
+            value,
+            definedAtInfo: {
+                filePath,
+                fileExportPath: [exportName]
+            }
+            /* TODO: remove?
+            definedByCodeFile: true
+            */
+        };
+        assertIsNotNull(value, configName, filePath);
+    };
+    codeFiles.forEach((codeFile) => {
+        if (codeFile.isPlusFile) {
+            const { importFileExports, importFilePath } = codeFile;
+            if (codeFile.configName !== 'client') {
+                (0, utils_js_1.assertDefaultExportUnknown)(importFileExports, importFilePath);
+            }
+            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
+                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
+                const configName = isSideExport ? exportName : codeFile.configName;
+                if (isSideExport && configName in pageConfig.configValues) {
+                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
+                    // Side-exports have the lowest priority.
+                    return;
+                }
+                addConfigValue(configName, exportValue, importFilePath, exportName);
+            });
+        }
+        else {
+            const { configName, importFilePath, importFileExportValue, importFileExportName } = codeFile;
+            addConfigValue(configName, importFileExportValue, importFilePath, importFileExportName);
+        }
+    });
+    (0, utils_js_1.objectAssign)(pageConfig, { isLoaded: true });
+    return pageConfig;
+}
+exports.loadPageCode = loadPageCode;
+function assertIsNotNull(configValue, configName, importFilePath) {
+    (0, utils_js_1.assert)(!importFilePath.includes('+config.'));
+    (0, utils_js_1.assertUsage)(configValue !== null, `Set ${picocolors_1.default.cyan(configName)} to ${picocolors_1.default.cyan('null')} in a +config.h.js file instead of ${importFilePath}`);
+}

package/dist/cjs/shared/page-configs/utils.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefinedAtString = exports.getConfigDefinedAtInfo = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getExportPath_js_1 = require("./getExportPath.js");
+// prettier-ignore
+function getConfigValue(pageConfig, configName, type) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    if (configValue === null)
+        return null;
+    const { value, definedAtInfo } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAtInfo);
+    return { value };
+}
+exports.getConfigValue = getConfigValue;
+function getConfigDefinedAtInfo(pageConfig, configName) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    // We assume the caller to have ensured that the config value exists prior to calling getConfigDefinedAtInfo()
+    (0, utils_js_1.assert)(configValue);
+    const { definedAtInfo } = configValue;
+    // definedAtInfo is available only for config values that aren't:
+    //  - computed, nor
+    //  - cumulative
+    (0, utils_js_1.assert)(definedAtInfo);
+    return definedAtInfo;
+}
+exports.getConfigDefinedAtInfo = getConfigDefinedAtInfo;
+function getConfigValueEntry(pageConfig, configName) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    const { value, definedAtInfo } = configValue;
+    // Enable users to suppress global config values by setting the local config value to null
+    if (value === null)
+        return null;
+    return { value, definedAtInfo };
+}
+function getPageConfig(pageId, pageConfigs) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    (0, utils_js_1.assert)(pageConfigs.length > 0);
+    (0, utils_js_1.assert)(pageConfig);
+    return pageConfig;
+}
+exports.getPageConfig = getPageConfig;
+function assertConfigValueType(value, type, configName, definedAtInfo) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
+    const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
+    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: is should be a ${picocolors_1.default.cyan(type)} instead`);
+}
+function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
+    let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)}`;
+    if (definedAtInfo !== null) {
+        configDefinedAt = `${configDefinedAt} defined at ${getDefinedAtString(definedAtInfo, append)}`;
+    }
+    return configDefinedAt;
+}
+exports.getConfigDefinedAtString = getConfigDefinedAtString;
+function getDefinedAtString(definedAtInfo, append) {
+    const { filePath, fileExportPath } = definedAtInfo;
+    let definedAt = filePath;
+    const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
+    if (exportPath) {
+        definedAt = `${definedAt} > ${picocolors_1.default.cyan(exportPath)}`;
+    }
+    if (append) {
+        definedAt = `${definedAt} > (${picocolors_1.default.blue(append)})`;
+    }
+    return definedAt;
+}
+exports.getDefinedAtString = getDefinedAtString;

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

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoInfiniteAbortLoop = exports.AbortRender = exports.getPageContextFromAllRewrites = exports.logAbortErrorHandled = exports.isAbortPageContext = exports.isAbortError = exports.RenderErrorPage = exports.render = exports.redirect = void 0;
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@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 = {};
+    (0, utils_js_1.objectAssign)(pageContextAbort, {
+        _abortCaller: abortCaller,
+        _abortCall: `throw redirect(${args.join(', ')})`,
+        _urlRedirect: {
+            url,
+            statusCode
+        }
+    });
+    return AbortRender(pageContextAbort);
+}
+exports.redirect = redirect;
+function render(value, abortReason) {
+    const args = [typeof value === 'number' ? String(value) : JSON.stringify(value)];
+    if (abortReason !== undefined)
+        args.push((0, utils_js_1.truncateString)(JSON.stringify(abortReason), 30, null));
+    const abortCaller = 'throw render()';
+    const abortCall = `throw render(${args.join(', ')})`;
+    return render_(value, abortReason, abortCall, abortCaller);
+}
+exports.render = render;
+function render_(value, abortReason, abortCall, abortCaller, pageContextAddendum) {
+    const pageContextAbort = {
+        abortReason,
+        _abortCaller: abortCaller,
+        _abortCall: abortCall
+    };
+    if (pageContextAddendum) {
+        (0, utils_js_1.assert)(pageContextAddendum._isLegacyRenderErrorPage === true);
+        (0, utils_js_1.objectAssign)(pageContextAbort, pageContextAddendum);
+    }
+    if (typeof value === 'string') {
+        const url = value;
+        (0, utils_js_1.objectAssign)(pageContextAbort, {
+            _urlRewrite: url
+        });
+        return AbortRender(pageContextAbort);
+    }
+    else {
+        const abortStatusCode = value;
+        assertStatusCode(value, [401, 403, 404, 410, 429, 500, 503], 'render');
+        (0, utils_js_1.objectAssign)(pageContextAbort, {
+            abortStatusCode,
+            is404: abortStatusCode === 404
+        });
+        return AbortRender(pageContextAbort);
+    }
+}
+function AbortRender(pageContextAbort) {
+    const err = new Error('AbortRender');
+    (0, utils_js_1.objectAssign)(err, { _pageContextAbort: pageContextAbort, [stamp]: true });
+    (0, utils_js_1.checkType)(err);
+    return err;
+}
+exports.AbortRender = AbortRender;
+// TODO/v1-release: remove
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+function RenderErrorPage({ pageContext = {} } = {}) {
+    (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('throw RenderErrorPage()')} is deprecated and will be removed in the next major release. Use ${picocolors_1.default.cyan('throw render()')} or ${picocolors_1.default.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';
+    }
+    (0, utils_js_1.objectAssign)(pageContext, { _isLegacyRenderErrorPage: true });
+    return render_(abortStatusCode, abortReason, 'throw RenderErrorPage()', 'throw RenderErrorPage()', pageContext);
+}
+exports.RenderErrorPage = RenderErrorPage;
+const stamp = '_isAbortError';
+function isAbortError(thing) {
+    return typeof thing === 'object' && thing !== null && stamp in thing;
+}
+exports.isAbortError = isAbortError;
+function isAbortPageContext(pageContext) {
+    if (!(pageContext._urlRewrite || pageContext._urlRedirect || pageContext.abortStatusCode)) {
+        return false;
+    }
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_abortCall', 'string'));
+    /* Isn't needed and is missing on the client-side
+    assert(hasProp(pageContext, '_abortCaller', 'string'))
+    */
+    (0, utils_js_1.checkType)(pageContext);
+    return true;
+}
+exports.isAbortPageContext = isAbortPageContext;
+function logAbortErrorHandled(err, isProduction, pageContext) {
+    if (isProduction)
+        return;
+    const urlCurrent = pageContext._urlRewrite ?? pageContext.urlOriginal;
+    (0, utils_js_1.assert)(urlCurrent);
+    const abortCall = err._pageContextAbort._abortCall;
+    (0, utils_js_1.assertInfo)(false, `${picocolors_1.default.cyan(abortCall)} intercepted while rendering ${picocolors_1.default.cyan(urlCurrent)}`, { onlyOnce: false });
+}
+exports.logAbortErrorHandled = logAbortErrorHandled;
+function assertStatusCode(statusCode, expected, caller) {
+    const expectedEnglish = (0, utils_js_1.joinEnglish)(expected.map((s) => s.toString()), 'or');
+    (0, utils_js_1.assertWarning)(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at ${utils_js_1.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;
+}
+exports.getPageContextFromAllRewrites = getPageContextFromAllRewrites;
+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(' => ');
+                (0, utils_js_1.assertUsage)(false, `Infinite loop of render() calls: ${loop}`);
+            }
+        }
+        urlRewrites.push(urlRewrite);
+    });
+}
+function assertNoInfiniteAbortLoop(rewriteCount, redirectCount) {
+    const abortCalls = [
+        // prettier-ignore
+        rewriteCount > 0 && picocolors_1.default.cyan("throw render('/some-url')"),
+        redirectCount > 0 && picocolors_1.default.cyan("throw redirect('/some-url')")
+    ]
+        .filter(Boolean)
+        .join(' and ');
+    (0, utils_js_1.assertUsage)(rewriteCount + redirectCount <= 7, `Maximum chain length of 7 ${abortCalls} exceeded. Did you define an infinite loop of ${abortCalls}?`);
+}
+exports.assertNoInfiniteAbortLoop = assertNoInfiniteAbortLoop;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+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);
+    }
+}
+exports.debug = debug;

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

@@ -0,0 +1,53 @@
+"use strict";
+// Unit tests at ./deduceRouteStringFromFilesystemPath.spec.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceRouteStringFromFilesystemPath = void 0;
+const utils_js_1 = require("./utils.js");
+// 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((0, utils_js_1.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 };
+        (0, utils_js_1.assert)(urlRoot.startsWith('/') && pageId.startsWith('/') && filesystemRoot.startsWith('/'), debugInfo);
+        (0, utils_js_1.assert)(pageId.startsWith(filesystemRoot), debugInfo);
+        if (filesystemRoot !== '/') {
+            (0, utils_js_1.assert)(!filesystemRoot.endsWith('/'), debugInfo);
+            filesystemRoute = (0, utils_js_1.slice)(pageId, filesystemRoot.length, 0);
+        }
+        else {
+            filesystemRoute = pageId;
+        }
+        (0, utils_js_1.assert)(filesystemRoute.startsWith('/'), debugInfo);
+        filesystemRoute = urlRoot + (urlRoot.endsWith('/') ? '' : '/') + (0, utils_js_1.slice)(filesystemRoute, 1, 0);
+    }
+    else {
+        filesystemRoute = pageId;
+    }
+    (0, utils_js_1.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
+    (0, utils_js_1.assert)(!filesystemRoute.includes('.page.'));
+    (0, utils_js_1.assert)(!filesystemRoute.endsWith('.'));
+    if (filesystemRoute.endsWith('/index')) {
+        filesystemRoute = (0, utils_js_1.slice)(filesystemRoute, 0, -'/index'.length);
+    }
+    if (filesystemRoute === '') {
+        filesystemRoute = '/';
+    }
+    (0, utils_js_1.assert)(filesystemRoute.startsWith('/'));
+    (0, utils_js_1.assert)(!filesystemRoute.endsWith('/') || filesystemRoute === '/');
+    return filesystemRoute;
+}
+exports.deduceRouteStringFromFilesystemPath = deduceRouteStringFromFilesystemPath;

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOnBeforeRouteHook = void 0;
+const assertPageContextProvidedByUser_js_1 = require("../assertPageContextProvidedByUser.js");
+const utils_js_1 = require("./utils.js");
+const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
+    let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
+    (0, resolveRouteFunction_js_1.assertSyncRouting)(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
+    hookReturn = await hookReturn;
+    const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
+    (0, utils_js_1.assertUsage)(hookReturn === null ||
+        hookReturn === undefined ||
+        ((0, utils_js_1.isObjectWithKeys)(hookReturn, ['pageContext']) && (0, utils_js_1.hasProp)(hookReturn, 'pageContext')), `${errPrefix} should return ${picocolors_1.default.cyan('null')}, ${picocolors_1.default.cyan('undefined')}, or a plain JavaScript object ${picocolors_1.default.cyan('{ pageContext: { /* ... */ } }')}`);
+    if (hookReturn === null || hookReturn === undefined) {
+        return null;
+    }
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(hookReturn, 'pageContext', 'object'), `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext }')} but pageContext should be a plain JavaScript object.`);
+    if ((0, utils_js_1.hasProp)(hookReturn.pageContext, '_pageId') && !(0, utils_js_1.hasProp)(hookReturn.pageContext, '_pageId', 'null')) {
+        const errPrefix2 = `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { _pageId } }')} but ${picocolors_1.default.cyan('_pageId')} should be`;
+        (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(hookReturn.pageContext, '_pageId', 'string'), `${errPrefix2} a string or null`);
+        (0, utils_js_1.assertUsage)(pageContext._allPageIds.includes(hookReturn.pageContext._pageId), `${errPrefix2} ${(0, utils_js_1.joinEnglish)(pageContext._allPageIds.map((s) => picocolors_1.default.cyan(s)), 'or')}`);
+    }
+    if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'routeParams')) {
+        (0, resolveRouteFunction_js_1.assertRouteParams)(hookReturn.pageContext, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { routeParams } }')} but routeParams should`);
+    }
+    const pageContextAddendumHook = {};
+    if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'url')) {
+        (0, utils_js_1.assertWarning)(false, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { url } }')} but ${picocolors_1.default.cyan('pageContext.url')} has been renamed to ${picocolors_1.default.cyan('pageContext.urlOriginal')}. Return ${picocolors_1.default.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 ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'urlOriginal')) {
+        (0, utils_js_1.assertUsageUrl)(hookReturn.pageContext.urlOriginal, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlOriginal } }')} but ${picocolors_1.default.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
+        (0, utils_js_1.objectAssign)(pageContextAddendumHook, { _urlOriginalPristine: pageContext.urlOriginal });
+    }
+    (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(hookReturn.pageContext, {
+        hookFilePath: onBeforeRouteHook.hookFilePath,
+        hookName: 'onBeforeRoute'
+    });
+    (0, utils_js_1.objectAssign)(pageContextAddendumHook, hookReturn.pageContext);
+    return pageContextAddendumHook;
+}
+exports.executeOnBeforeRouteHook = executeOnBeforeRouteHook;

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.route = void 0;
+// Ensure we don't bloat runtime of Server Routing
+const assertRoutingType_js_1 = require("../../utils/assertRoutingType.js");
+const isBrowser_js_1 = require("../../utils/isBrowser.js");
+if ((0, isBrowser_js_1.isBrowser)()) {
+    (0, assertRoutingType_js_1.assertClientRouting)();
+}
+const utils_js_1 = require("./utils.js");
+const addUrlComputedProps_js_1 = require("../addUrlComputedProps.js");
+const resolvePrecedence_js_1 = require("./resolvePrecedence.js");
+const resolveRouteString_js_1 = require("./resolveRouteString.js");
+const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
+const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
+const debug_js_1 = require("./debug.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function route(pageContext) {
+    (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContext);
+    (0, debug_js_1.debug)('Pages routes:', pageContext._pageRoutes);
+    const pageContextAddendum = {};
+    if (pageContext._onBeforeRouteHook) {
+        const pageContextAddendumHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext._onBeforeRouteHook, pageContext);
+        if (pageContextAddendumHook) {
+            (0, utils_js_1.objectAssign)(pageContextAddendum, pageContextAddendumHook);
+            if ((0, utils_js_1.hasProp)(pageContextAddendum, '_pageId', 'string') || (0, utils_js_1.hasProp)(pageContextAddendum, '_pageId', 'null')) {
+                // We bypass Vike's routing
+                if (!(0, utils_js_1.hasProp)(pageContextAddendum, 'routeParams')) {
+                    (0, utils_js_1.objectAssign)(pageContextAddendum, { routeParams: {} });
+                }
+                else {
+                    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextAddendum, 'routeParams', 'object'));
+                }
+                (0, utils_js_1.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.
+            (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
+        }
+    }
+    (0, utils_js_1.objectAssign)(pageContextAddendum, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    // Vike's routing
+    const allPageIds = pageContext._allPageIds;
+    (0, utils_js_1.assert)(allPageIds.length >= 0);
+    (0, utils_js_1.assertUsage)(pageContext._pageFilesAll.length > 0 || pageContext._pageConfigs.length > 0, 'No *.page.js file found. You must create at least one *.page.js file.');
+    (0, utils_js_1.assertUsage)(allPageIds.length > 0, "You must create at least one *.page.js file that isn't _default.page.*");
+    const { urlPathname } = pageContext;
+    (0, utils_js_1.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 = (0, resolveRouteString_js_1.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 = (0, resolveRouteString_js_1.resolveRouteString)(routeString, urlPathname);
+            if (match) {
+                const { routeParams } = match;
+                (0, utils_js_1.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 (0, resolveRouteFunction_js_1.resolveRouteFunction)(routeFunction, pageContext, routeDefinedAt);
+            if (match) {
+                const { routeParams, precedence } = match;
+                routeMatches.push({ pageId, precedence, routeParams, routeType });
+            }
+            return;
+        }
+        (0, utils_js_1.assert)(false);
+    }));
+    (0, resolvePrecedence_js_1.resolvePrecendence)(routeMatches);
+    const winner = routeMatches[0];
+    (0, debug_js_1.debug)(`Route matches for URL ${picocolors_1.default.cyan(urlPathname)} (in precedence order):`, routeMatches);
+    (0, utils_js_1.objectAssign)(pageContextAddendum, { _routeMatches: routeMatches });
+    if (!winner) {
+        (0, utils_js_1.objectAssign)(pageContextAddendum, {
+            _pageId: null,
+            routeParams: {}
+        });
+        return { pageContextAddendum };
+    }
+    {
+        const { routeParams } = winner;
+        (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(routeParams));
+        (0, utils_js_1.objectAssign)(pageContextAddendum, {
+            _pageId: winner.pageId,
+            routeParams: winner.routeParams
+        });
+    }
+    return { pageContextAddendum };
+}
+exports.route = route;