@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

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

@@ -1,106 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,211 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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"),
-    );
-  });
-});