Rebasely Beta: data may be purged

justintypescript-ultra-strict Public

Text · 87 lines · 3.6 KiB · at 9c48a39

import { Some, None, Ok, Err, type Option, type Result } from "@tsus/runtime";import { fromNullable, wrapSync } from "@tsus/runtime/boundary";export type RouteMatch = { route: string; params: Record<string, string> };export type RouteError = { kind: "invalid_route"; route: string };type Seg = { kind: "static" | "param" | "splat"; text: string };type Parsed = { route: string; segs: Seg[] };const toSeg = (p: string): Seg =>  p.startsWith(":") ? { kind: "param", text: p.slice(1) } : p.startsWith("*") ? { kind: "splat", text: p.slice(1) } : { kind: "static", text: p };const validSegs = (segs: Seg[], parts: string[]): boolean => {  const names = segs.filter((s) => s.kind !== "static").map((s) => s.text);  return (    parts.every((p) => p !== "") &&    names.every((n) => n !== "") &&    new Set(names).size === names.length &&    segs.every((s, i) => s.kind !== "splat" || i === segs.length - 1)  );};const parsePattern = (route: string): Result<Parsed, RouteError> => {  const parts = route === "/" ? [] : route.slice(1).split("/");  const segs = parts.map(toSeg);  return route.startsWith("/") && validSegs(segs, parts) ? Ok({ route, segs }) : Err({ kind: "invalid_route", route });};const parseAll = (routes: string[]): Result<Parsed[], RouteError> =>  routes.reduce(    (acc: Result<Parsed[], RouteError>, route) => acc.andThen((list) => parsePattern(route).map((p) => [...list, p])),    Ok([]),  );const decode = (s: string): Option<string> => wrapSync(decodeURIComponent)(s).ok();const matchSegs = (segs: Seg[], parts: string[], i: number, acc: Array<[string, string]>): Option<Record<string, string>> =>  match (fromNullable(segs[i])) {    None => parts.length === i ? Some(Object.fromEntries(acc)) : None,    Some(seg) => seg.kind === "splat"      ? decode(parts.slice(i).join("/")).map((v) => Object.fromEntries([...acc, [seg.text, v]]))      : matchOne(seg, fromNullable(parts[i])).andThen((entry) => matchSegs(segs, parts, i + 1, entry.length === 0 ? acc : [...acc, [entry[0], entry[1]]])),  };// Some([]) for a matching static segment, Some([name, value]) for a param.const matchOne = (seg: Seg, part: Option<string>): Option<string[]> =>  part.andThen((p) =>    seg.kind === "static" ? (p === seg.text ? Some([]) : None) : p === "" ? None : decode(p).map((v) => [seg.text, v]),  );const rank = (segs: Seg[], i: number): number =>  fromNullable(segs[i]).map((s): number => (s.kind === "static" ? 3 : s.kind === "param" ? 2 : 0)).unwrapOr(1);const compare = (a: Seg[], b: Seg[]): number => {  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {    if (rank(a, i) !== rank(b, i)) {      return rank(b, i) - rank(a, i);    }  }  return 0;};const pathParts = (path: string): string[] => {  const noQuery = path.split("?")[0];  const p = noQuery.length > 1 && noQuery.endsWith("/") ? noQuery.slice(0, -1) : noQuery;  return p === "/" ? [] : p.slice(1).split("/");};type Candidate = { route: string; segs: Seg[]; params: Record<string, string> };const best = (parsed: Parsed[], parts: string[]): Option<RouteMatch> => {  const candidates = parsed.flatMap((r): Candidate[] =>    matchSegs(r.segs, parts, 0, []).map((params) => [{ route: r.route, segs: r.segs, params }]).unwrapOr([]),  );  const winner = candidates.reduce((acc: Option<Candidate>, c) =>    match (acc) {      None => Some(c),      Some(b) => compare(c.segs, b.segs) < 0 ? Some(c) : acc,    },    None,  );  return winner.map((w) => ({ route: w.route, params: w.params }));};export const matchRoute = (routes: string[], path: string): Result<Option<RouteMatch>, RouteError> =>  parseAll(routes).map((parsed) => best(parsed, pathParts(path)));