@esmx/router 3.0.0-rc.29 → 3.0.0-rc.31

package/dist/router-guards-cleanup.test.mjs

@@ -1,437 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { Router } from "./router.mjs";
-import { RouterMode } from "./types.mjs";
-import { removeFromArray } from "./util.mjs";
-describe("Router Guards Cleanup Tests", () => {
-  let router;
-  beforeEach(async () => {
-    router = new Router({
-      mode: RouterMode.memory,
-      base: new URL("http://localhost:3000/"),
-      routes: [
-        {
-          path: "/",
-          component: () => "Home"
-        },
-        {
-          path: "/test1",
-          component: () => "Test1"
-        },
-        {
-          path: "/test2",
-          component: () => "Test2"
-        },
-        {
-          path: "/test3",
-          component: () => "Test3"
-        }
-      ]
-    });
-    await router.replace("/");
-  });
-  afterEach(() => {
-    router.destroy();
-  });
-  describe("\u{1F525} Guard Cleanup Effect Verification", () => {
-    describe("beforeEach cleanup effects", () => {
-      test("guard should not execute after cleanup", async () => {
-        const spy = vi.fn();
-        const unregister = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(1);
-      });
-      test("guard should not execute after cleanup for multiple navigations", async () => {
-        const spy = vi.fn();
-        const unregister = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        await router.push("/test2");
-        await router.push("/test3");
-        await router.push("/");
-        expect(spy).toHaveBeenCalledTimes(1);
-      });
-      test("async guard should not execute after cleanup", async () => {
-        const spy = vi.fn();
-        const asyncGuard = async (to, from) => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          spy(to, from);
-        };
-        const unregister = router.beforeEach(asyncGuard);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(1);
-      });
-    });
-    describe("afterEach cleanup effects", () => {
-      test("guard should not execute after cleanup", async () => {
-        const spy = vi.fn();
-        const unregister = router.afterEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(1);
-      });
-      test("guard should not execute after cleanup for multiple navigations", async () => {
-        const spy = vi.fn();
-        const unregister = router.afterEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        await router.push("/test2");
-        await router.push("/test3");
-        await router.push("/");
-        expect(spy).toHaveBeenCalledTimes(1);
-      });
-    });
-  });
-  describe("\u26A1 Multiple Guards Independent Cleanup", () => {
-    describe("beforeEach multiple guards cleanup", () => {
-      test("cleaning single guard should not affect other guards", async () => {
-        const spy1 = vi.fn();
-        const spy2 = vi.fn();
-        const spy3 = vi.fn();
-        const unregister1 = router.beforeEach(spy1);
-        const unregister2 = router.beforeEach(spy2);
-        const unregister3 = router.beforeEach(spy3);
-        await router.push("/test1");
-        expect(spy1).toHaveBeenCalledTimes(1);
-        expect(spy2).toHaveBeenCalledTimes(1);
-        expect(spy3).toHaveBeenCalledTimes(1);
-        unregister2();
-        await router.push("/test2");
-        expect(spy1).toHaveBeenCalledTimes(2);
-        expect(spy2).toHaveBeenCalledTimes(1);
-        expect(spy3).toHaveBeenCalledTimes(2);
-        unregister1();
-        unregister3();
-      });
-      test("cleaning multiple guards should work correctly", async () => {
-        const spy1 = vi.fn();
-        const spy2 = vi.fn();
-        const spy3 = vi.fn();
-        const spy4 = vi.fn();
-        const unregister1 = router.beforeEach(spy1);
-        const unregister2 = router.beforeEach(spy2);
-        const unregister3 = router.beforeEach(spy3);
-        const unregister4 = router.beforeEach(spy4);
-        await router.push("/test1");
-        expect(spy1).toHaveBeenCalledTimes(1);
-        expect(spy2).toHaveBeenCalledTimes(1);
-        expect(spy3).toHaveBeenCalledTimes(1);
-        expect(spy4).toHaveBeenCalledTimes(1);
-        unregister1();
-        unregister3();
-        spy1.mockClear();
-        spy2.mockClear();
-        spy3.mockClear();
-        spy4.mockClear();
-        await router.push("/test2");
-        expect(spy1).not.toHaveBeenCalled();
-        expect(spy2).toHaveBeenCalledTimes(1);
-        expect(spy3).not.toHaveBeenCalled();
-        expect(spy4).toHaveBeenCalledTimes(1);
-        unregister2();
-        unregister4();
-      });
-      test("guard execution order should remain correct after cleanup", async () => {
-        const executionOrder = [];
-        const guard1 = () => {
-          executionOrder.push("guard1");
-        };
-        const guard2 = () => {
-          executionOrder.push("guard2");
-        };
-        const guard3 = () => {
-          executionOrder.push("guard3");
-        };
-        router.beforeEach(guard1);
-        const unregister2 = router.beforeEach(guard2);
-        router.beforeEach(guard3);
-        await router.push("/test1");
-        expect(executionOrder).toEqual(["guard1", "guard2", "guard3"]);
-        executionOrder.length = 0;
-        unregister2();
-        await router.push("/test2");
-        expect(executionOrder).toEqual(["guard1", "guard3"]);
-      });
-    });
-    describe("afterEach multiple guards cleanup", () => {
-      test("cleaning single afterEach guard should not affect other guards", async () => {
-        const spy1 = vi.fn();
-        const spy2 = vi.fn();
-        const spy3 = vi.fn();
-        const unregister1 = router.afterEach(spy1);
-        const unregister2 = router.afterEach(spy2);
-        const unregister3 = router.afterEach(spy3);
-        await router.push("/test1");
-        expect(spy1).toHaveBeenCalledTimes(1);
-        expect(spy2).toHaveBeenCalledTimes(1);
-        expect(spy3).toHaveBeenCalledTimes(1);
-        unregister2();
-        await router.push("/test2");
-        expect(spy1).toHaveBeenCalledTimes(2);
-        expect(spy2).toHaveBeenCalledTimes(1);
-        expect(spy3).toHaveBeenCalledTimes(2);
-        unregister1();
-        unregister3();
-      });
-      test("afterEach guard execution order should remain correct after cleanup", async () => {
-        const executionOrder = [];
-        const guard1 = () => {
-          executionOrder.push("after1");
-        };
-        const guard2 = () => {
-          executionOrder.push("after2");
-        };
-        const guard3 = () => {
-          executionOrder.push("after3");
-        };
-        router.afterEach(guard1);
-        const unregister2 = router.afterEach(guard2);
-        router.afterEach(guard3);
-        await router.push("/test1");
-        expect(executionOrder).toEqual(["after1", "after2", "after3"]);
-        executionOrder.length = 0;
-        unregister2();
-        await router.push("/test2");
-        expect(executionOrder).toEqual(["after1", "after3"]);
-      });
-    });
-    describe("mixed guards cleanup", () => {
-      test("beforeEach and afterEach guards should cleanup independently", async () => {
-        const beforeSpy = vi.fn();
-        const afterSpy = vi.fn();
-        const unregisterBefore = router.beforeEach(beforeSpy);
-        const unregisterAfter = router.afterEach(afterSpy);
-        await router.push("/test1");
-        expect(beforeSpy).toHaveBeenCalledTimes(1);
-        expect(afterSpy).toHaveBeenCalledTimes(1);
-        unregisterBefore();
-        await router.push("/test2");
-        expect(beforeSpy).toHaveBeenCalledTimes(1);
-        expect(afterSpy).toHaveBeenCalledTimes(2);
-        unregisterAfter();
-        await router.push("/test3");
-        expect(beforeSpy).toHaveBeenCalledTimes(1);
-        expect(afterSpy).toHaveBeenCalledTimes(2);
-      });
-    });
-  });
-  describe("\u{1F6E1}\uFE0F Edge Cases Testing", () => {
-    describe("repeated cleanup safety", () => {
-      test("repeated cleanup function calls should be safe", () => {
-        const spy = vi.fn();
-        const unregister = router.beforeEach(spy);
-        expect(() => {
-          unregister();
-          unregister();
-          unregister();
-        }).not.toThrow();
-      });
-      test("guard should still not execute after repeated cleanup", async () => {
-        const spy = vi.fn();
-        const unregister = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        unregister();
-        unregister();
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(1);
-      });
-    });
-    describe("cleanup and re-registration", () => {
-      test("can re-register same guard after cleanup", async () => {
-        const spy = vi.fn();
-        const unregister1 = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister1();
-        const unregister2 = router.beforeEach(spy);
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(2);
-        unregister2();
-      });
-      test("re-registration after cleanup should work normally", async () => {
-        const spy = vi.fn();
-        let unregister = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(1);
-        unregister();
-        unregister = router.beforeEach(spy);
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(2);
-        unregister();
-        unregister = router.beforeEach(spy);
-        await router.push("/test3");
-        expect(spy).toHaveBeenCalledTimes(3);
-        unregister();
-      });
-    });
-    describe("same guard multiple registrations", () => {
-      test("same guard function registered multiple times should handle correctly", async () => {
-        const spy = vi.fn();
-        const unregister1 = router.beforeEach(spy);
-        const unregister2 = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(2);
-        unregister1();
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(3);
-        unregister2();
-        await router.push("/test3");
-        expect(spy).toHaveBeenCalledTimes(3);
-      });
-      test("complex scenario with same guard multiple registrations and cleanups", async () => {
-        const spy = vi.fn();
-        const unregister1 = router.beforeEach(spy);
-        const unregister2 = router.beforeEach(spy);
-        const unregister3 = router.beforeEach(spy);
-        await router.push("/test1");
-        expect(spy).toHaveBeenCalledTimes(3);
-        unregister2();
-        await router.push("/test2");
-        expect(spy).toHaveBeenCalledTimes(5);
-        unregister1();
-        unregister3();
-        await router.push("/test3");
-        expect(spy).toHaveBeenCalledTimes(5);
-      });
-    });
-    describe("empty array and non-existent element handling", () => {
-      test("removing element from empty array should be safe", () => {
-        const emptyArray = [];
-        const element = vi.fn();
-        expect(() => {
-          removeFromArray(emptyArray, element);
-        }).not.toThrow();
-        expect(emptyArray).toEqual([]);
-      });
-      test("removing non-existent element should be safe", () => {
-        const array = [vi.fn(), vi.fn(), vi.fn()];
-        const nonExistentElement = vi.fn();
-        const originalLength = array.length;
-        expect(() => {
-          removeFromArray(array, nonExistentElement);
-        }).not.toThrow();
-        expect(array).toHaveLength(originalLength);
-      });
-    });
-    describe("special value handling", () => {
-      test("removeFromArray should handle NaN values correctly", () => {
-        const arr = [1, Number.NaN, 3, Number.NaN, 5];
-        removeFromArray(arr, Number.NaN);
-        expect(arr).toEqual([1, 3, Number.NaN, 5]);
-      });
-      test("removeFromArray should handle function references correctly", () => {
-        const func1 = () => "func1";
-        const func2 = () => "func2";
-        const func3 = () => "func3";
-        const arr = [func1, func2, func3];
-        removeFromArray(arr, func2);
-        expect(arr).toEqual([func1, func3]);
-      });
-      test("removeFromArray should handle object references correctly", () => {
-        const obj1 = { id: 1 };
-        const obj2 = { id: 2 };
-        const obj3 = { id: 3 };
-        const arr = [obj1, obj2, obj3];
-        removeFromArray(arr, obj2);
-        expect(arr).toEqual([obj1, obj3]);
-      });
-    });
-    describe("memory leak protection", () => {
-      test("large number of guard registrations and cleanups should not cause memory leaks", () => {
-        const unregisters = [];
-        for (let i = 0; i < 100; i++) {
-          const guard = vi.fn();
-          const unregister = router.beforeEach(guard);
-          unregisters.push(unregister);
-        }
-        expect(router.transition.guards.beforeEach).toHaveLength(100);
-        unregisters.forEach((unregister) => unregister());
-        expect(router.transition.guards.beforeEach).toHaveLength(0);
-      });
-      test("mixed registration and cleanup should not cause memory leaks", () => {
-        const guards = [];
-        const unregisters = [];
-        for (let i = 0; i < 50; i++) {
-          const guard = vi.fn();
-          guards.push(guard);
-          const unregister = router.beforeEach(guard);
-          unregisters.push(unregister);
-          if (i % 5 === 0 && i > 0) {
-            unregisters[i - 5]();
-          }
-        }
-        unregisters.forEach((unregister) => unregister());
-        expect(router.transition.guards.beforeEach).toHaveLength(0);
-        expect(router.transition.guards.afterEach).toHaveLength(0);
-      });
-    });
-    describe("concurrent cleanup safety", () => {
-      test("cleaning guard during navigation should be safe", async () => {
-        let unregister = null;
-        let guardExecuted = false;
-        const guard = async () => {
-          guardExecuted = true;
-          unregister == null ? void 0 : unregister();
-          await new Promise((resolve) => setTimeout(resolve, 10));
-        };
-        unregister = router.beforeEach(guard);
-        await expect(router.push("/test1")).resolves.toBeDefined();
-        expect(guardExecuted).toBe(true);
-        guardExecuted = false;
-        await router.push("/test2");
-        expect(guardExecuted).toBe(false);
-      });
-      test("cleaning multiple guards simultaneously should be safe", async () => {
-        const guards = Array.from({ length: 10 }, () => vi.fn());
-        const unregisters = guards.map(
-          (guard) => router.beforeEach(guard)
-        );
-        await router.push("/test1");
-        guards.forEach(
-          (guard) => expect(guard).toHaveBeenCalledTimes(1)
-        );
-        unregisters.forEach((unregister) => unregister());
-        await router.push("/test2");
-        guards.forEach(
-          (guard) => expect(guard).toHaveBeenCalledTimes(1)
-        );
-      });
-    });
-  });
-  describe("\u{1F527} Router destroy cleanup verification", () => {
-    test("Router destroy should cleanup all guards", async () => {
-      const beforeSpy = vi.fn();
-      const afterSpy = vi.fn();
-      router.beforeEach(beforeSpy);
-      router.afterEach(afterSpy);
-      await router.push("/test1");
-      expect(beforeSpy).toHaveBeenCalledTimes(1);
-      expect(afterSpy).toHaveBeenCalledTimes(1);
-      router.destroy();
-      const newRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: () => "Home" },
-          { path: "/test", component: () => "Test" }
-        ]
-      });
-      await newRouter.replace("/");
-      await newRouter.push("/test");
-      expect(beforeSpy).toHaveBeenCalledTimes(1);
-      expect(afterSpy).toHaveBeenCalledTimes(1);
-      newRouter.destroy();
-    });
-  });
-});

package/dist/router-push.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/router-push.test.mjs

@@ -1,115 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { Router } from "./router.mjs";
-import { RouteType, RouterMode } from "./types.mjs";
-describe("Router Push Tests", () => {
-  let router;
-  beforeEach(async () => {
-    router = new Router({
-      mode: RouterMode.memory,
-      base: new URL("http://localhost:3000/"),
-      routes: [
-        { path: "/", component: () => "Home" },
-        { path: "/user/:id", component: () => "User" },
-        { path: "/about", component: () => "About" },
-        {
-          path: "/async",
-          asyncComponent: () => new Promise(
-            (resolve) => setTimeout(() => resolve("AsyncComponent"), 10)
-          )
-        }
-      ]
-    });
-    await router.replace("/");
-  });
-  afterEach(() => {
-    router.destroy();
-  });
-  describe("Basic push navigation", () => {
-    test("should successfully push to new route", async () => {
-      const route = await router.push("/user/123");
-      expect(route.path).toBe("/user/123");
-      expect(route.params.id).toBe("123");
-      expect(route.type).toBe(RouteType.push);
-      expect(route.handle).not.toBe(null);
-      expect(router.route.path).toBe("/user/123");
-    });
-    test("should handle query parameters in push", async () => {
-      const route = await router.push(
-        "/user/123?tab=profile&active=true"
-      );
-      expect(route.params.id).toBe("123");
-      expect(route.query.tab).toBe("profile");
-      expect(route.query.active).toBe("true");
-    });
-    test("should handle async component loading", async () => {
-      const route = await router.push("/async");
-      expect(route.path).toBe("/async");
-      expect(route.handle).not.toBe(null);
-    });
-  });
-  describe("Error handling", () => {
-    test("should throw error for async component loading failure", async () => {
-      const errorRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: () => "Home" },
-          {
-            path: "/error",
-            asyncComponent: () => Promise.reject(new Error("Loading failed"))
-          }
-        ]
-      });
-      await errorRouter.replace("/");
-      await expect(errorRouter.push("/error")).rejects.toThrow();
-      errorRouter.destroy();
-    });
-    test("should throw error when guard prevents navigation", async () => {
-      const guardRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: () => "Home" },
-          {
-            path: "/protected",
-            component: () => "Protected",
-            beforeEnter: () => false
-          }
-        ]
-      });
-      await guardRouter.replace("/");
-      await expect(guardRouter.push("/protected")).rejects.toThrow();
-      guardRouter.destroy();
-    });
-  });
-  describe("Concurrent navigation", () => {
-    test("should handle concurrent push operations", async () => {
-      const promises = [
-        router.push("/user/1").catch((err) => err),
-        router.push("/user/2").catch((err) => err)
-      ];
-      const [result1, result2] = await Promise.all(promises);
-      const successResults = [result1, result2].filter(
-        (r) => !(r instanceof Error)
-      );
-      const errorResults = [result1, result2].filter(
-        (r) => r instanceof Error
-      );
-      expect(successResults).toHaveLength(1);
-      expect(errorResults).toHaveLength(1);
-    });
-  });
-  describe("Edge cases", () => {
-    test("should handle push to current route", async () => {
-      await router.push("/about");
-      const route = await router.push("/about");
-      expect(route.path).toBe("/about");
-      expect(route.handle).not.toBe(null);
-    });
-    test("should handle empty parameter", async () => {
-      const route = await router.push("");
-      expect(route).toBeDefined();
-      expect(typeof route.path).toBe("string");
-    });
-  });
-});

package/dist/router-replace.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/router-replace.test.mjs

@@ -1,114 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { Router } from "./router.mjs";
-import { RouteType, RouterMode } from "./types.mjs";
-describe("Router Replace Tests", () => {
-  let router;
-  beforeEach(async () => {
-    router = new Router({
-      mode: RouterMode.memory,
-      base: new URL("http://localhost:3000/"),
-      routes: [
-        { path: "/", component: () => "Home" },
-        { path: "/user/:id", component: () => "User" },
-        { path: "/about", component: () => "About" },
-        {
-          path: "/async",
-          asyncComponent: () => new Promise(
-            (resolve) => setTimeout(() => resolve("AsyncComponent"), 10)
-          )
-        }
-      ]
-    });
-    await router.replace("/");
-  });
-  afterEach(() => {
-    router.destroy();
-  });
-  describe("Basic replace navigation", () => {
-    test("should successfully replace current route", async () => {
-      await router.push("/about");
-      const route = await router.replace("/user/123");
-      expect(route.path).toBe("/user/123");
-      expect(route.params.id).toBe("123");
-      expect(route.type).toBe(RouteType.replace);
-      expect(route.handle).not.toBe(null);
-      expect(router.route.path).toBe("/user/123");
-    });
-    test("should handle query parameters in replace", async () => {
-      const route = await router.replace(
-        "/user/123?tab=profile&active=true"
-      );
-      expect(route.params.id).toBe("123");
-      expect(route.query.tab).toBe("profile");
-      expect(route.query.active).toBe("true");
-    });
-    test("should handle async component loading", async () => {
-      const route = await router.replace("/async");
-      expect(route.path).toBe("/async");
-      expect(route.handle).not.toBe(null);
-    });
-  });
-  describe("Error handling", () => {
-    test("should throw error for async component loading failure", async () => {
-      const errorRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: () => "Home" },
-          {
-            path: "/error",
-            asyncComponent: () => Promise.reject(new Error("Loading failed"))
-          }
-        ]
-      });
-      await errorRouter.replace("/");
-      await expect(errorRouter.replace("/error")).rejects.toThrow();
-      errorRouter.destroy();
-    });
-    test("should throw error when guard prevents navigation", async () => {
-      const guardRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: () => "Home" },
-          {
-            path: "/protected",
-            component: () => "Protected",
-            beforeEnter: () => false
-          }
-        ]
-      });
-      await guardRouter.replace("/");
-      await expect(guardRouter.replace("/protected")).rejects.toThrow();
-      guardRouter.destroy();
-    });
-  });
-  describe("History management", () => {
-    test("should not create new history entry", async () => {
-      await router.push("/about");
-      await router.replace("/user/123");
-      const backRoute = await router.back();
-      expect(backRoute == null ? void 0 : backRoute.path).toBe("/");
-    });
-    test("should replace current entry in history", async () => {
-      await router.push("/about");
-      await router.push("/user/456");
-      await router.replace("/user/789");
-      const backRoute = await router.back();
-      expect(backRoute == null ? void 0 : backRoute.path).toBe("/about");
-    });
-  });
-  describe("Edge cases", () => {
-    test("should handle replace to current route", async () => {
-      await router.push("/about");
-      const route = await router.replace("/about");
-      expect(route.path).toBe("/about");
-      expect(route.handle).not.toBe(null);
-    });
-    test("should handle empty parameter", async () => {
-      const route = await router.replace("");
-      expect(route).toBeDefined();
-      expect(typeof route.path).toBe("string");
-    });
-  });
-});

package/dist/router-resolve.test.d.ts

@@ -1 +0,0 @@
-export {};