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

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

@@ -1,616 +0,0 @@
-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-".concat(to.path, "-from-").concat((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-".concat(to.path, "-from-").concat((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-".concat(to.path));
-      });
-      const unregisterAfter = lifecycleRouter.afterEach((to, from) => {
-        lifecycleLog.push("global-afterEach-".concat(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/".concat(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/".concat(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

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