hashrouter: refactor braces impl

Author: chase-moskal

s/hashrouter/plumbing/braces.ts

@@ -11,41 +11,47 @@ export function hasher<S extends string>(spec: S): Hasher<[ParamsOf<S>]> {
 	if (!spec.startsWith("#/"))
 		throw new Error(`hash route spec must start with "#/"`)
 
-	// capture names in order
-	const names: string[] = []
-	spec.replace(/\{([^}]+)\}/g, (_m, name: string) => {
-		if (names.includes(name)) throw new Error(`route hasher spec "${spec}" has forbidden duplicate name "${name}"`)
-		names.push(name)
-		return ""
-	})
-
-	// build a regex that matches the full hash
-	const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-	const pattern = "^" + escape(spec).replace(/\\\{[^}]+\\\}/g, "([^/]+)") + "$"
-	const regex = new RegExp(pattern)
+	const specparts = spec.split("/")
+	const braceregex = /\{([^\}\/]+)\}/
 
 	function parse(hash: string): [ParamsOf<S>] | null {
-		const m = regex.exec(hash)
-		if (!m) return null
-		const obj: Record<string, string> = {}
-		for (const [index, name] of names.entries()) {
-			try { obj[name] = decodeURIComponent(m[index + 1]) }
-			catch { return null }
+		if (!hash.startsWith("#/"))
+			throw new Error(`hash must start with "#/"`)
+
+		const hashparts = hash.split("/")
+		const params: Record<string, string> = {}
+
+		if (hashparts.length !== specparts.length)
+			return null
+
+		for (const [index, specpart] of specparts.entries()) {
+			const hashpart = hashparts.at(index)
+			if (hashpart === undefined) return null
+			const bracematch = specpart.match(braceregex)
+			try {
+				if (bracematch) params[bracematch[1]] = decodeURIComponent(hashpart)
+				else if (hashpart !== specpart) return null
+			}
+			catch {
+				return null
+			}
 		}
-		return [obj as ParamsOf<S>]
+
+		return [params as ParamsOf<S>]
 	}
 
-	function make(...[obj]: [ParamsOf<S>]): string {
-		let out = spec
-		for (const name of names) {
-			const v = (obj as Record<string, string>)[name]
-			if (v == null) throw new Error(`missing param "${name}"`)
-			out = out.replace(
-				new RegExp(`\\{${name.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\\}`),
-				encodeURIComponent(v),
-			) as any
+	function make(params: ParamsOf<S>): string {
+		const get = (param: string) => {
+			const p = param as keyof typeof params
+			if (p in params) return params[p]
+			else throw new Error(`missing param "${p}"`)
 		}
-		return out
+		return specparts.map(specpart => {
+			const bracematch = specpart.match(braceregex)
+			return bracematch
+				? encodeURIComponent(get(bracematch[1]))
+				: specpart
+		}).join("/")
 	}
 
 	return {parse, make}