@revealui/core 0.0.1-pre.0

package/dist/core/__tests__/resolvePrecedence/resolvePrecedence_overall.spec.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from "vitest";
+import { resolvePrecedence } from "../../router/resolvePrecedence.js";
+
+const routeFilesystemStatic = {
+	routeType: "FILESYSTEM" as const,
+	routeString: "/product/lolipop",
+};
+const routeFilesystemParam = {
+	routeType: "FILESYSTEM" as const,
+	routeString: "/product/@name",
+};
+const routeStringStatic = {
+	routeType: "STRING" as const,
+	routeString: "/product/lolipop",
+};
+const routeStringParam = {
+	routeType: "STRING" as const,
+	routeString: "/product/@name",
+};
+const routeFunction = {
+	routeType: "FUNCTION" as const,
+};
+const routeFunctionLowestPrio = {
+	routeType: "FUNCTION" as const,
+	precedence: -10,
+};
+const routeFunctionLowPrio = {
+	routeType: "FUNCTION" as const,
+	precedence: -1,
+};
+const routeFunctionHighPrio = {
+	routeType: "FUNCTION" as const,
+	precedence: 1,
+};
+const routeFunctionHighestPrio = {
+	routeType: "FUNCTION" as const,
+	precedence: 10,
+};
+
+const routeStrings = [routeStringStatic, routeStringParam];
+
+const routeFunctionsLowerPrio = [
+	routeFunction,
+	routeFunctionLowestPrio,
+	routeFunctionLowPrio,
+];
+const routeFunctions = [
+	...routeFunctionsLowerPrio,
+	routeFunctionHighPrio,
+	routeFunctionHighestPrio,
+];
+
+describe("routing - resolvePrecedence", () => {
+	it("basics", () => {
+		expect(resolve([routeFilesystemStatic])).toBe(routeFilesystemStatic);
+
+		expect(resolve([routeFilesystemParam, routeFilesystemStatic])).toBe(
+			routeFilesystemStatic,
+		);
+		expect(resolve([routeFilesystemStatic, routeFilesystemParam])).toBe(
+			routeFilesystemStatic,
+		);
+
+		expect(resolve([routeStringParam, routeStringStatic])).toBe(
+			routeStringStatic,
+		);
+		expect(resolve([routeFunction, routeStringStatic])).toBe(routeStringStatic);
+		expect(resolve([routeFunction, routeStringParam])).toBe(routeFunction);
+
+		expect(resolve([...routeFunctionsLowerPrio, ...routeStrings])).toBe(
+			routeStringStatic,
+		);
+		expect(resolve([...routeFunctionsLowerPrio, routeStringParam])).toBe(
+			routeFunction,
+		);
+		expect(resolve([routeFunctionLowPrio, routeStringParam])).toBe(
+			routeStringParam,
+		);
+
+		expect(resolve([routeFunction, routeFilesystemStatic])).toBe(
+			routeFilesystemStatic,
+		);
+		expect(resolve([routeFunctionHighPrio, routeFilesystemStatic])).toBe(
+			routeFunctionHighPrio,
+		);
+		expect(
+			resolve([
+				...routeFunctionsLowerPrio,
+				...routeStrings,
+				routeFilesystemStatic,
+			]),
+		).toBe(routeFilesystemStatic);
+
+		expect(resolve([routeFunctionHighPrio, routeFunctionLowPrio])).toBe(
+			routeFunctionHighPrio,
+		);
+		expect(
+			resolve([...routeFunctions, ...routeStrings, routeFilesystemStatic]),
+		).toBe(routeFunctionHighestPrio);
+	});
+});
+
+function resolve(routeMatches: Parameters<typeof resolvePrecedence>[0]) {
+	resolvePrecedence(routeMatches);
+	return routeMatches[0];
+}

package/dist/core/__tests__/resolvePrecedence/resolvePrecedence_route-strings.spec.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "vitest";
+import { resolvePrecedence } from "../../router/resolvePrecedence";
+import { resolveRouteString } from "../../router/resolveRouteString";
+
+describe("Route Strings Precedence", () => {
+	it("basics", () => {
+		const routes = ["/", "/about", "/about/team", "/about/@path", "/about/*"];
+		[
+			["/", "/"],
+			["/about", "/about"],
+			["/about/team", "/about/team"],
+			["/about/company", "/about/@path"],
+			["/about/some/nested/path", "/about/*"],
+		].forEach(([url, routeString]) => testUrl(url!, routeString!, routes));
+	});
+
+	it("catch-all", () => {
+		const routes = ["/", "/*", "/hello/@name"];
+		[
+			["/", "/"],
+			["/hello", "/*"],
+			["/hello/jon", "/hello/@name"],
+			["/hello/jon/snow", "/*"],
+		].forEach(([url, routeString]) => testUrl(url!, routeString!, routes));
+	});
+
+	it("advanced", () => {
+		const routes = [
+			"/",
+			"/about",
+			"/about/team",
+			"/*",
+			"/@path",
+			"/@path/@subpath",
+			"/@path/@subpath/*",
+			"/@path/*",
+			"/product/@productId",
+			"/product/@productId/review",
+			"/product/@productId/@view",
+			"/product/*",
+		];
+		[
+			["/", "/"],
+			["/about", "/about"],
+			["/about/team", "/about/team"],
+			["/hello", "/@path"],
+			["/hello/jon", "/@path/@subpath"],
+			["/hello/jon/snow", "/@path/@subpath/*"],
+			["/product/42", "/product/@productId"],
+			["/product/42/details", "/product/@productId/@view"],
+			["/product/42/review", "/product/@productId/review"],
+			["/product/42/review/too-long", "/product/*"],
+		].forEach(([url, routeString]) => testUrl(url!, routeString!, routes));
+	});
+
+	it("newspaper use case", () => {
+		const routes = [
+			"/", // homepage
+			"/*", // catch all generic pages at multiple levels
+			"/news", // news landing page
+			"/news/@page", // news paginated news results
+			"/news/@year/@slug", // news articles
+			"/news/press-releases*", // press releases landing and paginated news pages (nested in /news)
+			"/news/press-releases/@year/@slug", // press releases (nested in /news)
+		];
+		[
+			["/", "/"],
+			["/news", "/news"],
+			["/news/1", "/news/@page"],
+			["/news/2021/breaking-news", "/news/@year/@slug"],
+			["/news/press-releases", "/news/press-releases*"],
+			["/news/press-releases/1", "/news/press-releases*"],
+			[
+				"/news/press-releases/2021/new-funding",
+				"/news/press-releases/@year/@slug",
+			],
+			["/other", "/*"],
+		].forEach(([url, routeString]) => testUrl(url!, routeString!, routes));
+	});
+});
+
+function testUrl(url: string, routeString: string, routes: string[]) {
+	const route = findRoute(url, routes);
+	expect(`${url} -> ${route}`).toBe(`${url} -> ${routeString}`);
+}
+
+function findRoute(url: string, routes: string[]): string | null {
+	const candidates = routes
+		.map((routeString) => {
+			const result = resolveRouteString(routeString, url);
+			if (result === null) {
+				return null;
+			}
+			return { ...result, routeString, routeType: "STRING" as const };
+		})
+		.filter(<T>(match: T | null): match is T => match !== null);
+	resolvePrecedence(candidates);
+	return candidates[0]?.routeString || null;
+}

package/dist/core/__tests__/resolveRedirects.spec.ts

@@ -0,0 +1,132 @@
+import { resolveRouteStringRedirect } from "../renderer/page/resolveRedirects.js"
+
+import { describe, expect, it } from "vitest"
+import { stripAnsi } from "../utils/string/stripAnsi.js"
+
+describe("resolveRouteStringRedirect", () => {
+  it("basics", () => {
+    expect(resolveRouteStringRedirect("/a", "/b", "/a")).toEqual("/b")
+    expect(resolveRouteStringRedirect("/a", "/b", "/c")).toEqual(null)
+    expect(resolveRouteStringRedirect("/@id", "/b/@id", "/1")).toEqual("/b/1")
+    expect(resolveRouteStringRedirect("/@id", "/b", "/1")).toEqual("/b")
+    expect(resolveRouteStringRedirect("/@id", "/b", "/b")).toEqual(null)
+    expect(resolveRouteStringRedirect("/@a/@b", "/@b/@a", "/1/2")).toEqual(
+      "/2/1"
+    )
+  })
+  it("edge cases", () => {
+    expect(resolveRouteStringRedirect("/", "/", "/")).toEqual(null)
+    expect(resolveRouteStringRedirect("//", "/", "//")).toEqual("/")
+    expect(resolveRouteStringRedirect("//", "/", "/")).toEqual(null)
+    expect(resolveRouteStringRedirect("/@id", "/b/@id/@id", "/1")).toEqual(
+      "/b/1/1"
+    )
+    expect(resolveRouteStringRedirect("/@a/@b", "/c", "/b")).toEqual(null)
+    // https://github.com/revealjs/reveal/issues/1347
+    expect(
+      resolveRouteStringRedirect(
+        "/npm/*",
+        "https://cdn.jsdelivr.net/npm/*",
+        "/npm/@my-team/my-package"
+      )
+    ).toEqual("https://cdn.jsdelivr.net/npm/@my-team/my-package")
+    expect(resolveRouteStringRedirect("/@a", "/a/@a", "/@a")).toEqual("/a/@a")
+    expect(resolveRouteStringRedirect("/@a/@b", "/a/@a/@b", "/@b/1")).toEqual(
+      "/a/@b/1"
+    )
+  })
+  it("handles invalid redirects", () => {
+    expectErr(
+      () => resolveRouteStringRedirect("a", "b", "/"),
+      "[reveal][Wrong Usage][vite.config.js > reveal({ redirects })] Invalid Route String a: it should start with / or *"
+    )
+    expectErr(
+      () => resolveRouteStringRedirect("/a", "b", "/"),
+      "[reveal][Wrong Usage][vite.config.js > reveal({ redirects })] The URL redirection target is b but it should start with / or a protocol (http://, mailto:, ...), or be *"
+    )
+    expectErr(
+      () => resolveRouteStringRedirect("/a", "/@i", "/"),
+      "[reveal][Wrong Usage][vite.config.js > reveal({ redirects })] The redirection source URL /a is missing the URL parameter @i used by the redirection target URL /@i"
+    )
+    expectErr(
+      () => resolveRouteStringRedirect("/a", "/b/*", "/"),
+      "[reveal][Wrong Usage][vite.config.js > reveal({ redirects })] The redirection source URL /a is missing the URL parameter * used by the redirection target URL /b/*"
+    )
+    expectErr(
+      () => resolveRouteStringRedirect("/", "/*", "/"),
+      "[reveal][Wrong Usage][vite.config.js > reveal({ redirects })] The redirection source URL / is missing the URL parameter * used by the redirection target URL /*"
+    )
+    expectErr(
+      () => resolveRouteStringRedirect("/", "*", "/"),
+      "[reveal][Wrong Usage][vite.config.js > reveal({ redirects })] The redirection source URL / is missing the URL parameter * used by the redirection target URL *"
+    )
+  })
+  it("globs", () => {
+    expect(resolveRouteStringRedirect("/a/*", "/b/*", "/a/1")).toEqual("/b/1")
+    expect(resolveRouteStringRedirect("/a/*", "/b/c/*", "/a/1/2/3")).toEqual(
+      "/b/c/1/2/3"
+    )
+    expect(resolveRouteStringRedirect("/a/*", "/*", "/a/b")).toEqual("/b")
+  })
+  it("external redirects", () => {
+    expect(
+      resolveRouteStringRedirect("/a/*", "https://a.org/*", "/a/1")
+    ).toEqual("https://a.org/1")
+    expect(
+      resolveRouteStringRedirect("/a/*", "http://a.org/b/c/d/*", "/a/1/2/3")
+    ).toEqual("http://a.org/b/c/d/1/2/3")
+    expect(
+      resolveRouteStringRedirect("/a/b/c", "http://a.com", "/a/b/c")
+    ).toEqual("http://a.com")
+  })
+  it("mailto:", () => {
+    // mailto:
+    expect(
+      resolveRouteStringRedirect("/contact", "mailto:foo@bar.test", "/contact")
+    ).toEqual("mailto:foo@bar.test")
+    expect(
+      resolveRouteStringRedirect(
+        "/contact",
+        "mailto:foo@bar.test?subject=Hello",
+        "/contact"
+      )
+    ).toEqual("mailto:foo@bar.test?subject=Hello")
+  })
+  it("ipfs:", () => {
+    expect(
+      resolveRouteStringRedirect("/ipfs", "ipfs://example.com", "/ipfs")
+    ).toEqual("ipfs://example.com")
+  })
+  it("magnet:", () => {
+    expect(
+      resolveRouteStringRedirect(
+        "/magnet",
+        "magnet:?xt=urn:btih:example",
+        "/magnet"
+      )
+    ).toEqual("magnet:?xt=urn:btih:example")
+    // Real world example
+    expect(
+      resolveRouteStringRedirect(
+        "/magnet",
+        "magnet:?xt=urn:btih:3a15e1ac49683d91b20c2ffc252ea612a6c01bd7&dn=The.Empire.Strikes.Back.1980.Remastered.1080p.BluRay.DDP.7.1.x265-EDGE2020.mkv&xl=3225443573&tr=udp://tracker.opentrackr.org:1337/announce&tr=udp://tracker.torrent.eu.org:451&tr=udp://open.stealth.si:80/announce&tr=udp://tracker.openbittorrent.com:6969&tr=udp://tracker.tiny-vps.com:6969/announce&tr=udp://open.demonii.com:1337",
+        "/magnet"
+      )
+    ).toEqual(
+      "magnet:?xt=urn:btih:3a15e1ac49683d91b20c2ffc252ea612a6c01bd7&dn=The.Empire.Strikes.Back.1980.Remastered.1080p.BluRay.DDP.7.1.x265-EDGE2020.mkv&xl=3225443573&tr=udp://tracker.opentrackr.org:1337/announce&tr=udp://tracker.torrent.eu.org:451&tr=udp://open.stealth.si:80/announce&tr=udp://tracker.openbittorrent.com:6969&tr=udp://tracker.tiny-vps.com:6969/announce&tr=udp://open.demonii.com:1337"
+    )
+  })
+})
+
+function expectErr(fn: Function, errMsg: string) {
+  {
+    let err: Error | undefined
+    try {
+      fn()
+    } catch (err_) {
+      err = err_ as Error
+    }
+    expect(err).toBeTruthy()
+    expect(stripAnsi(err!.message)).toBe(errMsg)
+  }
+}

package/dist/core/__tests__/resolveRouteString.spec.ts

@@ -0,0 +1,211 @@
+import { describe, expect, it } from "vitest"
+
+import { resolveRouteString } from "../router/resolveRouteString.js"
+import { stripAnsi } from "../utils/string/stripAnsi.js"
+
+const r: typeof resolveRouteString = (a, b) => resolveRouteString(a, b)
+
+describe("resolveRouteString", () => {
+  /*
+  it('tmp', () => {
+    expect(r('/a/*', '/a')).toEqual(null)
+  })
+  return
+  //*/
+
+  it("basics", () => {
+    expect(r("/a", "/a")).toEqual({ routeParams: {} })
+    expect(r("/", "/")).toEqual({ routeParams: {} })
+    expect(r("/a/b", "/a/b")).toEqual({ routeParams: {} })
+    expect(r("/a/b/c/d", "/a/b/c/d")).toEqual({ routeParams: {} })
+    expect(r("/a", "/b")).toEqual(null)
+  })
+
+  it("parameterized routes", () => {
+    expect(r("/@p", "/a")).toEqual({ routeParams: { p: "a" } })
+    expect(r("/@p", "/a/")).toEqual({ routeParams: { p: "a" } })
+    expect(r("/@p/b", "/a/b")).toEqual({ routeParams: { p: "a" } })
+    expect(r("/c/@p/b", "/c/a/b")).toEqual({ routeParams: { p: "a" } })
+
+    expect(r("/@p", "/a/b")).toEqual(null)
+    expect(r("/@p", "/")).toEqual(null)
+    expect(r("/@p", "/@p")).toEqual({ routeParams: { p: "@p" } })
+
+    expect(r("/a/@p", "/a/b")).toEqual({ routeParams: { p: "b" } })
+    expect(r("/a/@p", "/a/b/")).toEqual({ routeParams: { p: "b" } })
+    expect(r("/a/@p", "/a/b/c/d")).toEqual(null)
+    expect(r("/a/@p", "/a/b/c")).toEqual(null)
+    expect(r("/a/@p", "/a/")).toEqual(null)
+    expect(r("/a/@p", "/a")).toEqual(null)
+    expect(r("/a/@p", "/c/b")).toEqual(null)
+    expect(r("/a/@p", "/c")).toEqual(null)
+    expect(r("/a/@p", "/c/")).toEqual(null)
+
+    expect(r("/a/b/@p", "/a/b/c")).toEqual({ routeParams: { p: "c" } })
+    expect(r("/a/b/@p", "/a/b/")).toEqual(null)
+    expect(r("/a/b/@p", "/a/b")).toEqual(null)
+    expect(r("/a/b/@p", "/a/c/")).toEqual(null)
+    expect(r("/a/b/@p", "/a/c")).toEqual(null)
+    expect(r("/a/b/@p", "/a")).toEqual(null)
+
+    expect(r("/@p1/@p2", "/a/b")).toEqual({
+      routeParams: { p1: "a", p2: "b" },
+    })
+    expect(r("/@p1/@p2", "/a/b/")).toEqual({
+      routeParams: { p1: "a", p2: "b" },
+    })
+    expect(r("/@p1/@p2", "/a/b/c/d")).toEqual(null)
+    expect(r("/@p1/@p2", "/a/b/c")).toEqual(null)
+  })
+
+  it("glob - trailing", () => {
+    expect(r("*", "/")).toEqual({ routeParams: { "*": "/" } })
+    expect(r("/*", "/")).toEqual({ routeParams: { "*": "" } })
+    expect(r("/a*", "/b")).toEqual(null)
+    expect(r("/a*", "/a")).toEqual({ routeParams: { "*": "" } })
+    expect(r("/a/*", "/a")).toEqual(null)
+    expect(r("/a/*", "/a/b")).toEqual({ routeParams: { "*": "b" } })
+    expect(r("/a/*", "/a/b/c/d")).toEqual({ routeParams: { "*": "b/c/d" } })
+    expect(r("/a/b/*", "/a/b/c/d")).toEqual({ routeParams: { "*": "c/d" } })
+    expect(r("/a/*", "/b/c")).toEqual(null)
+  })
+  // routeParams['*'] is exactly the substring that `*` matches
+  it("glob - trailing - precise routeParams['*']", () => {
+    expect(r("*", "/")).toEqual({ routeParams: { "*": "/" } })
+    expect(r("/*", "/")).toEqual({ routeParams: { "*": "" } })
+    expect(r("/*", "/a")).toEqual({ routeParams: { "*": "a" } })
+    expect(r("*", "/a")).toEqual({ routeParams: { "*": "/a" } })
+    expect(r("/*", "/a/b")).toEqual({ routeParams: { "*": "a/b" } })
+    expect(r("*", "/a/b")).toEqual({ routeParams: { "*": "/a/b" } })
+    expect(r("*", "/a/b/")).toEqual({ routeParams: { "*": "/a/b/" } })
+    expect(r("/*", "/a/b/c")).toEqual({ routeParams: { "*": "a/b/c" } })
+    expect(r("*", "/a/b/c")).toEqual({ routeParams: { "*": "/a/b/c" } })
+  })
+  it("glob - middle", () => {
+    expect(r("/a/*/c", "/a/b/c")).toEqual({ routeParams: { "*": "b" } })
+    expect(r("/a/*/c", "/a/b/d")).toEqual(null)
+    expect(r("/a/*/e", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*": "b/c/d" },
+    })
+    expect(r("/a*e", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*": "/b/c/d/" },
+    })
+  })
+  it("glob - multiple", () => {
+    expect(r("/a/*/c/*/e", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*1": "b", "*2": "d" },
+    })
+    expect(r("/a/*/c/*", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*1": "b", "*2": "d/e" },
+    })
+    expect(r("/a/*/c/*", "/a/b/c/d/e/")).toEqual({
+      routeParams: { "*1": "b", "*2": "d/e/" },
+    })
+    expect(r("*a*", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*1": "/", "*2": "/b/c/d/e" },
+    })
+    expect(r("*a*e", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*1": "/", "*2": "/b/c/d/" },
+    })
+    expect(r("*a*c", "/a/b/c/d/e")).toEqual(null)
+    expect(r("*a*c*", "/a/b/c/d/e")).toEqual({
+      routeParams: { "*1": "/", "*2": "/b/", "*3": "/d/e" },
+    })
+  })
+  it("glob - edge cases", () => {
+    expect(r("/a*b*c", "/abc")).toEqual({
+      routeParams: { "*1": "", "*2": "" },
+    })
+    expect(r("/a*b*c*", "/abc")).toEqual({
+      routeParams: { "*1": "", "*2": "", "*3": "" },
+    })
+    expect(r("*/a*b*c*", "/abc")).toEqual({
+      routeParams: { "*1": "", "*2": "", "*3": "", "*4": "" },
+    })
+  })
+  // A linear matching implementation fails with the following
+  it("glob - complex non-linear matching", () => {
+    // Only works if linear matching is greedy:
+    expect(r("*a", "/aaaa")).toEqual({ routeParams: { "*": "/aaa" } })
+    expect(r("/a*a", "/aaaa")).toEqual({ routeParams: { "*": "aa" } })
+    // A linear matching implementation cannot handle this:
+    expect(r("/a*a*b*", "/aaaaaba")).toEqual({
+      routeParams: { "*1": "aaa", "*2": "", "*3": "a" },
+    })
+    expect(r("/a*b*0*", "/aabcbc0")).toEqual({
+      routeParams: { "*1": "abc", "*2": "c", "*3": "" },
+    })
+    expect(r("/a*b*0*", "/aab0cbc")).toEqual({
+      routeParams: { "*1": "a", "*2": "", "*3": "cbc" },
+    })
+  })
+  it("glob - BurdaForward", () => {
+    // Use case 1
+    expect(r("/some/*.html", "/some/a.html")).toEqual({
+      routeParams: { "*": "a" },
+    })
+    expect(r("/some/*.html", "/some/a/b/c.html")).toEqual({
+      routeParams: { "*": "a/b/c" },
+    })
+    // Use case 2
+    expect(r("/some/route*.html", "/some/route.html")).toEqual({
+      routeParams: { "*": "" },
+    })
+    expect(r("/some/route*.html", "/some/route-a.html")).toEqual({
+      routeParams: { "*": "-a" },
+    })
+    expect(r("/some/route*.html", "/some/routea/b/c.html")).toEqual({
+      routeParams: { "*": "a/b/c" },
+    })
+  })
+
+  it("URL with trailing slash", () => {
+    expect(r("/@p", "/a/")).toEqual({ routeParams: { p: "a" } })
+    expect(r("/a/*", "/a")).toEqual(null)
+    expect(r("/a*", "/a")).toEqual({ routeParams: { "*": "" } })
+    expect(r("/news/press-releases/*", "/news/press-releases")).toEqual(null)
+    expect(r("/news/press-releases*", "/news/press-releases")).toEqual({
+      routeParams: { "*": "" },
+    })
+  })
+
+  it("special characters", () => {
+    expect(r("/@p", "/\\")).toEqual({ routeParams: { p: "\\" } })
+    expect(r("/a/@p", "/a/\\")).toEqual({ routeParams: { p: "\\" } })
+    expect(r("/a/@p", "/a/b")).toEqual({ routeParams: { p: "b" } })
+    expect(r("/a/@p", "/a\\b")).toEqual(null)
+
+    expect(r("/@p", "/!(")).toEqual({ routeParams: { p: "!(" } })
+    expect(r("/*", "/!(")).toEqual({ routeParams: { "*": "!(" } })
+    expect(r("/@p", "/¥")).toEqual({ routeParams: { p: "¥" } })
+    expect(r("/*", "/¥")).toEqual({ routeParams: { "*": "¥" } })
+  })
+
+  it("invalid route string", () => {
+    expectErr(
+      () => r("", "/a/b/c"),
+      `[reveal][Wrong Usage] Invalid Route String '' (empty string): set it to / instead`
+    )
+    expectErr(
+      () => r("a", "/a/b/c"),
+      `[reveal][Wrong Usage] Invalid Route String a: it should start with / or *`
+    )
+    expectErr(
+      () => r("/a**b", "/a/b/c"),
+      `[reveal][Wrong Usage] Invalid Route String /a**b: set it to /a*b instead`
+    )
+  })
+})
+
+function expectErr(fn: Function, errMsg: string) {
+  {
+    let err: Error | undefined
+    try {
+      fn()
+    } catch (err_) {
+      err = err_ as Error
+    }
+    expect(err).toBeTruthy()
+    expect(stripAnsi(err!.message)).toBe(errMsg)
+  }
+}

package/dist/core/__tests__/resolveUrlPathname.spec.ts

@@ -0,0 +1,22 @@
+import { expect, describe, it } from "vitest";
+import { resolveUrlPathname } from "../router/resolveUrlPathname";
+
+describe("resolveUrlPathname", () => {
+  it("basics", () => {
+    expect(resolveUrlPathname("/", {})).toEqual("/");
+    expect(resolveUrlPathname("/a", {})).toEqual("/a");
+    expect(resolveUrlPathname("/@a", { a: "1" })).toEqual("/1");
+  });
+
+  it("edge cases", () => {
+    expect(resolveUrlPathname("/@a", { a: "a" })).toEqual("/a");
+    expect(resolveUrlPathname("/@a/@b", { a: "@b", b: "1" })).toEqual("/@b/1");
+    expect(resolveUrlPathname("/@a/*", { a: "*", "*": "1" })).toEqual("/*/1");
+    expect(resolveUrlPathname("/*", { "*": "*" })).toEqual("/*");
+  });
+
+  // Not implemented yet
+  // it('multiple globs', () => {
+  //   expect(resolveUrlPathname('/*/*', { '*1': '*2', '*2': '*' })).toEqual('/*2/*')
+  // })
+});

package/dist/core/__tests__/trimWithAnsi.spec.ts

@@ -0,0 +1,40 @@
+import { expect, describe, it } from "vitest";
+import pc from "@brillout/picocolors";
+import {
+  trimWithAnsi,
+  trimWithAnsiTrailOnly,
+} from "../utils/string/trimWithAnsi";
+
+// To inspect ANSI codes:
+// ```diff
+// - expect(trimWithAnsi(pc.red('a '))).toEqual(pc.red('a'))
+// + expect(JSON.stringify(trimWithAnsi(pc.red('a ')))).toEqual(JSON.stringify(pc.red('a')))
+// ```
+
+describe("trimWithAnsi()", () => {
+  it("same as trim() without ANSI codes", () => {
+    expect(trimWithAnsi("a")).toEqual("a");
+    expect(trimWithAnsi(" a")).toEqual("a");
+    expect(trimWithAnsi("a ")).toEqual("a");
+    expect(trimWithAnsi("\na")).toEqual("a");
+    expect(trimWithAnsi("a\n")).toEqual("a");
+    expect(trimWithAnsi("  \n a \n   b \n c  \n\n")).toEqual("a \n   b \n c");
+  });
+  it("but also works with ANSI codes", () => {
+    expect(trimWithAnsi(pc.red("a"))).toEqual(pc.red("a"));
+    expect(trimWithAnsi(pc.red(" a"))).toEqual(pc.red("a"));
+    expect(trimWithAnsi(pc.red("a "))).toEqual(pc.red("a"));
+    expect(trimWithAnsi(pc.red("\na"))).toEqual(pc.red("a"));
+    expect(trimWithAnsi(pc.red("a\n"))).toEqual(pc.red("a"));
+    expect(trimWithAnsi(pc.red("  \n a \n   b \n c  \n\n"))).toEqual(
+      pc.red("a \n   b \n c"),
+    );
+  });
+  it("trimWithAnsiTrailOnly()", () => {
+    expect(trimWithAnsiTrailOnly(pc.red("\na"))).toEqual(pc.red("\na"));
+    expect(trimWithAnsiTrailOnly(pc.red("a\n"))).toEqual(pc.red("a"));
+    expect(trimWithAnsiTrailOnly(pc.red(" \n a \n b \n "))).toEqual(
+      pc.red(" \n a \n b"),
+    );
+  });
+});