@xmachines/play-router 1.0.0-beta.1

package/test/connect-route-map.test.ts

@@ -0,0 +1,320 @@
+import { describe, expect, test, vi } from "vitest";
+import { Signal } from "@xmachines/play-signals";
+import { createRouteMap } from "../src/create-route-map.js";
+import { connectRouter } from "../src/connect-router.js";
+
+function createNode(id: string, fullPath: string, pattern?: string): any {
+	return {
+		id,
+		path: fullPath,
+		fullPath,
+		pattern,
+		stateId: id,
+		routable: true,
+		children: [] as any[],
+		parent: null as any,
+		metadata: {},
+	};
+}
+
+function createRouteTree(...nodes: Array<ReturnType<typeof createNode>>) {
+	const root = createNode("root", "/");
+	root.children = nodes;
+	for (const node of nodes) {
+		node.parent = root;
+	}
+
+	const byPath = new Map<string, (typeof nodes)[number]>();
+	const byStateId = new Map<string, (typeof nodes)[number]>();
+	for (const node of nodes) {
+		byPath.set(node.fullPath, node);
+		byStateId.set(node.id, node);
+	}
+
+	return {
+		root,
+		byPath,
+		byStateId,
+	};
+}
+
+describe("createRouteMap", () => {
+	test("resolves exact matches without params", () => {
+		const tree = createRouteTree(createNode("dashboard", "/dashboard"));
+		const routeMap = createRouteMap(tree as any);
+
+		expect(routeMap.resolve("/dashboard")).toEqual({
+			to: "#dashboard",
+			params: {},
+		});
+	});
+
+	test("resolves URLPattern routes with params", () => {
+		const tree = createRouteTree(createNode("docs", "/docs/*", "/docs/*"));
+		const routeMap = createRouteMap(tree as any);
+
+		const resolved = routeMap.resolve("/docs/guides/install");
+		expect(resolved.to).toBe("#docs");
+		expect(Object.keys(resolved.params).length).toBeGreaterThan(0);
+	});
+
+	test("ignores invalid patterns and warns once", () => {
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const tree = createRouteTree(createNode("broken", "/broken", "("));
+
+		const routeMap = createRouteMap(tree as any);
+		expect(routeMap.resolve("/broken")).toEqual({ to: "#broken", params: {} });
+		expect(warnSpy).toHaveBeenCalled();
+
+		warnSpy.mockRestore();
+	});
+});
+
+describe("connectRouter", () => {
+	test("sends initial play.route when URL and actor route differ", () => {
+		const send = vi.fn();
+		const actor = {
+			send,
+			currentRoute: new Signal.State("/home"),
+		} as any;
+
+		let listener: ((location: { pathname: string }) => void) | undefined;
+		const unsubscribe = vi.fn();
+		const history = {
+			location: { pathname: "/dashboard", search: "", hash: "", state: null },
+			subscribe(fn: (location: { pathname: string }) => void) {
+				listener = fn;
+				return unsubscribe;
+			},
+			push: vi.fn(),
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve(pathname: string) {
+					return pathname === "/dashboard"
+						? { to: "#dashboard", params: {} }
+						: { to: null, params: {} };
+				},
+			},
+		});
+
+		expect(listener).toBeTypeOf("function");
+		expect(send).toHaveBeenCalledWith({
+			type: "play.route",
+			to: "#dashboard",
+			params: {},
+		});
+
+		disconnect();
+		expect(unsubscribe).toHaveBeenCalledTimes(1);
+	});
+
+	test("replaces history when actor redirects during history navigation", () => {
+		const actor = {
+			send: vi.fn(),
+			currentRoute: new Signal.State("/login"),
+		} as any;
+
+		let listener: ((location: { pathname: string }) => void) | undefined;
+		const history = {
+			location: { pathname: "/login", search: "", hash: "", state: null },
+			subscribe(fn: (location: { pathname: string }) => void) {
+				listener = fn;
+				return () => {};
+			},
+			push: vi.fn(),
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve(pathname: string) {
+					return pathname === "/login"
+						? { to: "#login", params: {} }
+						: { to: null, params: {} };
+				},
+			},
+		});
+
+		actor.currentRoute.set("/");
+		listener?.({ pathname: "/login" });
+
+		expect(history.replace).toHaveBeenCalledWith("/");
+		disconnect();
+	});
+
+	test("does not replace history when actor route equals incoming location", () => {
+		const actor = {
+			send: vi.fn(),
+			currentRoute: new Signal.State("/login"),
+		} as any;
+
+		let listener: ((location: { pathname: string }) => void) | undefined;
+		const history = {
+			location: { pathname: "/home", search: "", hash: "", state: null },
+			subscribe(fn: (location: { pathname: string }) => void) {
+				listener = fn;
+				return () => {};
+			},
+			push: vi.fn(),
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve(pathname: string) {
+					return pathname === "/login"
+						? { to: "#login", params: {} }
+						: { to: null, params: {} };
+				},
+			},
+		});
+
+		listener?.({ pathname: "/login" });
+
+		expect(history.replace).not.toHaveBeenCalled();
+		disconnect();
+	});
+
+	test("ignores unknown history path and does not send play.route", () => {
+		const actor = {
+			send: vi.fn(),
+			currentRoute: new Signal.State("/home"),
+		} as any;
+
+		let listener: ((location: { pathname: string }) => void) | undefined;
+		const history = {
+			location: { pathname: "/home", search: "", hash: "", state: null },
+			subscribe(fn: (location: { pathname: string }) => void) {
+				listener = fn;
+				return () => {};
+			},
+			push: vi.fn(),
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve() {
+					return { to: null, params: {} };
+				},
+			},
+		});
+
+		actor.send.mockClear();
+		listener?.({ pathname: "/unknown" });
+
+		expect(actor.send).not.toHaveBeenCalled();
+		disconnect();
+	});
+
+	test("skips history subscriber when history change was triggered by actor sync", async () => {
+		const actor = {
+			send: vi.fn(),
+			currentRoute: new Signal.State("/home"),
+		} as any;
+
+		let listener: ((location: { pathname: string }) => void) | undefined;
+		const history = {
+			location: { pathname: "/home", search: "", hash: "", state: null },
+			subscribe(fn: (location: { pathname: string }) => void) {
+				listener = fn;
+				return () => {};
+			},
+			push(path: string) {
+				listener?.({ pathname: path });
+			},
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve(pathname: string) {
+					return pathname === "/dashboard"
+						? { to: "#dashboard", params: {} }
+						: { to: null, params: {} };
+				},
+			},
+		});
+
+		actor.send.mockClear();
+		actor.currentRoute.set("/dashboard");
+		await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+		expect(actor.send).not.toHaveBeenCalled();
+		disconnect();
+	});
+
+	test("does not push history when actor route is unchanged", async () => {
+		const actor = {
+			send: vi.fn(),
+			currentRoute: new Signal.State("/home"),
+		} as any;
+
+		const history = {
+			location: { pathname: "/home", search: "", hash: "", state: null },
+			subscribe() {
+				return () => {};
+			},
+			push: vi.fn(),
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve() {
+					return { to: null, params: {} };
+				},
+			},
+		});
+
+		actor.currentRoute.set("/home");
+		await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+		expect(history.push).not.toHaveBeenCalled();
+		disconnect();
+	});
+
+	test("skips initial route send when URL differs but route map has no match", () => {
+		const actor = {
+			send: vi.fn(),
+			currentRoute: new Signal.State("/home"),
+		} as any;
+
+		const history = {
+			location: { pathname: "/unknown", search: "", hash: "", state: null },
+			subscribe() {
+				return () => {};
+			},
+			push: vi.fn(),
+			replace: vi.fn(),
+		} as any;
+
+		const disconnect = connectRouter({
+			actor,
+			router: { history } as any,
+			routeMap: {
+				resolve() {
+					return { to: null, params: {} };
+				},
+			},
+		});
+
+		expect(actor.send).not.toHaveBeenCalled();
+		disconnect();
+	});
+});