Fixed circular dependency warning

src/index.js

@@ -1,7 +1,6 @@
-import { setRoute } from "./router/routes";
+import { updateRoute } from "./router/routes";
 
-window.onpopstate = setRoute;
+window.onpopstate = updateRoute;
 
-export { defineRoutes } from "./router/routes";
-export { navigate } from "./router/navigate";
+export { defineRoutes, navigate } from "./router/routes";
 export { default } from "./router/Router.svelte";

src/router/guard.js

@@ -1,5 +1,3 @@
-import { navigate } from "./navigate";
-
 /**
  * Checks if route can be accessed.
  * @returns true if route can be accessed.
@@ -9,8 +7,7 @@ export function guardRoute(route) {
         for (let i = 0; i < route.guards.length; i++) {
             const path = route.guards[i](route.path);
             if (path !== true) {
-                navigate(path);
-                return false;
+                return path;
             }
         }
     }

src/router/routes.js

@@ -9,7 +9,7 @@ var allRoutes = [];
  */
 export function defineRoutes(routes) {
     allRoutes = routes;
-    setRoute();
+    updateRoute();
 }
 
 /**
@@ -21,12 +21,28 @@ export function getRoute(path) {
     return allRoutes.filter(route => route.path === path)[0];
 }
 
+/**
+ * Navigates to the specified path.
+ * @param {string} path to the page (e.g "home").
+ */
+export function navigate(path) {
+    const newRoute = getRoute(path);
+    if (newRoute) {
+        location.hash = newRoute.path; 
+    }
+}
+
 /**
  * Sets the route for the current page.
  */
-export function setRoute() { 
+export function updateRoute() { 
     const newRoute = getRoute(location.hash.substring(1));
-    if (newRoute && guardRoute(newRoute)) {
-        currentPage.set(newRoute.component);    
+    if (newRoute) {
+        const guard = guardRoute(newRoute);
+        if (guard === true) {
+            currentPage.set(newRoute.component); 
+        } else if (guard !== false) {
+            navigate(guard);
+        }   
     }
 }

test/guard.spec.js

@@ -34,13 +34,13 @@ describe("guard", () => {
         expect(guard).toBe(false);
     });
 
-    test("guardRoute should navigate if guards return path", () => {
+    test("guardRoute should return route path if guards return path", () => {
         const expectedPath = "test1";
         const route = {path: expectedPath, guards: [function(path) {return expectedPath}]};
         defineRoutes([route]);
 
-        guardRoute(route);
+        const reroute = guardRoute(route);
 
-        expect(location.hash).toBe("#" + expectedPath);
+        expect(reroute).toBe(expectedPath);
     });
 });

test/routes.spec.js

@@ -1,4 +1,4 @@
-import { getRoute, defineRoutes, setRoute } from "../src/router/routes";
+import { getRoute, defineRoutes, updateRoute, navigate } from "../src/router/routes";
 import { currentPage } from "../src/router/page";
 import { get } from "svelte/store";
 
@@ -19,37 +19,69 @@ describe("routes", () => {
         expect(actualRoute).toBe(expectedRoute);
     });
 
-    test("setRoute should update currentPage", () => {
+    test("updateRoute should update currentPage", () => {
         currentPage.set({});
         const route = {path: "test", component: "TestComponent"};
         location.hash = route.path;
         defineRoutes([route]);
 
-        setRoute();
+        updateRoute();
 
         expect(get(currentPage)).toBe(route.component);
     });
 
-    test("setRoute should not update currentPage if route is missing", () => {
+    test("updateRoute should not update currentPage if route is missing", () => {
         const component = "TestComp";
         currentPage.set(component);
         location.hash = "test2";
         defineRoutes([]);
 
-        setRoute();
+        updateRoute();
 
         expect(get(currentPage)).toBe(component);
     });
 
-    test("setRoute should not update currentPage if route guard returns false", () => {
+    test("updateRoute should not update currentPage if route guard returns false", () => {
         const component = "TestComp";
         currentPage.set(component);
         const route = {path: "test", guards: [function(path) {return false}]};
         location.hash = route.path;
         defineRoutes([route]);
 
-        setRoute();
+        updateRoute();
 
         expect(get(currentPage)).toBe(component);
     });
+
+    test("updateRoute should reroute if route guard returns path", () => {
+        const component = "TestComp";
+        const rerouteComponent = "RerouteComp";
+        currentPage.set(component);
+        const reroute = {path: "reroute", component: rerouteComponent}
+        const route = {path: "test", guards: [function(path) {return reroute.path}]};
+        location.hash = route.path;
+        defineRoutes([route, reroute]);
+
+        updateRoute();
+
+        expect(get(currentPage)).toBe(rerouteComponent);
+    });
+
+    test("navigate should update location hash for existing route", () => {
+        const path = "test";
+        defineRoutes([{path}]);
+
+        navigate(path);
+
+        expect(location.hash).toBe("#" + path);
+    });
+
+    test("navigate should not update location hash for missing path", () => {
+        const path = "test";
+        location.hash = path
+
+        navigate("hello");
+
+        expect(location.hash).toBe("#" + path);
+    });
 });