vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

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

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPageRoutes = void 0;
+const error_page_js_1 = require("../error-page.js");
+const utils_js_1 = require("./utils.js");
+const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
+const utils_js_2 = require("../utils.js");
+const utils_js_3 = require("../page-configs/utils.js");
+const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
+async function loadPageRoutes(
+// TODO: remove all arguments and use GlobalContext instead
+pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
+    await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
+    const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
+    const pageRoutes = getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds);
+    return { pageRoutes, onBeforeRouteHook };
+}
+exports.loadPageRoutes = loadPageRoutes;
+function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
+    const pageRoutes = [];
+    let pageIds = [...allPageIds];
+    // V1 Design
+    if (pageConfigs.length > 0) {
+        (0, utils_js_1.assert)(filesystemRoots === null);
+        const comesFromV1PageConfig = true;
+        pageConfigs
+            .filter((p) => !p.isErrorPage)
+            .forEach((pageConfig) => {
+            const pageId = pageConfig.pageId;
+            pageIds = removePageId(pageIds, pageId);
+            let pageRoute = null;
+            {
+                const configName = 'route';
+                const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
+                if (configValue) {
+                    const definedAtInfo = (0, utils_js_3.getConfigDefinedAtInfo)(pageConfig, configName);
+                    const route = configValue.value;
+                    const definedAt = (0, utils_js_3.getDefinedAtString)(definedAtInfo);
+                    if (typeof route === 'string') {
+                        pageRoute = {
+                            pageId,
+                            comesFromV1PageConfig,
+                            routeString: route,
+                            routeDefinedAt: definedAt,
+                            routeType: 'STRING'
+                        };
+                    }
+                    else {
+                        (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
+                        if ((0, utils_js_3.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                            (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
+                        pageRoute = {
+                            pageId,
+                            comesFromV1PageConfig,
+                            routeFunction: route,
+                            routeDefinedAt: definedAt,
+                            routeType: 'FUNCTION'
+                        };
+                    }
+                }
+            }
+            if (!pageRoute) {
+                const { routeFilesystem } = pageConfig;
+                (0, utils_js_1.assert)(routeFilesystem);
+                const { routeString, definedBy } = routeFilesystem;
+                (0, utils_js_1.assert)(routeFilesystem.routeString.startsWith('/'));
+                pageRoute = {
+                    pageId,
+                    routeFilesystemDefinedBy: definedBy,
+                    comesFromV1PageConfig,
+                    routeString,
+                    routeDefinedAt: null,
+                    routeType: 'FILESYSTEM'
+                };
+            }
+            (0, utils_js_1.assert)(pageRoute);
+            pageRoutes.push(pageRoute);
+        });
+    }
+    // Old design
+    // TODO/v1-release: remove
+    if (pageConfigs.length === 0) {
+        (0, utils_js_1.assert)(filesystemRoots);
+        const comesFromV1PageConfig = false;
+        pageIds
+            .filter((pageId) => !(0, error_page_js_1.isErrorPageId)(pageId, false))
+            .forEach((pageId) => {
+            const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
+            if (!pageRouteFile || !('default' in pageRouteFile.fileExports)) {
+                const routeString = (0, deduceRouteStringFromFilesystemPath_js_1.deduceRouteStringFromFilesystemPath)(pageId, filesystemRoots);
+                (0, utils_js_1.assert)(routeString.startsWith('/'));
+                (0, utils_js_1.assert)(!routeString.endsWith('/') || routeString === '/');
+                pageRoutes.push({
+                    pageId,
+                    comesFromV1PageConfig,
+                    routeString,
+                    routeDefinedAt: null,
+                    routeFilesystemDefinedBy: `${pageId}.page.*`,
+                    routeType: 'FILESYSTEM'
+                });
+            }
+            else {
+                const { filePath, fileExports } = pageRouteFile;
+                (0, utils_js_1.assert)(fileExports.default);
+                if ((0, utils_js_1.hasProp)(fileExports, 'default', 'string')) {
+                    const routeString = fileExports.default;
+                    (0, utils_js_1.assertUsage)(routeString.startsWith('/'), `A Route String should start with a leading slash '/' but ${filePath} has \`export default '${routeString}'\`. Make sure to \`export default '/${routeString}'\` instead.`);
+                    pageRoutes.push({
+                        pageId,
+                        comesFromV1PageConfig,
+                        routeString,
+                        routeDefinedAt: filePath,
+                        routeType: 'STRING'
+                    });
+                    return;
+                }
+                if ((0, utils_js_1.hasProp)(fileExports, 'default', 'function')) {
+                    const routeFunction = fileExports.default;
+                    {
+                        const allowKey = 'iKnowThePerformanceRisksOfAsyncRouteFunctions';
+                        if (allowKey in fileExports) {
+                            (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
+                        }
+                    }
+                    pageRoutes.push({
+                        pageId,
+                        comesFromV1PageConfig,
+                        routeFunction,
+                        routeDefinedAt: filePath,
+                        routeType: 'FUNCTION'
+                    });
+                    return;
+                }
+                (0, utils_js_1.assertUsage)(false, `The default export of ${filePath} should be a string or a function.`);
+            }
+        });
+    }
+    return pageRoutes;
+}
+function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
+    // V1 Design
+    if (pageConfigs.length > 0) {
+        if (pageConfigGlobal.onBeforeRoute) {
+            const hookFn = pageConfigGlobal.onBeforeRoute.value;
+            if (hookFn) {
+                (0, utils_js_1.assert)(!pageConfigGlobal.onBeforeRoute.isComputed);
+                const hookFilePath = pageConfigGlobal.onBeforeRoute.definedAtInfo.filePath;
+                (0, utils_js_1.assert)(hookFilePath);
+                (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+                const onBeforeRouteHook = {
+                    hookFilePath: hookFilePath,
+                    onBeforeRoute: hookFn
+                };
+                return { onBeforeRouteHook, filesystemRoots: null };
+            }
+        }
+        return { onBeforeRouteHook: null, filesystemRoots: null };
+    }
+    // Old design
+    // TODO/v1-release: remove
+    let onBeforeRouteHook = null;
+    const filesystemRoots = [];
+    pageFilesAll
+        .filter((p) => p.fileType === '.page.route' && p.isDefaultPageFile)
+        .forEach(({ filePath, fileExports }) => {
+        (0, utils_js_1.assert)(fileExports);
+        if ('onBeforeRoute' in fileExports) {
+            (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'onBeforeRoute', 'function'), `\`export { onBeforeRoute }\` of ${filePath} should be a function.`);
+            const { onBeforeRoute } = fileExports;
+            onBeforeRouteHook = { hookFilePath: `${filePath} > \`export { onBeforeRoute }\``, onBeforeRoute };
+        }
+        if ('filesystemRoutingRoot' in fileExports) {
+            (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);
+            (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} is \`'${fileExports.filesystemRoutingRoot}'\` but it should start with a leading slash \`/\`.`);
+            filesystemRoots.push({
+                filesystemRoot: dirname(filePath),
+                urlRoot: fileExports.filesystemRoutingRoot
+            });
+        }
+    });
+    return { onBeforeRouteHook, filesystemRoots };
+}
+function dirname(filePath) {
+    (0, utils_js_1.assert)(filePath.startsWith('/'));
+    (0, utils_js_1.assert)(!filePath.endsWith('/'));
+    const paths = filePath.split('/');
+    const dirPath = (0, utils_js_1.slice)(paths, 0, -1).join('/') || '/';
+    (0, utils_js_1.assert)(dirPath.startsWith('/'));
+    (0, utils_js_1.assert)(!dirPath.endsWith('/') || dirPath === '/');
+    return dirPath;
+}
+function removePageId(pageIds, pageId) {
+    const { length } = pageIds;
+    pageIds = pageIds.filter((id) => id !== pageId);
+    (0, utils_js_1.assert)(pageIds.length === length - 1);
+    return pageIds;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePrecendence = void 0;
+// export type { RouteMatch }
+const resolveRouteString_js_1 = require("./resolveRouteString.js");
+const utils_js_1 = require("./utils.js");
+const utils_js_2 = require("./utils.js");
+const resolveRouteString_js_2 = require("./resolveRouteString.js");
+// See https://vike.dev/route-function#precedence
+function resolvePrecendence(routeMatches) {
+    // prettier-ignore
+    routeMatches
+        .sort(sortMatches)
+        .sort((0, utils_js_2.makeFirst)((routeMatch) => routeMatch.routeType === 'FUNCTION' && !!routeMatch.precedence && routeMatch.precedence < 0))
+        .sort((0, utils_js_2.makeFirst)((routeMatch) => routeMatch.routeType === 'STRING' && (0, resolveRouteString_js_2.isStaticRouteString)(routeMatch.routeString) === false))
+        .sort((0, utils_js_2.makeFirst)((routeMatch) => routeMatch.routeType === 'FUNCTION' && !routeMatch.precedence))
+        .sort((0, utils_js_2.makeFirst)((routeMatch) => routeMatch.routeType === 'STRING' && (0, resolveRouteString_js_2.isStaticRouteString)(routeMatch.routeString) === true))
+        .sort((0, utils_js_2.makeFirst)((routeMatch) => routeMatch.routeType === 'FILESYSTEM'))
+        .sort((0, utils_js_2.makeFirst)((routeMatch) => routeMatch.routeType === 'FUNCTION' && !!routeMatch.precedence && routeMatch.precedence > 0));
+}
+exports.resolvePrecendence = resolvePrecendence;
+// -1 => routeMatch1 higher precedence
+// +1 => routeMatch2 higher precedence
+function sortMatches(routeMatch1, routeMatch2) {
+    {
+        const precedence1 = routeMatch1.precedence ?? 0;
+        const precedence2 = routeMatch2.precedence ?? 0;
+        if (precedence1 !== precedence2) {
+            return precedence1 > precedence2 ? -1 : 1;
+        }
+    }
+    if (!routeMatch2.routeString) {
+        return 0;
+    }
+    if (!routeMatch1.routeString) {
+        return 0;
+    }
+    // Return route with highest number of static path segments at beginning first
+    {
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticSegmentsBeginning;
+        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return route with highest number of static path segments in total first
+    {
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticSegements;
+        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return route with most parameter segements first
+    {
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfParameterSegments;
+        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return catch-all routes last
+    {
+        if ((0, resolveRouteString_js_1.analyzeRouteString)(routeMatch2.routeString).isCatchAll) {
+            return -1;
+        }
+        if ((0, resolveRouteString_js_1.analyzeRouteString)(routeMatch1.routeString).isCatchAll) {
+            return 1;
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRouteStringRedirect = exports.resolveRedirects = void 0;
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const utils_js_1 = require("../utils.js");
+const resolveRouteString_js_1 = require("./resolveRouteString.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
+// TODO/v1-release: update
+const configSrc = '[vite.config.js > ssr({ redirects })]';
+function resolveRedirects(redirects, urlPathname) {
+    for (const [urlSource, urlTarget] of Object.entries(redirects)) {
+        const urlResolved = resolveRouteStringRedirect(urlSource, urlTarget, urlPathname);
+        if (urlResolved)
+            return urlResolved;
+    }
+    return null;
+}
+exports.resolveRedirects = resolveRedirects;
+function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
+    (0, resolveRouteString_js_1.assertRouteString)(urlSource, `${configSrc} Invalid`);
+    (0, utils_js_1.assertUsage)(urlTarget.startsWith('/') ||
+        urlTarget.startsWith('http://') ||
+        urlTarget.startsWith('https://') ||
+        urlTarget === '*', `${configSrc} Invalid redirection target URL ${picocolors_1.default.cyan(urlTarget)}: the target URL should start with ${picocolors_1.default.cyan('/')}, ${picocolors_1.default.cyan('http://')}, ${picocolors_1.default.cyan('https://')}, or be ${picocolors_1.default.cyan('*')}`);
+    assertParams(urlSource, urlTarget);
+    const match = (0, resolveRouteString_js_1.resolveRouteString)(urlSource, urlPathname);
+    if (!match)
+        return null;
+    let urlResolved = urlTarget;
+    Object.entries(match.routeParams).forEach(([key, val]) => {
+        if (key !== '*') {
+            key = `@${key}`;
+        }
+        urlResolved = urlResolved.replaceAll(key, val);
+    });
+    (0, utils_js_1.assert)(!urlResolved.includes('@'));
+    if (urlResolved === urlPathname)
+        return null;
+    (0, utils_js_1.assert)(urlTarget.startsWith('/') || urlTarget.startsWith('http'));
+    return urlResolved;
+}
+exports.resolveRouteStringRedirect = resolveRouteStringRedirect;
+function assertParams(urlSource, urlTarget) {
+    const routeSegments = urlTarget.split('/');
+    routeSegments.forEach((routeSegment) => {
+        if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
+            const segments = urlSource.split('/');
+            (0, utils_js_1.assertUsage)(segments.includes(routeSegment), `${configSrc} The redirection source URL ${picocolors_1.default.cyan(urlSource)} is missing the URL parameter ${picocolors_1.default.cyan(routeSegment)} used by the redirection target URL ${picocolors_1.default.cyan(urlTarget)}`);
+        }
+    });
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRoute = void 0;
+const utils_js_1 = require("./utils.js");
+const resolveRouteString_js_1 = require("./resolveRouteString.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function resolveRoute(routeString, urlPathname) {
+    const errMsg = (propName, msg = 'a non-empty string') => `[resolveRoute(routeString, urlPathname)] ${picocolors_1.default.cyan(propName)} should be ` + msg;
+    (0, utils_js_1.assertUsage)(routeString, errMsg('routeString'), { showStackTrace: true });
+    (0, utils_js_1.assertUsage)(urlPathname, errMsg('urlPathname'), { showStackTrace: true });
+    (0, utils_js_1.assertUsage)(urlPathname.startsWith('/'), errMsg('urlPathname', 'pageContext.urlPathname'), { showStackTrace: true });
+    const result = (0, resolveRouteString_js_1.resolveRouteString)(routeString, urlPathname);
+    return {
+        match: !!result,
+        routeParams: result?.routeParams ?? {}
+    };
+}
+exports.resolveRoute = resolveRoute;

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

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnDeprecatedAllowKey = exports.assertSyncRouting = exports.assertRouteParams = exports.resolveRouteFunction = void 0;
+const addUrlComputedProps_js_1 = require("../addUrlComputedProps.js");
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt) {
+    (0, addUrlComputedProps_js_1.assertPageContextUrlComputedProps)(pageContext);
+    let result = routeFunction(pageContext);
+    assertSyncRouting(result, `The Route Function ${routeDefinedAt}`);
+    // TODO/v1-release
+    //* 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
+    result = await result;
+    //*/
+    if (result === false) {
+        return null;
+    }
+    if (result === true) {
+        result = {};
+    }
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${picocolors_1.default.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    if ('match' in result) {
+        const { match } = result;
+        (0, utils_js_1.assertUsage)(typeof match === 'boolean', `The ${picocolors_1.default.cyan('match')} value returned by the Route Function ${routeDefinedAt} should be a boolean.`);
+        if (!match) {
+            return null;
+        }
+    }
+    let precedence = null;
+    if ('precedence' in result) {
+        precedence = result.precedence;
+        (0, utils_js_1.assertUsage)(typeof precedence === 'number', `The ${picocolors_1.default.cyan('precedence')} value returned by the Route Function ${routeDefinedAt} should be a number.`);
+    }
+    assertRouteParams(result, `The ${picocolors_1.default.cyan('routeParams')} object returned by the Route Function ${routeDefinedAt} should`);
+    const routeParams = result.routeParams || {};
+    (0, utils_js_1.assertUsage)(!('pageContext' in result), `Providing ${picocolors_1.default.cyan('pageContext')} in Route Functions is prohibited, see https://vike.dev/route-function#cannot-provide-pagecontext`);
+    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(routeParams));
+    Object.keys(result).forEach((key) => {
+        (0, utils_js_1.assertUsage)(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAt} returned an object with an unknown property ${picocolors_1.default.cyan(key)} (the known properties are ${picocolors_1.default.cyan('match')}, ${picocolors_1.default.cyan('routeParams')}, and ${picocolors_1.default.cyan('precedence')})`);
+    });
+    return {
+        precedence,
+        routeParams
+    };
+}
+exports.resolveRouteFunction = resolveRouteFunction;
+// TODO/v1-release: remove, and make routing synchronous (enabling Vike to synchronously check whether a link is a Vike link before even calling ev.preventDefault())
+function assertSyncRouting(res, errPrefix) {
+    (0, utils_js_1.assertWarning)(!(0, utils_js_1.isPromise)(res), `${errPrefix} returned a promise, but asynchronous routing is deprecated and will be removed in the next major release, see https://vike.dev/route-function#async`, { onlyOnce: true });
+}
+exports.assertSyncRouting = assertSyncRouting;
+// TODO/v1-release: remove
+function warnDeprecatedAllowKey() {
+    const allowKey = picocolors_1.default.cyan('iKnowThePerformanceRisksOfAsyncRouteFunctions');
+    (0, utils_js_1.assertWarning)(false, `${allowKey} is deprecated and will be removed in the next major release`, { onlyOnce: true });
+}
+exports.warnDeprecatedAllowKey = warnDeprecatedAllowKey;
+function assertRouteParams(result, errPrefix) {
+    (0, utils_js_1.assert)(errPrefix.endsWith(' should'));
+    if (!(0, utils_js_1.hasProp)(result, 'routeParams')) {
+        return;
+    }
+    (0, utils_js_1.assert)(errPrefix.endsWith(' should'));
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result.routeParams), `${errPrefix} be a plain JavaScript object.`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isStringRecord)(result.routeParams), `${errPrefix} only hold string values.`);
+}
+exports.assertRouteParams = assertRouteParams;

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

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRouteString = exports.analyzeRouteString = exports.isStaticRouteString = exports.getUrlFromRouteString = exports.resolveRouteString = void 0;
+const utils_js_1 = require("../utils.js");
+const utils_js_2 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const PARAM_TOKEN_NEW = '@';
+// TODO/v1-release: remove
+const PARAM_TOKEN_OLD = ':';
+function assertRouteString(routeString, errPrefix = 'Invalid') {
+    (0, utils_js_2.assert)(errPrefix.endsWith('Invalid') || errPrefix.endsWith('invalid'));
+    (0, utils_js_2.assertUsage)(routeString !== '', `${errPrefix} Route String ${highlight(routeString)} (empty string): set it to ${highlight('/')} instead`);
+    (0, utils_js_2.assertUsage)(routeString.startsWith('/') || routeString === '*', `${errPrefix} Route String ${highlight(routeString)}: Route Strings should start with a leading slash ${highlight('/')} (or be ${highlight('*')})`);
+}
+exports.assertRouteString = assertRouteString;
+function resolveRouteString(routeString, urlPathname) {
+    assertRouteString(routeString);
+    (0, utils_js_2.assert)(urlPathname.startsWith('/'));
+    const routeSegments = routeString.split('/');
+    const urlSegments = urlPathname.split('/');
+    const routeParams = {};
+    assertGlob(routeString);
+    if (routeString === '*') {
+        routeString = '/*';
+    }
+    for (let i = 0; i < Math.max(routeSegments.length, urlSegments.length); i++) {
+        const routeSegment = routeSegments[i];
+        const urlSegment = urlSegments[i];
+        if (routeSegment === '*') {
+            routeParams['*'] = urlSegments.slice(Math.max(1, i)).join('/');
+            return { routeParams };
+        }
+        else if (routeSegment && isParam(routeSegment)) {
+            (0, utils_js_1.assertWarning)(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${picocolors_1.default.cyan(routeString)}, use ${picocolors_1.default.cyan(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead.`, { onlyOnce: true });
+            if (!urlSegment) {
+                return null;
+            }
+            routeParams[routeSegment.slice(1)] = urlSegment;
+        }
+        else {
+            if ((routeSegment || '') !== (urlSegment || '')) {
+                return null;
+            }
+        }
+    }
+    return { routeParams };
+}
+exports.resolveRouteString = resolveRouteString;
+function getUrlFromRouteString(routeString) {
+    (0, utils_js_2.assert)(routeString.startsWith('/'));
+    if (isStaticRouteString(routeString)) {
+        const url = routeString;
+        return url;
+    }
+    return null;
+}
+exports.getUrlFromRouteString = getUrlFromRouteString;
+function assertGlob(routeString) {
+    const numberOfGlobChars = routeString.split('*').length - 1;
+    (0, utils_js_2.assertUsage)(numberOfGlobChars <= 1, `Invalid Route String ${highlight(routeString)}: Route Strings aren't allowed to contain more than one glob ${highlight('*')} (use a Route Function instead)`);
+    (0, utils_js_2.assertUsage)(numberOfGlobChars === 0 || (numberOfGlobChars === 1 && routeString.endsWith('*')), `Invalid Route String ${highlight(routeString)}: make sure it ends with ${highlight('*')} or use a Route Function`);
+}
+function analyzeRouteString(routeString) {
+    const routeSegments = routeString.split('/').filter((routeSegment) => routeSegment !== '' && routeSegment !== '*');
+    let numberOfStaticSegmentsBeginning = 0;
+    for (const routeSegment of routeSegments) {
+        if (isParam(routeSegment)) {
+            break;
+        }
+        numberOfStaticSegmentsBeginning++;
+    }
+    const numberOfStaticSegements = routeSegments.filter((s) => !isParam(s)).length;
+    const numberOfParameterSegments = routeSegments.filter((s) => isParam(s)).length;
+    const isCatchAll = routeString.endsWith('*');
+    return { numberOfParameterSegments, numberOfStaticSegmentsBeginning, numberOfStaticSegements, isCatchAll };
+}
+exports.analyzeRouteString = analyzeRouteString;
+function isParam(routeSegment) {
+    return routeSegment.startsWith(PARAM_TOKEN_NEW) || routeSegment.startsWith(PARAM_TOKEN_OLD);
+}
+function isStaticRouteString(routeString) {
+    const url = routeString;
+    const match = resolveRouteString(routeString, url);
+    (0, utils_js_2.assert)(match);
+    return Object.keys(match.routeParams).length === 0;
+}
+exports.isStaticRouteString = isStaticRouteString;
+function highlight(routeString) {
+    if ((0, utils_js_1.isBrowser)()) {
+        return `'${routeString}'`;
+    }
+    else {
+        if (routeString === '') {
+            routeString = "''";
+        }
+        return picocolors_1.default.cyan(routeString);
+    }
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRoute = void 0;
+// TODO/v1-release - move:
+//   import { resolveRoute } from 'vike/routing'
+// to:
+//   import { resolveRoute } from 'vike'
+var resolveRoute_js_1 = require("./resolveRoute.js");
+Object.defineProperty(exports, "resolveRoute", { enumerable: true, get: function () { return resolveRoute_js_1.resolveRoute; } });

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

@@ -0,0 +1,43 @@
+"use strict";
+// Utils needed by:
+//  - runtime of server
+//  - runtime of client (Client Routing)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Ensure we don't bloat runtime of Server Routing with the utils down below
+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)();
+}
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/isObjectWithKeys.js"), exports);
+__exportStar(require("../../utils/sorter.js"), exports);
+__exportStar(require("../../utils/isPromise.js"), exports);
+__exportStar(require("../../utils/isPlainObject.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/slice.js"), exports);
+__exportStar(require("../../utils/isStringRecord.js"), exports);
+__exportStar(require("../../utils/unique.js"), exports);
+__exportStar(require("../../utils/isBrowser.js"), exports);
+__exportStar(require("../../utils/parseUrl.js"), exports);
+__exportStar(require("../hooks/executeHook.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports);
+__exportStar(require("../../utils/joinEnglish.js"), exports);
+__exportStar(require("../../utils/projectInfo.js"), exports);
+__exportStar(require("../../utils/truncateString.js"), exports);
+__exportStar(require("../../utils/isCallable.js"), exports);

package/dist/cjs/shared/sortPageContext.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortPageContext = void 0;
+const utils_js_1 = require("./utils.js");
+// Sort `pageContext` keys alphabetically, in order to make reading `console.log(pageContext)` easier
+function sortPageContext(pageContext) {
+    const entries = Object.entries(pageContext);
+    for (const key in pageContext) {
+        delete pageContext[key];
+    }
+    entries
+        .sort(([key1], [key2]) => (0, utils_js_1.compareString)(key1, key2))
+        .forEach(([key, val]) => {
+        pageContext[key] = val;
+    });
+}
+exports.sortPageContext = sortPageContext;

package/dist/cjs/shared/types.js

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

package/dist/cjs/shared/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+// Utils needed by all runtimes:
+//  - runtime of server
+//  - runtime of client (Server Routing)
+//  - runtime of client (Client Routing)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../utils/assert.js"), exports);
+__exportStar(require("../utils/parseUrl.js"), exports);
+__exportStar(require("../utils/objectAssign.js"), exports);
+__exportStar(require("../utils/isCallable.js"), exports);
+__exportStar(require("../utils/isObject.js"), exports);
+__exportStar(require("../utils/unique.js"), exports);
+__exportStar(require("../utils/slice.js"), exports);
+__exportStar(require("../utils/sorter.js"), exports);
+__exportStar(require("../utils/isBrowser.js"), exports);
+__exportStar(require("../utils/hasProp.js"), exports);
+__exportStar(require("../utils/isPlainObject.js"), exports);
+__exportStar(require("../utils/compareString.js"), exports);
+__exportStar(require("../utils/isNotNullish.js"), exports);
+__exportStar(require("../utils/stringifyStringArray.js"), exports);
+__exportStar(require("../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../utils/cast.js"), exports);
+__exportStar(require("../utils/projectInfo.js"), exports);
+__exportStar(require("../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../utils/isPromise.js"), exports);
+__exportStar(require("../utils/checkType.js"), exports);
+__exportStar(require("../utils/assertDefaultExport.js"), exports);
+__exportStar(require("../utils/objectEntries.js"), exports);
+__exportStar(require("../utils/getValuePrintable.js"), exports);

package/dist/cjs/types/index-dreprecated.js

@@ -0,0 +1,3 @@
+"use strict";
+// Same as ./index.ts but with deprecation notice.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/index.js

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

package/dist/cjs/utils/PromiseType.js

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