@esmx/router 3.0.0-rc.17 → 3.0.0-rc.19

package/dist/router-restart-app.dom.test.mjs

@@ -0,0 +1,616 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Router } from "./router.mjs";
+import { RouteType } from "./types.mjs";
+describe("Router.restartApp Focused Tests", () => {
+  let router;
+  let mockApps;
+  beforeEach(async () => {
+    mockApps = {
+      home: vi.fn(() => ({ mount: vi.fn(), unmount: vi.fn() })),
+      about: vi.fn(() => ({ mount: vi.fn(), unmount: vi.fn() })),
+      user: vi.fn(() => ({ mount: vi.fn(), unmount: vi.fn() })),
+      products: vi.fn(() => ({ mount: vi.fn(), unmount: vi.fn() }))
+    };
+    const options = {
+      routes: [
+        { path: "/", app: "home" },
+        { path: "/about", app: "about" },
+        { path: "/user/:id", app: "user" },
+        { path: "/products/:category", app: "products" }
+      ],
+      apps: mockApps
+    };
+    router = new Router(options);
+    await router.push("/");
+  });
+  afterEach(() => {
+    router.destroy();
+    vi.clearAllMocks();
+  });
+  describe("\u{1F3AF} Core Functionality Tests", () => {
+    it("should support parameterless restart (restart to current path)", async () => {
+      await router.push("/user/123");
+      expect(router.route.url.pathname).toBe("/user/123");
+      const result = await router.restartApp();
+      expect(result.type).toBe(RouteType.restartApp);
+      expect(result.url.pathname).toBe("/user/123");
+      expect(result.handle).not.toBeNull();
+      expect(router.route).toBe(result);
+    });
+    it("should support string path restart", async () => {
+      const result = await router.restartApp("/about");
+      expect(result.type).toBe(RouteType.restartApp);
+      expect(result.url.pathname).toBe("/about");
+      expect(result.handle).not.toBeNull();
+      expect(router.route).toBe(result);
+    });
+    it("should support object parameter restart", async () => {
+      const result = await router.restartApp({
+        path: "/user/456",
+        query: { tab: "profile", mode: "edit" },
+        hash: "#section1"
+      });
+      expect(result.type).toBe(RouteType.restartApp);
+      expect(result.url.pathname).toBe("/user/456");
+      expect(result.query.tab).toBe("profile");
+      expect(result.query.mode).toBe("edit");
+      expect(result.url.hash).toBe("#section1");
+      expect(result.params.id).toBe("456");
+      expect(result.handle).not.toBeNull();
+    });
+    it("should support restart with state", async () => {
+      const customState = { userId: 123, preferences: { theme: "dark" } };
+      const result = await router.restartApp({
+        path: "/about",
+        state: customState
+      });
+      expect(result.state).toEqual(expect.objectContaining(customState));
+      const state = result.state;
+      expect(state.userId).toBe(123);
+      expect(state.preferences.theme).toBe("dark");
+    });
+    it("should correctly handle route parameters", async () => {
+      const result = await router.restartApp("/user/789");
+      expect(result.params.id).toBe("789");
+      expect(result.matched.length).toBeGreaterThan(0);
+      expect(result.matched[0].path).toBe("/user/:id");
+    });
+    it("should correctly handle query parameters", async () => {
+      const result = await router.restartApp("/about?tab=info&mode=edit");
+      expect(result.query.tab).toBe("info");
+      expect(result.query.mode).toBe("edit");
+      expect(result.url.search).toBe("?tab=info&mode=edit");
+    });
+    it("should correctly handle hash", async () => {
+      const result = await router.restartApp("/about#section2");
+      expect(result.url.hash).toBe("#section2");
+    });
+  });
+  describe("\u{1F504} restartApp-Specific Behavior Tests", () => {
+    it("should force update MicroApp (even with same application)", async () => {
+      await router.push("/about");
+      const firstCallCount = mockApps.about.mock.calls.length;
+      await router.restartApp("/about");
+      const secondCallCount = mockApps.about.mock.calls.length;
+      expect(secondCallCount).toBeGreaterThan(firstCallCount);
+    });
+    it("should call navigation.replace instead of push", async () => {
+      const replaceSpy = vi.spyOn(router.navigation, "replace");
+      const pushSpy = vi.spyOn(router.navigation, "push");
+      await router.restartApp("/about");
+      expect(replaceSpy).toHaveBeenCalled();
+      expect(pushSpy).not.toHaveBeenCalled();
+    });
+    it("should correctly update router current route state", async () => {
+      const result = await router.restartApp("/about");
+      expect(router.route.url.pathname).toBe("/about");
+      expect(router.route.type).toBe(RouteType.restartApp);
+      expect(router.route).toBe(result);
+    });
+    it("should differentiate from other routing method behaviors", async () => {
+      await router.push("/user/123");
+      expect(router.route.type).toBe(RouteType.push);
+      await router.replace("/about");
+      expect(router.route.type).toBe(RouteType.replace);
+      const result = await router.restartApp("/products/electronics");
+      expect(result.type).toBe(RouteType.restartApp);
+      expect(router.route.type).toBe(RouteType.restartApp);
+    });
+  });
+  describe("\u{1F3AD} Edge Cases Tests", () => {
+    it("should handle non-existent routes", async () => {
+      const result = await router.restartApp("/nonexistent");
+      expect(result.matched.length).toBe(0);
+      expect(result.config).toBeNull();
+      expect(result.url.pathname).toBe("/nonexistent");
+      expect(result.type).toBe(RouteType.restartApp);
+    });
+    it("should handle empty string path", async () => {
+      const result = await router.restartApp("");
+      expect(result.url.pathname).toBe("/");
+      expect(result.type).toBe(RouteType.restartApp);
+    });
+    it("should handle root path", async () => {
+      const result = await router.restartApp("/");
+      expect(result.url.pathname).toBe("/");
+      expect(result.matched.length).toBeGreaterThan(0);
+      expect(result.type).toBe(RouteType.restartApp);
+    });
+    it("should handle complex query parameters", async () => {
+      const result = await router.restartApp("/about?a=1&b=2&a=3&c=");
+      expect(result.query.b).toBe("2");
+      expect(result.query.c).toBe("");
+      expect(result.url.search).toContain("a=");
+      expect(result.url.search).toContain("b=2");
+    });
+    it("should handle special character paths", async () => {
+      const result = await router.restartApp("/user/\u6D4B\u8BD5\u7528\u6237");
+      expect(result.url.pathname).toContain("/user/");
+      expect(decodeURIComponent(result.params.id)).toBe("\u6D4B\u8BD5\u7528\u6237");
+    });
+  });
+  describe("\u{1F517} URL Parsing Tests", () => {
+    it("should correctly parse absolute paths", async () => {
+      await router.push("/user/123");
+      const result = await router.restartApp("/about");
+      expect(result.url.pathname).toBe("/about");
+      expect(result.url.href).toMatch(/\/about$/);
+    });
+    it("should correctly handle relative paths", async () => {
+      await router.push("/user/123");
+      const result = await router.restartApp("456");
+      expect(result.url.pathname).toContain("456");
+      if (result.matched.length > 0 && result.matched[0].path === "/user/:id") {
+        expect(result.params.id).toBe("456");
+      }
+    });
+    it("should correctly handle complete URLs", async () => {
+      const result = await router.restartApp("http://example.com/test");
+      expect(result.url.href).toBe("http://example.com/test");
+      expect(result.url.pathname).toBe("/test");
+    });
+  });
+  describe("\u{1F3AF} Type Overload Tests", () => {
+    it("should support parameterless calls", async () => {
+      await router.push("/user/123");
+      const result = await router.restartApp();
+      expect(result.url.pathname).toBe("/user/123");
+      expect(result.type).toBe(RouteType.restartApp);
+    });
+    it("should support string parameter calls", async () => {
+      const result = await router.restartApp("/about");
+      expect(result.url.pathname).toBe("/about");
+      expect(result.type).toBe(RouteType.restartApp);
+    });
+    it("should support object parameter calls", async () => {
+      const routeLocation = {
+        path: "/user/456",
+        query: { tab: "settings" }
+      };
+      const result = await router.restartApp(routeLocation);
+      expect(result.url.pathname).toBe("/user/456");
+      expect(result.query.tab).toBe("settings");
+      expect(result.type).toBe(RouteType.restartApp);
+    });
+  });
+  describe("\u{1F504} Multiple Restart Tests", () => {
+    it("should support consecutive multiple restarts", async () => {
+      const paths = ["/about", "/user/123", "/products/electronics", "/"];
+      for (const path of paths) {
+        const result = await router.restartApp(path);
+        expect(result.type).toBe(RouteType.restartApp);
+        expect(result.handle).not.toBeNull();
+        expect(router.route).toBe(result);
+      }
+    });
+    it("should create new application instances on each restart", async () => {
+      await router.restartApp("/about");
+      const firstCallCount = mockApps.about.mock.calls.length;
+      await router.restartApp("/about");
+      const secondCallCount = mockApps.about.mock.calls.length;
+      await router.restartApp("/about");
+      const thirdCallCount = mockApps.about.mock.calls.length;
+      expect(secondCallCount).toBeGreaterThan(firstCallCount);
+      expect(thirdCallCount).toBeGreaterThan(secondCallCount);
+    });
+  });
+  describe("\u{1F3A8} Status Code Handling Tests", () => {
+    it("should support custom status codes", async () => {
+      const result = await router.restartApp({
+        path: "/about",
+        statusCode: 201
+      });
+      expect(result.statusCode).toBe(201);
+    });
+    it("should maintain default status code as null", async () => {
+      const result = await router.restartApp("/about");
+      expect(result.statusCode).toBeNull();
+    });
+  });
+  describe("\u{1F527} Consistency Tests with resolve Method", () => {
+    it("should maintain consistency with resolve method results in URL parsing", async () => {
+      const resolvedRoute = router.resolve("/user/789");
+      const restartedRoute = await router.restartApp("/user/789");
+      expect(restartedRoute.url.href).toBe(resolvedRoute.url.href);
+      expect(restartedRoute.params).toEqual(resolvedRoute.params);
+      expect(restartedRoute.matched).toEqual(resolvedRoute.matched);
+      expect(restartedRoute.type).toBe(RouteType.restartApp);
+      expect(resolvedRoute.type).toBe(RouteType.push);
+    });
+  });
+  describe("\u{1F6E1}\uFE0F Route Guards Integration Tests", () => {
+    let guardExecutionLog;
+    beforeEach(() => {
+      guardExecutionLog = [];
+    });
+    it("should correctly execute beforeEach guards", async () => {
+      const unregister = router.beforeEach(async (to, from) => {
+        guardExecutionLog.push(
+          `beforeEach-${to.path}-from-${(from == null ? void 0 : from.path) || "null"}`
+        );
+      });
+      await router.restartApp("/about");
+      expect(guardExecutionLog).toContain("beforeEach-/about-from-/");
+      unregister();
+    });
+    it("should correctly execute afterEach guards", async () => {
+      const unregister = router.afterEach((to, from) => {
+        guardExecutionLog.push(
+          `afterEach-${to.path}-from-${(from == null ? void 0 : from.path) || "null"}`
+        );
+      });
+      await router.restartApp("/about");
+      expect(guardExecutionLog).toContain("afterEach-/about-from-/");
+      unregister();
+    });
+    it("should abort restart when beforeEach guard returns false", async () => {
+      const unregister = router.beforeEach(async (to, from) => {
+        if (to.path === "/about") {
+          return false;
+        }
+      });
+      await expect(router.restartApp("/about")).rejects.toThrow();
+      expect(router.route.path).toBe("/");
+      unregister();
+    });
+    it("should support guard redirects", async () => {
+      const unregister = router.beforeEach(async (to, from) => {
+        if (to.path === "/about") {
+          return "/user/redirected";
+        }
+      });
+      const result = await router.restartApp("/about");
+      expect(result.path).toBe("/user/redirected");
+      expect(result.params.id).toBe("redirected");
+      expect(result.handle).not.toBeNull();
+      unregister();
+    });
+  });
+  describe("\u{1F9E9} Async Component Handling Tests", () => {
+    let asyncRouter;
+    beforeEach(async () => {
+      const asyncOptions = {
+        routes: [
+          {
+            path: "/",
+            app: "home",
+            component: () => "HomeComponent"
+          },
+          {
+            path: "/async",
+            app: "async",
+            asyncComponent: async () => {
+              await new Promise(
+                (resolve) => setTimeout(resolve, 10)
+              );
+              return () => "AsyncComponent";
+            }
+          },
+          {
+            path: "/async-error",
+            app: "async-error",
+            asyncComponent: async () => {
+              throw new Error("Component load failed");
+            }
+          }
+        ],
+        apps: mockApps
+      };
+      asyncRouter = new Router(asyncOptions);
+      await asyncRouter.push("/");
+    });
+    afterEach(() => {
+      asyncRouter.destroy();
+    });
+    it("should correctly handle async component loading", async () => {
+      const result = await asyncRouter.restartApp("/async");
+      expect(result.handle).not.toBeNull();
+      expect(result.matched[0].component).toBeDefined();
+      expect(typeof result.matched[0].component).toBe("function");
+    });
+    it("should handle async component loading failures", async () => {
+      await expect(
+        asyncRouter.restartApp("/async-error")
+      ).rejects.toThrow();
+    });
+  });
+  describe("\u26A1 Task Cancellation and Concurrency Control Tests", () => {
+    it("should cancel tasks interrupted by new restartApp calls", async () => {
+      const unregister = router.beforeEach(async (to, from) => {
+        if (to.path === "/user/slow") {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+      });
+      const promises = [
+        router.restartApp("/user/slow").catch((err) => err),
+        router.restartApp("/about").catch((err) => err)
+      ];
+      const results = await Promise.all(promises);
+      expect(results[0] instanceof Error).toBe(true);
+      expect(results[1].handle).not.toBeNull();
+      expect(router.route.path).toBe("/about");
+      unregister();
+    });
+    it("should correctly handle multiple concurrent restartApp calls", async () => {
+      const paths = ["/user/1", "/user/2", "/user/3"];
+      const promises = paths.map(
+        (path) => router.restartApp(path).catch((err) => err)
+      );
+      const results = await Promise.all(promises);
+      expect(results[0] instanceof Error).toBe(true);
+      expect(results[1] instanceof Error).toBe(true);
+      expect(results[2].handle).not.toBeNull();
+      expect(router.route.path).toBe("/user/3");
+    });
+  });
+  describe("\u{1F30D} Route Override Tests", () => {
+    let overrideRouter;
+    beforeEach(async () => {
+      const overrideOptions = {
+        routes: [
+          {
+            path: "/",
+            app: "home",
+            component: () => "HomeComponent"
+          },
+          {
+            path: "/override-test",
+            app: "override",
+            component: () => "OverrideComponent",
+            override: (to, from) => {
+              if (to.query.native === "true") {
+                return async () => {
+                  return { native: true, path: to.path };
+                };
+              }
+            }
+          },
+          {
+            path: "/hybrid-page",
+            app: "hybrid",
+            component: () => "HybridComponent",
+            override: (to, from) => {
+              return async () => {
+                return {
+                  hybrid: "native",
+                  component: "NativeComponent"
+                };
+              };
+            }
+          }
+        ],
+        apps: mockApps
+      };
+      overrideRouter = new Router(overrideOptions);
+      await overrideRouter.push("/");
+    });
+    afterEach(() => {
+      overrideRouter.destroy();
+    });
+    it("should use override when condition is met", async () => {
+      var _a;
+      const result = await overrideRouter.restartApp(
+        "/override-test?native=true"
+      );
+      expect(result.handle).not.toBeNull();
+      expect(result.handleResult).toBeUndefined();
+      expect((_a = result.config) == null ? void 0 : _a.override).toBeDefined();
+    });
+    it("should use default behavior when override returns nothing", async () => {
+      const result = await overrideRouter.restartApp(
+        "/override-test?native=false"
+      );
+      expect(result.handle).not.toBeNull();
+      expect(result.handle).not.toBeNull();
+    });
+    it("should always use override when function always returns handler", async () => {
+      var _a;
+      const result = await overrideRouter.restartApp("/hybrid-page");
+      expect(result.handle).not.toBeNull();
+      expect(result.handleResult).toBeUndefined();
+      expect((_a = result.config) == null ? void 0 : _a.override).toBeDefined();
+    });
+  });
+  describe("\u274C Error Handling and Exception Scenario Tests", () => {
+    it("should handle exceptions thrown in guards", async () => {
+      const unregister = router.beforeEach(async (to, from) => {
+        if (to.path === "/about") {
+          throw new Error("Guard error");
+        }
+      });
+      await expect(router.restartApp("/about")).rejects.toThrow(
+        "Guard error"
+      );
+      unregister();
+    });
+    it("should handle MicroApp update exceptions", async () => {
+      const originalUpdate = router.microApp._update;
+      router.microApp._update = vi.fn().mockImplementation(() => {
+        throw new Error("MicroApp update failed");
+      });
+      await expect(router.restartApp("/about")).rejects.toThrow(
+        "MicroApp update failed"
+      );
+      router.microApp._update = originalUpdate;
+    });
+    it("should handle navigation.replace exceptions", async () => {
+      const originalReplace = router.navigation.replace;
+      router.navigation.replace = vi.fn().mockImplementation(() => {
+        throw new Error("Navigation replace failed");
+      });
+      await expect(router.restartApp("/about")).rejects.toThrow(
+        "Navigation replace failed"
+      );
+      router.navigation.replace = originalReplace;
+    });
+  });
+  describe("\u{1F504} Route Lifecycle Integrity Tests", () => {
+    let lifecycleRouter;
+    let lifecycleLog;
+    beforeEach(async () => {
+      lifecycleLog = [];
+      const lifecycleOptions = {
+        routes: [
+          {
+            path: "/",
+            app: "home",
+            component: () => "HomeComponent",
+            beforeLeave: async (to, from) => {
+              lifecycleLog.push("home-beforeLeave");
+            }
+          },
+          {
+            path: "/lifecycle",
+            app: "lifecycle",
+            component: () => "LifecycleComponent",
+            beforeEnter: async (to, from) => {
+              lifecycleLog.push("lifecycle-beforeEnter");
+            },
+            beforeUpdate: async (to, from) => {
+              lifecycleLog.push("lifecycle-beforeUpdate");
+            },
+            beforeLeave: async (to, from) => {
+              lifecycleLog.push("lifecycle-beforeLeave");
+            }
+          }
+        ],
+        apps: mockApps
+      };
+      lifecycleRouter = new Router(lifecycleOptions);
+      await lifecycleRouter.push("/");
+    });
+    afterEach(() => {
+      lifecycleRouter.destroy();
+    });
+    it("should correctly execute complete route lifecycle", async () => {
+      const unregisterBefore = lifecycleRouter.beforeEach((to, from) => {
+        lifecycleLog.push(`global-beforeEach-${to.path}`);
+      });
+      const unregisterAfter = lifecycleRouter.afterEach((to, from) => {
+        lifecycleLog.push(`global-afterEach-${to.path}`);
+      });
+      await lifecycleRouter.restartApp("/lifecycle");
+      expect(lifecycleLog).toEqual([
+        "home-beforeLeave",
+        "global-beforeEach-/lifecycle",
+        "lifecycle-beforeEnter",
+        "global-afterEach-/lifecycle"
+      ]);
+      unregisterBefore();
+      unregisterAfter();
+    });
+    it("should execute beforeUpdate when restarting same route", async () => {
+      await lifecycleRouter.push("/lifecycle");
+      lifecycleLog = [];
+      await lifecycleRouter.restartApp("/lifecycle?version=2");
+      expect(lifecycleLog).toContain("lifecycle-beforeUpdate");
+      expect(lifecycleLog).not.toContain("lifecycle-beforeEnter");
+    });
+  });
+  describe("\u{1F3AF} Special Route Configuration Tests", () => {
+    it("should handle routes with custom location handler", async () => {
+      let locationCalled = false;
+      const customLocationRouter = new Router({
+        routes: [{ path: "/", app: "home" }],
+        apps: mockApps,
+        fallback: (to, from) => {
+          locationCalled = true;
+          return { customLocation: true, path: to.path };
+        }
+      });
+      await customLocationRouter.push("/");
+      const result = await customLocationRouter.restartApp("/nonexistent");
+      expect(locationCalled).toBe(true);
+      expect(result.matched.length).toBe(0);
+      expect(typeof result.handle).toBe("function");
+      expect(result.handleResult).toEqual({
+        customLocation: true,
+        path: "/nonexistent"
+      });
+      customLocationRouter.destroy();
+    });
+    it("should handle complex nested route restarts", async () => {
+      const nestedRouter = new Router({
+        routes: [
+          {
+            path: "/",
+            app: "home",
+            children: [
+              {
+                path: "nested/:id",
+                app: "nested",
+                children: [
+                  {
+                    path: "deep/:subId",
+                    app: "deep"
+                  }
+                ]
+              }
+            ]
+          }
+        ],
+        apps: mockApps
+      });
+      await nestedRouter.push("/");
+      const result = await nestedRouter.restartApp(
+        "/nested/123/deep/456"
+      );
+      expect(result.params.id).toBe("123");
+      expect(result.params.subId).toBe("456");
+      expect(result.matched.length).toBe(3);
+      nestedRouter.destroy();
+    });
+  });
+  describe("\u{1F4CA} Performance and Memory Tests", () => {
+    it("should correctly clean up resources after extensive restarts", async () => {
+      const initialAppsCallCount = Object.values(mockApps).reduce(
+        (sum, app) => sum + app.mock.calls.length,
+        0
+      );
+      for (let i = 0; i < 50; i++) {
+        await router.restartApp(`/user/${i}`);
+      }
+      const finalAppsCallCount = Object.values(mockApps).reduce(
+        (sum, app) => sum + app.mock.calls.length,
+        0
+      );
+      expect(finalAppsCallCount).toBeGreaterThan(initialAppsCallCount);
+      expect(router.route.params.id).toBe("49");
+    });
+    it("should correctly handle rapid consecutive restart calls", async () => {
+      const startTime = Date.now();
+      const promises = Array.from(
+        { length: 10 },
+        (_, i) => router.restartApp(`/user/${i}`).catch((err) => err)
+      );
+      const results = await Promise.all(promises);
+      const endTime = Date.now();
+      const successfulResults = results.filter(
+        (r) => !(r instanceof Error) && r.handle !== null
+      );
+      expect(successfulResults).toHaveLength(1);
+      expect(successfulResults[0].params.id).toBe("9");
+      expect(endTime - startTime).toBeLessThan(1e3);
+    });
+  });
+});

package/dist/router-window-navigation.test.d.ts

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