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

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

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

package/dist/router-back.test.mjs

@@ -1,361 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { Router } from "./router.mjs";
-import { RouteType, RouterMode } from "./types.mjs";
-describe("Router.back Tests", () => {
-  let router;
-  let executionLog;
-  beforeEach(async () => {
-    executionLog = [];
-    router = new Router({
-      mode: RouterMode.memory,
-      base: new URL("http://localhost:3000/"),
-      fallback: (to, from) => {
-        executionLog.push("location-handler-".concat(to.path));
-      },
-      routes: [
-        {
-          path: "/",
-          component: () => "Home"
-        },
-        {
-          path: "/about",
-          component: () => "About"
-        },
-        {
-          path: "/user/:id",
-          component: () => "User",
-          beforeEnter: (to) => {
-            if (to.params.id === "blocked") {
-              return false;
-            }
-            if (to.params.id === "redirect") {
-              return "/about";
-            }
-          }
-        },
-        {
-          path: "/async",
-          asyncComponent: () => new Promise((resolve) => {
-            setTimeout(() => resolve("AsyncComponent"), 10);
-          })
-        },
-        {
-          path: "/async-error",
-          asyncComponent: () => new Promise((_, reject) => {
-            setTimeout(
-              () => reject(new Error("Load failed")),
-              10
-            );
-          })
-        }
-      ]
-    });
-    await router.push("/");
-  });
-  afterEach(() => {
-    router.destroy();
-  });
-  describe("\u{1F3AF} Core Behavior", () => {
-    test("back should return Promise<Route | null>", async () => {
-      await router.push("/about");
-      const route = await router.back();
-      expect(route).toBeInstanceOf(Object);
-      expect(route == null ? void 0 : route.path).toBe("/");
-      expect(route == null ? void 0 : route.handle).not.toBeNull();
-    });
-    test("back should navigate to previous route", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      const backRoute = await router.back();
-      expect(backRoute == null ? void 0 : backRoute.path).toBe("/about");
-      expect(router.route.path).toBe("/about");
-    });
-    test("back should update router state", async () => {
-      await router.push("/about");
-      await router.back();
-      expect(router.route.path).toBe("/");
-      expect(router.route.handle).not.toBeNull();
-    });
-  });
-  describe("\u{1F504} History Navigation Logic", () => {
-    test("back should navigate based on history stack", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      const route1 = await router.back();
-      expect(route1 == null ? void 0 : route1.path).toBe("/about");
-      expect(router.route.path).toBe("/about");
-      const route2 = await router.back();
-      expect(route2 == null ? void 0 : route2.path).toBe("/");
-      expect(router.route.path).toBe("/");
-    });
-    test("back beyond history boundaries should return null", async () => {
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: "Home" },
-          { path: "/about", component: "About" }
-        ]
-      });
-      await testRouter.replace("/about");
-      const route = await testRouter.back();
-      expect(route).toBe(null);
-      expect(testRouter.route.path).toBe("/about");
-      testRouter.destroy();
-    });
-    test("back should return correct RouteType", async () => {
-      await router.push("/about");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.type).toBe(RouteType.back);
-    });
-    test("back should keep isPush as false", async () => {
-      await router.push("/about");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.isPush).toBe(false);
-    });
-  });
-  describe("\u{1F3C3} Concurrency Control", () => {
-    test("later initiated back should cancel earlier back", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      const [firstResult, secondResult] = await Promise.all([
-        router.back(),
-        // First operation, should succeed
-        router.back()
-        // Second operation, returns null due to first one in progress
-      ]);
-      expect(firstResult == null ? void 0 : firstResult.handle).not.toBeNull();
-      expect(secondResult).toBe(null);
-      expect(router.route.path).toBe("/about");
-    });
-    test("cancelled tasks should not affect micro-app state", async () => {
-      const updateSpy = vi.spyOn(router.microApp, "_update");
-      await router.push("/about");
-      await router.push("/user/123");
-      updateSpy.mockClear();
-      const [firstResult, secondResult] = await Promise.all([
-        router.back(),
-        // First operation succeeds
-        router.back()
-        // Second operation returns null
-      ]);
-      expect(firstResult == null ? void 0 : firstResult.handle).not.toBeNull();
-      expect(secondResult).toBe(null);
-      expect(updateSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-  describe("\u{1F3AD} Micro-app Integration", () => {
-    test("back should trigger micro-app update", async () => {
-      const updateSpy = vi.spyOn(router.microApp, "_update");
-      await router.push("/about");
-      await router.back();
-      expect(updateSpy).toHaveBeenCalled();
-    });
-    test("micro-app update should happen after route state update", async () => {
-      let routePathWhenUpdated = null;
-      vi.spyOn(router.microApp, "_update").mockImplementation(() => {
-        routePathWhenUpdated = router.route.path;
-      });
-      await router.push("/about");
-      await router.back();
-      expect(routePathWhenUpdated).toBe("/");
-    });
-  });
-  describe("\u26A1 Async Components & Back", () => {
-    test("back to async component route should wait for component loading", async () => {
-      await router.push("/about");
-      await router.push("/async");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.path).toBe("/about");
-      expect(route == null ? void 0 : route.handle).not.toBeNull();
-    });
-    test("back to failed async component route should handle error correctly", async () => {
-      await router.push("/about");
-      await expect(router.push("/async-error")).rejects.toThrow();
-      expect(router.route.path).toBe("/about");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.path).toBe("/");
-    });
-  });
-  describe("\u{1F6E1}\uFE0F Back Guard Behavior", () => {
-    test("back navigation should work normally after blocked route attempt", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      const blockedResult = await router.push("/user/blocked");
-      expect(blockedResult.path).toBe("/user/blocked");
-      expect(router.route.path).toBe("/user/blocked");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.path).toBe("/user/123");
-    });
-    test("redirect guard should work during navigation", async () => {
-      const route = await router.push("/user/redirect");
-      expect(route.path).toBe("/about");
-      expect(router.route.path).toBe("/about");
-      const backRoute = await router.back();
-      expect(backRoute == null ? void 0 : backRoute.path).toBe("/");
-    });
-    test("afterEach only executes when navigation succeeds", async () => {
-      let afterEachCalled = false;
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: "Home" },
-          { path: "/about", component: "About" },
-          {
-            path: "/blocked",
-            component: "Blocked",
-            beforeEnter: () => false
-          }
-        ]
-      });
-      testRouter.afterEach(() => {
-        afterEachCalled = true;
-      });
-      await testRouter.push("/about");
-      afterEachCalled = false;
-      await expect(testRouter.push("/blocked")).rejects.toThrow();
-      expect(afterEachCalled).toBe(false);
-      testRouter.destroy();
-    });
-    test("beforeEach guard should be called during back operation", async () => {
-      let beforeEachCalled = false;
-      router.beforeEach(() => {
-        beforeEachCalled = true;
-      });
-      await router.push("/about");
-      await router.back();
-      expect(beforeEachCalled).toBe(true);
-    });
-  });
-  describe("\u{1F4BE} History Management", () => {
-    test("back should navigate correctly in history stack", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.path).toBe("/about");
-      expect(router.route.path).toBe("/about");
-    });
-    test("back operation should not create new history entries", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      await router.back();
-      const forwardRoute = await router.forward();
-      expect(forwardRoute == null ? void 0 : forwardRoute.path).toBe("/user/123");
-    });
-  });
-  describe("\u274C Error Handling", () => {
-    test("back to non-existent route should trigger location handling", async () => {
-      const fallbackSpy = vi.fn();
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        fallback: fallbackSpy,
-        routes: [{ path: "/", component: "Home" }]
-      });
-      await testRouter.replace("/");
-      const result = await testRouter.back();
-      expect(result).toBe(null);
-      testRouter.destroy();
-    });
-    test("exceptions during back process should propagate correctly", async () => {
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: "Home" },
-          { path: "/about", component: "About" }
-        ]
-      });
-      await testRouter.push("/about");
-      testRouter.beforeEach(() => {
-        throw new Error("Guard error");
-      });
-      await expect(testRouter.back()).rejects.toThrow("Guard error");
-      testRouter.destroy();
-    });
-  });
-  describe("\u{1F50D} Edge Cases", () => {
-    test("back should handle special character paths correctly", async () => {
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [
-          { path: "/", component: "Home" },
-          { path: "/special", component: "Special" }
-        ]
-      });
-      await testRouter.push("/");
-      await testRouter.push("/special");
-      const route = await testRouter.back();
-      expect(route == null ? void 0 : route.path).toBe("/");
-      expect(testRouter.route.path).toBe("/");
-      testRouter.destroy();
-    });
-  });
-  describe("\u{1F517} Integration with Other Navigation Methods", () => {
-    test("back should behave consistently with go(-1)", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      const backRoute = await router.back();
-      const goRoute = await router.go(-1);
-      expect(backRoute == null ? void 0 : backRoute.path).toBe("/about");
-      expect(goRoute == null ? void 0 : goRoute.path).toBe("/");
-    });
-    test("push after back should handle history correctly", async () => {
-      await router.push("/about");
-      await router.push("/user/123");
-      await router.back();
-      await router.push("/user/456");
-      expect(router.route.path).toBe("/user/456");
-    });
-  });
-  describe("\u{1F527} handleBackBoundary Callback Tests", () => {
-    test("should trigger handleBackBoundary when Navigation returns null", async () => {
-      let handleBackBoundaryCalled = false;
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [{ path: "/", component: "Home" }],
-        handleBackBoundary: () => {
-          handleBackBoundaryCalled = true;
-        }
-      });
-      await testRouter.replace("/");
-      const result = await testRouter.back();
-      expect(result).toBe(null);
-      expect(handleBackBoundaryCalled).toBe(true);
-      testRouter.destroy();
-    });
-    test("should not error when no handleBackBoundary callback", async () => {
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [{ path: "/", component: "Home" }]
-      });
-      await testRouter.replace("/");
-      const result = await testRouter.back();
-      expect(result).toBe(null);
-      testRouter.destroy();
-    });
-  });
-  describe("\u{1F504} Navigation Result Handling", () => {
-    test("should correctly handle successful navigation result", async () => {
-      await router.push("/about");
-      const route = await router.back();
-      expect(route == null ? void 0 : route.path).toBe("/");
-      expect(router.route.path).toBe("/");
-    });
-    test("should return null directly when Navigation returns null", async () => {
-      const testRouter = new Router({
-        mode: RouterMode.memory,
-        base: new URL("http://localhost:3000/"),
-        routes: [{ path: "/", component: "Home" }]
-      });
-      await testRouter.replace("/");
-      const result = await testRouter.back();
-      expect(result).toBe(null);
-      testRouter.destroy();
-    });
-  });
-});

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

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