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

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

@@ -0,0 +1,194 @@
+export { loadPageRoutes };
+import { isErrorPageId } from '../error-page.js';
+import { assert, assertUsage, hasProp, slice } from './utils.js';
+import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
+import { isCallable } from '../utils.js';
+import { getConfigDefinedAtInfo, getConfigValue, getDefinedAtString } from '../page-configs/utils.js';
+import { warnDeprecatedAllowKey } from './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 };
+}
+function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
+    const pageRoutes = [];
+    let pageIds = [...allPageIds];
+    // V1 Design
+    if (pageConfigs.length > 0) {
+        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 = getConfigValue(pageConfig, configName);
+                if (configValue) {
+                    const definedAtInfo = getConfigDefinedAtInfo(pageConfig, configName);
+                    const route = configValue.value;
+                    const definedAt = getDefinedAtString(definedAtInfo);
+                    if (typeof route === 'string') {
+                        pageRoute = {
+                            pageId,
+                            comesFromV1PageConfig,
+                            routeString: route,
+                            routeDefinedAt: definedAt,
+                            routeType: 'STRING'
+                        };
+                    }
+                    else {
+                        assert(isCallable(route));
+                        if (getConfigValue(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                            warnDeprecatedAllowKey();
+                        pageRoute = {
+                            pageId,
+                            comesFromV1PageConfig,
+                            routeFunction: route,
+                            routeDefinedAt: definedAt,
+                            routeType: 'FUNCTION'
+                        };
+                    }
+                }
+            }
+            if (!pageRoute) {
+                const { routeFilesystem } = pageConfig;
+                assert(routeFilesystem);
+                const { routeString, definedBy } = routeFilesystem;
+                assert(routeFilesystem.routeString.startsWith('/'));
+                pageRoute = {
+                    pageId,
+                    routeFilesystemDefinedBy: definedBy,
+                    comesFromV1PageConfig,
+                    routeString,
+                    routeDefinedAt: null,
+                    routeType: 'FILESYSTEM'
+                };
+            }
+            assert(pageRoute);
+            pageRoutes.push(pageRoute);
+        });
+    }
+    // Old design
+    // TODO/v1-release: remove
+    if (pageConfigs.length === 0) {
+        assert(filesystemRoots);
+        const comesFromV1PageConfig = false;
+        pageIds
+            .filter((pageId) => !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 = deduceRouteStringFromFilesystemPath(pageId, filesystemRoots);
+                assert(routeString.startsWith('/'));
+                assert(!routeString.endsWith('/') || routeString === '/');
+                pageRoutes.push({
+                    pageId,
+                    comesFromV1PageConfig,
+                    routeString,
+                    routeDefinedAt: null,
+                    routeFilesystemDefinedBy: `${pageId}.page.*`,
+                    routeType: 'FILESYSTEM'
+                });
+            }
+            else {
+                const { filePath, fileExports } = pageRouteFile;
+                assert(fileExports.default);
+                if (hasProp(fileExports, 'default', 'string')) {
+                    const routeString = fileExports.default;
+                    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 (hasProp(fileExports, 'default', 'function')) {
+                    const routeFunction = fileExports.default;
+                    {
+                        const allowKey = 'iKnowThePerformanceRisksOfAsyncRouteFunctions';
+                        if (allowKey in fileExports) {
+                            warnDeprecatedAllowKey();
+                        }
+                    }
+                    pageRoutes.push({
+                        pageId,
+                        comesFromV1PageConfig,
+                        routeFunction,
+                        routeDefinedAt: filePath,
+                        routeType: 'FUNCTION'
+                    });
+                    return;
+                }
+                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) {
+                assert(!pageConfigGlobal.onBeforeRoute.isComputed);
+                const hookFilePath = pageConfigGlobal.onBeforeRoute.definedAtInfo.filePath;
+                assert(hookFilePath);
+                assertUsage(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 }) => {
+        assert(fileExports);
+        if ('onBeforeRoute' in fileExports) {
+            assertUsage(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) {
+            assertUsage(hasProp(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);
+            assertUsage(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) {
+    assert(filePath.startsWith('/'));
+    assert(!filePath.endsWith('/'));
+    const paths = filePath.split('/');
+    const dirPath = slice(paths, 0, -1).join('/') || '/';
+    assert(dirPath.startsWith('/'));
+    assert(!dirPath.endsWith('/') || dirPath === '/');
+    return dirPath;
+}
+function removePageId(pageIds, pageId) {
+    const { length } = pageIds;
+    pageIds = pageIds.filter((id) => id !== pageId);
+    assert(pageIds.length === length - 1);
+    return pageIds;
+}

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

@@ -0,0 +1,8 @@
+export { resolvePrecendence };
+import type { RouteType } from './loadPageRoutes.js';
+type RouteMatch = {
+    precedence?: number | null;
+    routeString?: string;
+    routeType: RouteType;
+};
+declare function resolvePrecendence<T extends RouteMatch>(routeMatches: T[]): void;

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

@@ -0,0 +1,69 @@
+export { resolvePrecendence };
+// export type { RouteMatch }
+import { analyzeRouteString } from './resolveRouteString.js';
+import { higherFirst } from './utils.js';
+import { makeFirst } from './utils.js';
+import { isStaticRouteString } from './resolveRouteString.js';
+// See https://vike.dev/route-function#precedence
+function resolvePrecendence(routeMatches) {
+    // prettier-ignore
+    routeMatches
+        .sort(sortMatches)
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FUNCTION' && !!routeMatch.precedence && routeMatch.precedence < 0))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'STRING' && isStaticRouteString(routeMatch.routeString) === false))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FUNCTION' && !routeMatch.precedence))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'STRING' && isStaticRouteString(routeMatch.routeString) === true))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FILESYSTEM'))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FUNCTION' && !!routeMatch.precedence && routeMatch.precedence > 0));
+}
+// -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) => analyzeRouteString(routeString).numberOfStaticSegmentsBeginning;
+        const result = 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) => analyzeRouteString(routeString).numberOfStaticSegements;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return route with most parameter segements first
+    {
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfParameterSegments;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return catch-all routes last
+    {
+        if (analyzeRouteString(routeMatch2.routeString).isCatchAll) {
+            return -1;
+        }
+        if (analyzeRouteString(routeMatch1.routeString).isCatchAll) {
+            return 1;
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,4 @@
+export { resolveRedirects };
+export { resolveRouteStringRedirect };
+declare function resolveRedirects(redirects: Record<string, string>, urlPathname: string): null | string;
+declare function resolveRouteStringRedirect(urlSource: string, urlTarget: string, urlPathname: string): null | string;

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

@@ -0,0 +1,50 @@
+export { resolveRedirects };
+// For ./resolveRedirects.spec.ts
+export { resolveRouteStringRedirect };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assert, assertUsage } from '../utils.js';
+import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
+import pc from '@brillout/picocolors';
+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;
+}
+function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
+    assertRouteString(urlSource, `${configSrc} Invalid`);
+    assertUsage(urlTarget.startsWith('/') ||
+        urlTarget.startsWith('http://') ||
+        urlTarget.startsWith('https://') ||
+        urlTarget === '*', `${configSrc} Invalid redirection target URL ${pc.cyan(urlTarget)}: the target URL should start with ${pc.cyan('/')}, ${pc.cyan('http://')}, ${pc.cyan('https://')}, or be ${pc.cyan('*')}`);
+    assertParams(urlSource, urlTarget);
+    const match = 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);
+    });
+    assert(!urlResolved.includes('@'));
+    if (urlResolved === urlPathname)
+        return null;
+    assert(urlTarget.startsWith('/') || urlTarget.startsWith('http'));
+    return urlResolved;
+}
+function assertParams(urlSource, urlTarget) {
+    const routeSegments = urlTarget.split('/');
+    routeSegments.forEach((routeSegment) => {
+        if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
+            const segments = urlSource.split('/');
+            assertUsage(segments.includes(routeSegment), `${configSrc} The redirection source URL ${pc.cyan(urlSource)} is missing the URL parameter ${pc.cyan(routeSegment)} used by the redirection target URL ${pc.cyan(urlTarget)}`);
+        }
+    });
+}

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

@@ -0,0 +1,5 @@
+export { resolveRoute };
+declare function resolveRoute(routeString: string, urlPathname: string): {
+    match: boolean;
+    routeParams: Record<string, string>;
+};

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

@@ -0,0 +1,15 @@
+export { resolveRoute };
+import { assertUsage } from './utils.js';
+import { resolveRouteString } from './resolveRouteString.js';
+import pc from '@brillout/picocolors';
+function resolveRoute(routeString, urlPathname) {
+    const errMsg = (propName, msg = 'a non-empty string') => `[resolveRoute(routeString, urlPathname)] ${pc.cyan(propName)} should be ` + msg;
+    assertUsage(routeString, errMsg('routeString'), { showStackTrace: true });
+    assertUsage(urlPathname, errMsg('urlPathname'), { showStackTrace: true });
+    assertUsage(urlPathname.startsWith('/'), errMsg('urlPathname', 'pageContext.urlPathname'), { showStackTrace: true });
+    const result = resolveRouteString(routeString, urlPathname);
+    return {
+        match: !!result,
+        routeParams: result?.routeParams ?? {}
+    };
+}

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

@@ -0,0 +1,14 @@
+export { resolveRouteFunction };
+export { assertRouteParams };
+export { assertSyncRouting };
+export { warnDeprecatedAllowKey };
+import { PageContextUrlComputedPropsInternal } from '../addUrlComputedProps.js';
+declare function resolveRouteFunction(routeFunction: Function, pageContext: PageContextUrlComputedPropsInternal, routeDefinedAt: string): Promise<null | {
+    precedence: number | null;
+    routeParams: Record<string, string>;
+}>;
+declare function assertSyncRouting(res: unknown, errPrefix: string): void;
+declare function warnDeprecatedAllowKey(): void;
+declare function assertRouteParams<T>(result: T, errPrefix: string): asserts result is T & {
+    routeParams?: Record<string, string>;
+};

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

@@ -0,0 +1,64 @@
+export { resolveRouteFunction };
+export { assertRouteParams };
+export { assertSyncRouting };
+export { warnDeprecatedAllowKey };
+import { assertPageContextUrlComputedProps } from '../addUrlComputedProps.js';
+import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise, isStringRecord } from './utils.js';
+import pc from '@brillout/picocolors';
+async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt) {
+    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 = {};
+    }
+    assertUsage(isPlainObject(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${pc.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    if ('match' in result) {
+        const { match } = result;
+        assertUsage(typeof match === 'boolean', `The ${pc.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;
+        assertUsage(typeof precedence === 'number', `The ${pc.cyan('precedence')} value returned by the Route Function ${routeDefinedAt} should be a number.`);
+    }
+    assertRouteParams(result, `The ${pc.cyan('routeParams')} object returned by the Route Function ${routeDefinedAt} should`);
+    const routeParams = result.routeParams || {};
+    assertUsage(!('pageContext' in result), `Providing ${pc.cyan('pageContext')} in Route Functions is prohibited, see https://vike.dev/route-function#cannot-provide-pagecontext`);
+    assert(isPlainObject(routeParams));
+    Object.keys(result).forEach((key) => {
+        assertUsage(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAt} returned an object with an unknown property ${pc.cyan(key)} (the known properties are ${pc.cyan('match')}, ${pc.cyan('routeParams')}, and ${pc.cyan('precedence')})`);
+    });
+    return {
+        precedence,
+        routeParams
+    };
+}
+// 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) {
+    assertWarning(!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 });
+}
+// TODO/v1-release: remove
+function warnDeprecatedAllowKey() {
+    const allowKey = pc.cyan('iKnowThePerformanceRisksOfAsyncRouteFunctions');
+    assertWarning(false, `${allowKey} is deprecated and will be removed in the next major release`, { onlyOnce: true });
+}
+function assertRouteParams(result, errPrefix) {
+    assert(errPrefix.endsWith(' should'));
+    if (!hasProp(result, 'routeParams')) {
+        return;
+    }
+    assert(errPrefix.endsWith(' should'));
+    assertUsage(isPlainObject(result.routeParams), `${errPrefix} be a plain JavaScript object.`);
+    assertUsage(isStringRecord(result.routeParams), `${errPrefix} only hold string values.`);
+}

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

@@ -0,0 +1,17 @@
+export { resolveRouteString };
+export { getUrlFromRouteString };
+export { isStaticRouteString };
+export { analyzeRouteString };
+export { assertRouteString };
+declare function assertRouteString(routeString: string, errPrefix?: `${string}Invalid` | `${string}invalid`): void;
+declare function resolveRouteString(routeString: string, urlPathname: string): null | {
+    routeParams: Record<string, string>;
+};
+declare function getUrlFromRouteString(routeString: string): null | string;
+declare function analyzeRouteString(routeString: string): {
+    numberOfParameterSegments: number;
+    numberOfStaticSegmentsBeginning: number;
+    numberOfStaticSegements: number;
+    isCatchAll: boolean;
+};
+declare function isStaticRouteString(routeString: string): boolean;

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

@@ -0,0 +1,95 @@
+export { resolveRouteString };
+export { getUrlFromRouteString };
+export { isStaticRouteString };
+export { analyzeRouteString };
+export { assertRouteString };
+import { assertWarning, isBrowser } from '../utils.js';
+import { assert, assertUsage } from './utils.js';
+import pc from '@brillout/picocolors';
+const PARAM_TOKEN_NEW = '@';
+// TODO/v1-release: remove
+const PARAM_TOKEN_OLD = ':';
+function assertRouteString(routeString, errPrefix = 'Invalid') {
+    assert(errPrefix.endsWith('Invalid') || errPrefix.endsWith('invalid'));
+    assertUsage(routeString !== '', `${errPrefix} Route String ${highlight(routeString)} (empty string): set it to ${highlight('/')} instead`);
+    assertUsage(routeString.startsWith('/') || routeString === '*', `${errPrefix} Route String ${highlight(routeString)}: Route Strings should start with a leading slash ${highlight('/')} (or be ${highlight('*')})`);
+}
+function resolveRouteString(routeString, urlPathname) {
+    assertRouteString(routeString);
+    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)) {
+            assertWarning(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${pc.cyan(routeString)}, use ${pc.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 };
+}
+function getUrlFromRouteString(routeString) {
+    assert(routeString.startsWith('/'));
+    if (isStaticRouteString(routeString)) {
+        const url = routeString;
+        return url;
+    }
+    return null;
+}
+function assertGlob(routeString) {
+    const numberOfGlobChars = routeString.split('*').length - 1;
+    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)`);
+    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 };
+}
+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);
+    assert(match);
+    return Object.keys(match.routeParams).length === 0;
+}
+function highlight(routeString) {
+    if (isBrowser()) {
+        return `'${routeString}'`;
+    }
+    else {
+        if (routeString === '') {
+            routeString = "''";
+        }
+        return pc.cyan(routeString);
+    }
+}

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

@@ -0,0 +1 @@
+export { resolveRoute } from './resolveRoute.js';

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

@@ -0,0 +1,5 @@
+// TODO/v1-release - move:
+//   import { resolveRoute } from 'vike/routing'
+// to:
+//   import { resolveRoute } from 'vike'
+export { resolveRoute } from './resolveRoute.js';

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

@@ -0,0 +1,18 @@
+export * from '../../utils/assert.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isObjectWithKeys.js';
+export * from '../../utils/sorter.js';
+export * from '../../utils/isPromise.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/isStringRecord.js';
+export * from '../../utils/unique.js';
+export * from '../../utils/isBrowser.js';
+export * from '../../utils/parseUrl.js';
+export * from '../hooks/executeHook.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/joinEnglish.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/truncateString.js';
+export * from '../../utils/isCallable.js';

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

@@ -0,0 +1,27 @@
+// Utils needed by:
+//  - runtime of server
+//  - runtime of client (Client Routing)
+// Ensure we don't bloat runtime of Server Routing with the utils down below
+import { assertClientRouting } from '../../utils/assertRoutingType.js';
+import { isBrowser } from '../../utils/isBrowser.js';
+if (isBrowser()) {
+    assertClientRouting();
+}
+export * from '../../utils/assert.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isObjectWithKeys.js';
+export * from '../../utils/sorter.js';
+export * from '../../utils/isPromise.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/isStringRecord.js';
+export * from '../../utils/unique.js';
+export * from '../../utils/isBrowser.js';
+export * from '../../utils/parseUrl.js';
+export * from '../hooks/executeHook.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/joinEnglish.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/truncateString.js';
+export * from '../../utils/isCallable.js';

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

@@ -0,0 +1,2 @@
+export { sortPageContext };
+declare function sortPageContext(pageContext: Record<string, unknown>): void;

package/dist/esm/shared/sortPageContext.js

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