Remove unnecessary as Path

Author: 2chanhaeng

packages/uri-template/src/router/router.test.ts

@@ -1,5 +1,5 @@
 import { test } from "@fedify/fixture";
-import { deepEqual, equal } from "node:assert/strict";
+import { deepEqual, equal, throws } from "node:assert/strict";
 import {
   createRouterAddTest,
   createRouterBuildTest,
@@ -155,12 +155,12 @@ test("Router#register() registers all routes in one call", async (t) => {
   });
 
   await t.step("matches routes equivalently to repeated add()", () => {
-    deepEqual(router.route("/users/42" as Path), {
+    deepEqual(router.route("/users/42"), {
       name: "user",
       template: "/users/{id}",
       values: { id: "42" },
     });
-    deepEqual(router.route("/users/42/posts/7" as Path), {
+    deepEqual(router.route("/users/42/posts/7"), {
       name: "userPost",
       template: "/users/{id}/posts/{postId}",
       values: { id: "42", postId: "7" },
@@ -173,8 +173,8 @@ test("Router#register() registers all routes in one call", async (t) => {
       reference.add(path, name);
     }
     deepEqual(
-      router.route("/users/42" as Path),
-      reference.route("/users/42" as Path),
+      router.route("/users/42"),
+      reference.route("/users/42"),
     );
   });
 
@@ -189,13 +189,13 @@ test("Router#register() registers all routes in one call", async (t) => {
 });
 
 test("Router accepts pre-parsed RouterPathPattern", async (t) => {
-  const pattern = Router.compile("/items/{id}" as Path);
+  const pattern = Router.compile("/items/{id}");
 
   await t.step("via add()", () => {
     const router = new Router();
     router.add(pattern, "item");
     equal(router.has("item"), true);
-    deepEqual(router.route("/items/9" as Path), {
+    deepEqual(router.route("/items/9"), {
       name: "item",
       template: "/items/{id}",
       values: { id: "9" },
@@ -262,11 +262,11 @@ test("Router constructor argument variants", async (t) => {
 test("Router treats re-registration as replacement", async (t) => {
   await t.step("add() replaces a previous add() with the same name", () => {
     const router = new Router();
-    router.add("/old/{id}" as Path, "user");
-    router.add("/new/{id}" as Path, "user");
+    router.add("/old/{id}", "user");
+    router.add("/new/{id}", "user");
 
-    equal(router.route("/old/1" as Path), null);
-    deepEqual(router.route("/new/1" as Path), {
+    equal(router.route("/old/1"), null);
+    deepEqual(router.route("/new/1"), {
       name: "user",
       template: "/new/{id}",
       values: { id: "1" },
@@ -277,29 +277,29 @@ test("Router treats re-registration as replacement", async (t) => {
   await t.step("register() replaces previously registered names", () => {
     const router = new Router();
     router.register([
-      ["/a/{id}" as Path, "user"],
-      ["/b/{id}" as Path, "post"],
+      ["/a/{id}", "user"],
+      ["/b/{id}", "post"],
     ]);
     router.register([
-      ["/c/{id}" as Path, "user"],
-      ["/d/{id}" as Path, "post"],
+      ["/c/{id}", "user"],
+      ["/d/{id}", "post"],
     ]);
 
-    equal(router.route("/a/1" as Path), null);
-    equal(router.route("/b/1" as Path), null);
-    equal(router.route("/c/1" as Path)?.name, "user");
-    equal(router.route("/d/1" as Path)?.name, "post");
+    equal(router.route("/a/1"), null);
+    equal(router.route("/b/1"), null);
+    equal(router.route("/c/1")?.name, "user");
+    equal(router.route("/d/1")?.name, "post");
   });
 
   await t.step("register() de-duplicates names within a single call", () => {
     const router = new Router();
     router.register([
-      ["/a/{id}" as Path, "user"],
-      ["/b/{id}" as Path, "user"],
+      ["/a/{id}", "user"],
+      ["/b/{id}", "user"],
     ]);
 
-    equal(router.route("/a/1" as Path), null);
-    deepEqual(router.route("/b/1" as Path), {
+    equal(router.route("/a/1"), null);
+    deepEqual(router.route("/b/1"), {
       name: "user",
       template: "/b/{id}",
       values: { id: "1" },
@@ -308,23 +308,23 @@ test("Router treats re-registration as replacement", async (t) => {
 
   await t.step("constructor de-duplicates names in the input iterable", () => {
     const router = new Router([
-      ["/v1/{id}" as Path, "user"],
-      ["/v2/{id}" as Path, "user"],
+      ["/v1/{id}", "user"],
+      ["/v2/{id}", "user"],
     ]);
 
-    equal(router.route("/v1/1" as Path), null);
-    equal(router.route("/v2/1" as Path)?.name, "user");
+    equal(router.route("/v1/1"), null);
+    equal(router.route("/v2/1")?.name, "user");
   });
 
   await t.step("only the latest survives repeated re-registration", () => {
     const router = new Router();
     for (let i = 0; i < 50; i++) {
-      router.add(`/v${i}/{id}` as Path, "user");
+      router.add(`/v${i}/{id}`, "user");
     }
 
-    equal(router.route("/v0/1" as Path), null);
-    equal(router.route("/v25/1" as Path), null);
-    deepEqual(router.route("/v49/1" as Path), {
+    equal(router.route("/v0/1"), null);
+    equal(router.route("/v25/1"), null);
+    deepEqual(router.route("/v49/1"), {
       name: "user",
       template: "/v49/{id}",
       values: { id: "1" },
@@ -335,44 +335,44 @@ test("Router treats re-registration as replacement", async (t) => {
     "mixed add() / register() preserves replacement semantics",
     () => {
       const router = new Router();
-      router.add("/old-a/{id}" as Path, "a");
-      router.add("/old-b/{id}" as Path, "b");
+      router.add("/old-a/{id}", "a");
+      router.add("/old-b/{id}", "b");
       router.register([
-        ["/new-a/{id}" as Path, "a"],
-        ["/new-b/{id}" as Path, "b"],
+        ["/new-a/{id}", "a"],
+        ["/new-b/{id}", "b"],
       ]);
 
-      equal(router.route("/old-a/1" as Path), null);
-      equal(router.route("/old-b/1" as Path), null);
-      equal(router.route("/new-a/1" as Path)?.name, "a");
-      equal(router.route("/new-b/1" as Path)?.name, "b");
+      equal(router.route("/old-a/1"), null);
+      equal(router.route("/old-b/1"), null);
+      equal(router.route("/new-a/1")?.name, "a");
+      equal(router.route("/new-b/1")?.name, "b");
     },
   );
 
   await t.step("sibling routes survive re-registration of another name", () => {
     const router = new Router();
     router.register([
-      ["/users/{id}" as Path, "user"],
-      ["/posts/{id}" as Path, "post"],
+      ["/users/{id}", "user"],
+      ["/posts/{id}", "post"],
     ]);
-    router.add("/people/{id}" as Path, "user");
+    router.add("/people/{id}", "user");
 
-    equal(router.route("/users/1" as Path), null);
-    equal(router.route("/people/1" as Path)?.name, "user");
-    equal(router.route("/posts/9" as Path)?.name, "post");
+    equal(router.route("/users/1"), null);
+    equal(router.route("/people/1")?.name, "user");
+    equal(router.route("/posts/9")?.name, "post");
   });
 
   await t.step(
     "clone() after re-registration reflects only active routes",
     () => {
       const router = new Router();
-      router.add("/old/{id}" as Path, "user");
-      router.add("/new/{id}" as Path, "user");
+      router.add("/old/{id}", "user");
+      router.add("/new/{id}", "user");
 
       const cloned = router.clone();
       equal(cloned.has("user"), true);
-      equal(cloned.route("/old/1" as Path), null);
-      deepEqual(cloned.route("/new/1" as Path), {
+      equal(cloned.route("/old/1"), null);
+      deepEqual(cloned.route("/new/1"), {
         name: "user",
         template: "/new/{id}",
         values: { id: "1" },