match constraints

Author: pcattori

packages/route-pattern/src/lib/match.ts

@@ -1,40 +1,60 @@
 import type { Node } from './ast.ts';
 import { parse } from './parse/parse.ts';
 
+type Params = Record<string, string | undefined>;
+type Constraint = (url: URL) => Params | null;
+
 export function createMatcher(sources: Array<string>) {
   const patterns = sources.map((source) => {
     const { protocol, hostname, pathname } = parse(source);
 
-    const regexs = {
-      protocol: protocol === undefined ? /.*/ : toRegExp(protocol),
-      hostname: hostname === undefined ? /.*/ : toRegExp(hostname, /[^.]*/),
-      pathname: pathname === undefined ? /^\/$/ : toRegExp(pathname, /[^/]*/),
-    };
-    return { pattern: source, regexs };
+    const protocolRE = protocol === undefined ? /^.*$/ : toRegExp(protocol);
+    const hostnameRE = hostname === undefined ? /^.*$/ : toRegExp(hostname, { param: /[^.]*/ });
+    const pathnameRE = pathname === undefined ? /^\/$/ : toRegExp(pathname, { param: /[^/]*/ });
+
+    const constraints: Array<Constraint> = [
+      (url) => (protocolRE.test(url.protocol) ? {} : null),
+      (url) => {
+        const match = hostnameRE.exec(url.hostname);
+        if (!match) return null;
+        return match.groups ?? {};
+      },
+      (url) => {
+        const match = pathnameRE.exec(url.pathname.slice(1));
+        if (!match) return null;
+        return match.groups ?? {};
+      },
+    ];
+
+    return { pattern: source, constraints };
   });
 
   const match = function (url: string | URL) {
+    if (typeof url === 'string') url = new URL(url);
+
     const matches: Array<{ pattern: string; params: Record<string, string | undefined> }> = [];
-    if (typeof url === 'string') {
-      url = new URL(url);
-    }
-    for (const { pattern, regexs } of patterns) {
-      const protocol = regexs.protocol.exec(url.protocol);
-      const hostname = regexs.hostname.exec(url.hostname);
-      const pathname = regexs.pathname.exec(url.pathname);
-      if (protocol === null || hostname === null || pathname === null) {
-        continue;
+    for (const { pattern, constraints } of patterns) {
+      let isMatch = true;
+      const params: Params = {};
+      for (const constraint of constraints) {
+        const result = constraint(url);
+        if (result === null) {
+          isMatch = false;
+          break;
+        }
+        Object.assign(params, result);
       }
-      matches.push({ pattern, params: { ...hostname.groups, ...pathname.groups } });
+      if (!isMatch) continue;
+      matches.push({ pattern, params });
     }
     return matches;
   };
   return { match };
 }
 
-export function toRegExp(part: Array<Node>, paramRegExp?: RegExp) {
-  const source = toRegExpSource(part, paramRegExp);
-  return new RegExp(source);
+export function toRegExp(part: Array<Node>, options?: { param: RegExp }) {
+  const source = toRegExpSource(part, options?.param);
+  return new RegExp('^' + source + '$');
 }
 
 function escape(text: string): string {