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

package/dist/route-task.test.mjs

@@ -1,673 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  RouteNavigationAbortedError,
-  RouteTaskCancelledError,
-  RouteTaskExecutionError
-} from "./error.mjs";
-import { parsedOptions } from "./options.mjs";
-import { Route } from "./route.mjs";
-import { RouteTaskController, createRouteTask } from "./route-task.mjs";
-import { RouteType } from "./types.mjs";
-function createRealOptions() {
-  return parsedOptions({
-    base: new URL("http://localhost/"),
-    routes: [
-      { path: "/test", component: "TestComponent" },
-      { path: "/about", component: "AboutComponent" },
-      { path: "/redirected", component: "RedirectedComponent" },
-      { path: "/admin", component: "AdminComponent" },
-      { path: "/login", component: "LoginComponent" },
-      { path: "/home", component: "HomeComponent" }
-    ]
-  });
-}
-function createMockRouter() {
-  const options = createRealOptions();
-  return {
-    parsedOptions: options
-  };
-}
-describe("createRouteTask", () => {
-  it("should return original route when task array is empty", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const tasks = [];
-    const result = await createRouteTask({
-      to,
-      from,
-      tasks,
-      router
-    });
-    expect(result).toBe(to);
-  });
-  it("should execute tasks in sequence", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const executionOrder = [];
-    const firstTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task1");
-      return;
-    };
-    const secondTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task2");
-      return async () => ({ success: true });
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: firstTask
-      },
-      {
-        name: "override",
-        task: secondTask
-      }
-    ];
-    const result = await createRouteTask({
-      to,
-      from,
-      tasks,
-      router
-    });
-    expect(executionOrder).toEqual(["task1", "task2"]);
-    expect(result).toBe(to);
-    expect(to.handle).toBeTypeOf("function");
-  });
-  it("should set handle when task returns a function", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const handleFunction = async (to2, from2, router2) => {
-      return { message: "Route handled successfully" };
-    };
-    const successTask = async (route, fromRoute, router2) => {
-      return handleFunction;
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: successTask
-      }
-    ];
-    const result = await createRouteTask({
-      to,
-      from,
-      tasks,
-      router
-    });
-    expect(result).toBe(to);
-    expect(to.handle).toBeTypeOf("function");
-    expect(to.handle).not.toBeNull();
-  });
-  it("should throw RouteNavigationAbortedError when task returns false", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const blockingTask = async (route, fromRoute, router2) => {
-      const shouldProceed = false;
-      return shouldProceed ? void 0 : false;
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: blockingTask
-      }
-    ];
-    await expect(
-      createRouteTask({
-        to,
-        from,
-        tasks,
-        router
-      })
-    ).rejects.toThrow(RouteNavigationAbortedError);
-  });
-  it("should handle redirection when task returns a route location string", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const redirectTask = async (route, fromRoute, router2) => {
-      if (route.path === "/test") {
-        return "/redirected";
-      }
-      return;
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: redirectTask
-      }
-    ];
-    const result = await createRouteTask({
-      to,
-      from,
-      tasks,
-      router
-    });
-    expect(result).toBeInstanceOf(Route);
-    expect(result.path).toBe("/redirected");
-  });
-  it("should throw RouteTaskExecutionError when task throws an error", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const errorTask = async (route, fromRoute, router2) => {
-      throw new Error("Task execution failed");
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: errorTask
-      }
-    ];
-    await expect(
-      createRouteTask({
-        to,
-        from,
-        tasks,
-        router
-      })
-    ).rejects.toThrow(RouteTaskExecutionError);
-  });
-  it("should handle non-Error exceptions and convert them to Error instances", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const stringErrorTask = async (route, fromRoute, router2) => {
-      throw "String error message";
-    };
-    const numberErrorTask = async (route, fromRoute, router2) => {
-      throw 404;
-    };
-    const objectErrorTask = async (route, fromRoute, router2) => {
-      throw { code: "CUSTOM_ERROR", message: "Custom error object" };
-    };
-    const stringTasks = [
-      { name: "stringError", task: stringErrorTask }
-    ];
-    try {
-      await createRouteTask({ to, from, tasks: stringTasks, router });
-    } catch (error) {
-      expect(error).toBeInstanceOf(RouteTaskExecutionError);
-      expect(
-        error.originalError
-      ).toBeInstanceOf(Error);
-      expect(
-        error.originalError.message
-      ).toBe("String error message");
-    }
-    const numberTasks = [
-      { name: "numberError", task: numberErrorTask }
-    ];
-    try {
-      await createRouteTask({ to, from, tasks: numberTasks, router });
-    } catch (error) {
-      expect(error).toBeInstanceOf(RouteTaskExecutionError);
-      expect(
-        error.originalError
-      ).toBeInstanceOf(Error);
-      expect(
-        error.originalError.message
-      ).toBe("404");
-    }
-    const objectTasks = [
-      { name: "objectError", task: objectErrorTask }
-    ];
-    try {
-      await createRouteTask({ to, from, tasks: objectTasks, router });
-    } catch (error) {
-      expect(error).toBeInstanceOf(RouteTaskExecutionError);
-      expect(
-        error.originalError
-      ).toBeInstanceOf(Error);
-      expect(
-        error.originalError.message
-      ).toBe("[object Object]");
-    }
-  });
-  it("should not execute subsequent tasks once an error is thrown", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const executionOrder = [];
-    const firstTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task1");
-      throw new Error("Task failed");
-    };
-    const secondTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task2");
-      return;
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: firstTask
-      },
-      {
-        name: "beforeEnter",
-        task: secondTask
-      }
-    ];
-    await expect(
-      createRouteTask({
-        to,
-        from,
-        tasks,
-        router
-      })
-    ).rejects.toThrow(RouteTaskExecutionError);
-    expect(executionOrder).toEqual(["task1"]);
-  });
-  it("should handle null from route parameter", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const checkFromRouteTask = async (route, fromRoute, router2) => {
-      expect(fromRoute).toBeNull();
-      return async () => ({ success: true });
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: checkFromRouteTask
-      }
-    ];
-    const result = await createRouteTask({
-      to,
-      from: null,
-      tasks,
-      router
-    });
-    expect(result).toBe(to);
-    expect(to.handle).toBeTypeOf("function");
-  });
-  it("should pass the correct to and from parameters to tasks", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const firstTask = async (route, fromRoute, router2) => {
-      expect(route).toBe(to);
-      expect(fromRoute).toBe(from);
-      return;
-    };
-    const secondTask = async (route, fromRoute, router2) => {
-      expect(route).toBe(to);
-      expect(fromRoute).toBe(from);
-      return false;
-    };
-    const thirdTask = async (route, fromRoute, router2) => {
-      throw new Error("This should not be executed");
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: firstTask
-      },
-      {
-        name: "beforeEnter",
-        task: secondTask
-      },
-      {
-        name: "confirm",
-        task: thirdTask
-      }
-    ];
-    await expect(
-      createRouteTask({
-        to,
-        from,
-        tasks,
-        router
-      })
-    ).rejects.toThrow(RouteNavigationAbortedError);
-  });
-  it("should execute all tasks until one returns a result", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const from = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/home"
-    });
-    const executionOrder = [];
-    const firstTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task1");
-      return;
-    };
-    const handleFunction = async (to2, from2, router2) => {
-      return { message: "Route handled" };
-    };
-    const secondTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task2");
-      return handleFunction;
-    };
-    const thirdTask = async (route, fromRoute, router2) => {
-      executionOrder.push("task3");
-      return;
-    };
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: firstTask
-      },
-      {
-        name: "beforeEnter",
-        task: secondTask
-      },
-      {
-        name: "confirm",
-        task: thirdTask
-      }
-    ];
-    const result = await createRouteTask({
-      to,
-      from,
-      tasks,
-      router
-    });
-    expect(result).toBe(to);
-    expect(to.handle).toBeTypeOf("function");
-    expect(to.handle).not.toBe(null);
-    expect(executionOrder).toEqual(["task1", "task2"]);
-  });
-  describe("Task cancellation with RouteTaskController", () => {
-    it("should cancel task when abort is called before task execution", async () => {
-      const router = createMockRouter();
-      const to = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/test"
-      });
-      const from = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/home"
-      });
-      const controller = new RouteTaskController();
-      const firstTask = async (route, fromRoute, router2) => {
-        throw new Error("This should not be executed");
-      };
-      const secondTask = async (route, fromRoute, router2) => {
-        throw new Error("This should also not be executed");
-      };
-      const tasks = [
-        {
-          name: "beforeEach",
-          task: firstTask
-        },
-        {
-          name: "beforeEnter",
-          task: secondTask
-        }
-      ];
-      controller.abort();
-      await expect(
-        createRouteTask({
-          to,
-          from,
-          tasks,
-          controller,
-          router
-        })
-      ).rejects.toThrow(RouteTaskCancelledError);
-    });
-    it("should cancel task when abort is called after first task execution", async () => {
-      const router = createMockRouter();
-      const to = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/test"
-      });
-      const from = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/home"
-      });
-      const controller = new RouteTaskController();
-      const firstTask = async (route, fromRoute, router2) => {
-        controller.abort();
-        return;
-      };
-      const secondTask = async (route, fromRoute, router2) => {
-        throw new Error("This should not be executed");
-      };
-      const tasks = [
-        {
-          name: "beforeEach",
-          task: firstTask
-        },
-        {
-          name: "beforeEnter",
-          task: secondTask
-        }
-      ];
-      await expect(
-        createRouteTask({
-          to,
-          from,
-          tasks,
-          controller,
-          router
-        })
-      ).rejects.toThrow(RouteTaskCancelledError);
-    });
-    it("should not throw error on shouldCancel if controller is provided", async () => {
-      const router = createMockRouter();
-      const to = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/test"
-      });
-      const from = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/home"
-      });
-      const handleTask = async (route, fromRoute, router2) => {
-        return async () => ({ success: true });
-      };
-      const tasks = [
-        {
-          name: "beforeEach",
-          task: handleTask
-        }
-      ];
-      const result = await createRouteTask({
-        to,
-        from,
-        tasks,
-        router
-      });
-      expect(result).toBe(to);
-      expect(result == null ? void 0 : result.handle).toBeTypeOf("function");
-    });
-  });
-  describe("Real scenario test", () => {
-    it("should correctly handle RouteTaskOptions type verification", async () => {
-      const router = createMockRouter();
-      const to = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/test"
-      });
-      const from = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/home"
-      });
-      const tasks = [];
-      const routeTaskOptions = {
-        to,
-        from,
-        tasks,
-        router
-      };
-      const result = await createRouteTask(routeTaskOptions);
-      expect(result).toBe(to);
-    });
-    it("should correctly handle RouteTaskOptions with controller", async () => {
-      const router = createMockRouter();
-      const to = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/test"
-      });
-      const from = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/home"
-      });
-      const tasks = [];
-      const controller = new RouteTaskController();
-      const routeTaskOptions = {
-        to,
-        from,
-        tasks,
-        router,
-        controller
-      };
-      const result = await createRouteTask(routeTaskOptions);
-      expect(result).toBe(to);
-    });
-    it("should correctly create real task function interface", async () => {
-      const router = createMockRouter();
-      const to = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/test"
-      });
-      const from = new Route({
-        options: router.parsedOptions,
-        toType: RouteType.push,
-        toInput: "/home"
-      });
-      const realTaskFunction = async (route, fromRoute, router2) => {
-        expect(route).toBeInstanceOf(Route);
-        expect(fromRoute).toBeInstanceOf(Route);
-        expect(router2).toBeDefined();
-        return async () => ({ success: true });
-      };
-      const tasks = [
-        {
-          name: "beforeEach",
-          task: realTaskFunction
-        }
-      ];
-      const result = await createRouteTask({
-        to,
-        from,
-        tasks,
-        router
-      });
-      expect(result).toBe(to);
-      expect(to.handle).toBeTypeOf("function");
-    });
-  });
-});
-describe("RouteTaskController", () => {
-  it("should handle task cancellation", async () => {
-    const router = createMockRouter();
-    const to = new Route({
-      options: router.parsedOptions,
-      toType: RouteType.push,
-      toInput: "/test"
-    });
-    const controller = new RouteTaskController();
-    controller.abort();
-    const tasks = [
-      {
-        name: "beforeEach",
-        task: async () => async () => ({ success: true })
-      }
-    ];
-    await expect(
-      createRouteTask({
-        to,
-        from: null,
-        tasks,
-        router,
-        controller
-      })
-    ).rejects.toThrow(RouteTaskCancelledError);
-  });
-});

package/dist/route-transition.test.d.ts

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