reactive-route 0.0.1-alpha.3 → 0.0.1-alpha.30

package/{dist/cjs/index.js → index.cjs}

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,53 +15,25 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  createRouterConfig: () => createRouterConfig,
-  createRouterStore: () => createRouterStore,
-  findRouteByPathname: () => findRouteByPathname,
-  getInitialRoute: () => getInitialRoute,
+  RedirectError: () => RedirectError,
+  createRouter: () => createRouter,
+  createRoutes: () => createRoutes,
   history: () => history,
-  isDynamicRoute: () => isDynamicRoute,
   loadComponentToConfig: () => loadComponentToConfig,
   replaceDynamicValues: () => replaceDynamicValues
 });
 module.exports = __toCommonJS(core_exports);
 
-// packages/core/utils/addNames.ts
-function addNames(obj) {
-  Object.entries(obj).forEach(([key, value]) => {
-    value.name = key;
-  });
-  return obj;
-}
-
-// packages/core/createRouterConfig.ts
-function createRouterConfig(config) {
-  return addNames(config);
-}
-
-// packages/core/createRouterStore.ts
-var import_query_string2 = __toESM(require("query-string"));
-
 // packages/core/utils/constants.ts
 var constants = {
   dynamicSeparator: ":",
   pathPartSeparator: "/",
-  isClient: typeof window !== "undefined",
-  errorRedirect: "REDIRECT",
-  errorPrevent: "PREVENT_REDIRECT"
+  isClient: typeof window !== "undefined"
 };
 
 // packages/core/utils/dynamic.ts
@@ -73,9 +43,6 @@ function isDynamic(param) {
 function clearDynamic(param) {
   return param.replace(new RegExp(`^${constants.dynamicSeparator}`), "");
 }
-function isDynamicRoute(route) {
-  return "params" in route;
-}
 
 // packages/core/utils/getDynamicValues.ts
 function getDynamicValues(params) {
@@ -90,18 +57,65 @@ function getDynamicValues(params) {
   return dynamicParams;
 }
 
-// packages/core/utils/getQueryValues.ts
-var import_query_string = __toESM(require("query-string"));
+// packages/core/utils/findRouteByPathname.ts
+function completeStaticMatch(pathname, path) {
+  return !path.includes(constants.dynamicSeparator) && (pathname === path || pathname === `${path}${constants.pathPartSeparator}`);
+}
+function findRouteByPathname({
+  pathname,
+  routes
+}) {
+  let dynamicRouteMatch;
+  const pathnameArray = pathname.replace(/\?.+$/, "").split(constants.pathPartSeparator).filter(Boolean);
+  for (const routeName in routes) {
+    if (!Object.hasOwn(routes, routeName)) continue;
+    const route = routes[routeName];
+    if (completeStaticMatch(pathname, route.path)) return route;
+    if (dynamicRouteMatch) continue;
+    const routePathnameArray = route.path.split(constants.pathPartSeparator).filter(Boolean);
+    if (routePathnameArray.length !== pathnameArray.length) continue;
+    const someParamInvalid = routePathnameArray.some((paramName, i) => {
+      const paramFromUrl = pathnameArray[i];
+      if (!isDynamic(paramName)) return paramName !== paramFromUrl;
+      const validator = route.params?.[clearDynamic(paramName)];
+      if (typeof validator !== "function") {
+        throw new Error(`findRoute: missing validator for param "${paramName}"`);
+      }
+      return !validator(paramFromUrl);
+    });
+    if (!someParamInvalid) dynamicRouteMatch = route;
+  }
+  return dynamicRouteMatch;
+}
 
 // packages/core/utils/getTypedEntries.ts
 var getTypedEntries = Object.entries;
 
+// packages/core/utils/queryString.ts
+function removeHash(input) {
+  const hashStart = input.indexOf("#");
+  return hashStart === -1 ? input : input.slice(0, hashStart);
+}
+var queryString = {
+  extract(input) {
+    const inputNoHash = removeHash(input);
+    const queryStart = inputNoHash.indexOf("?");
+    return queryStart === -1 ? "" : inputNoHash.slice(queryStart + 1);
+  },
+  parse(input) {
+    return Object.fromEntries(new URLSearchParams(input));
+  },
+  stringify(obj) {
+    return new URLSearchParams(obj).toString();
+  }
+};
+
 // packages/core/utils/getQueryValues.ts
 function getQueryValues(params) {
   const { route, pathname } = params;
-  const qs = import_query_string.default.extract(pathname);
+  const qs = queryString.extract(pathname);
   if (!qs || !route.query) return {};
-  const query = import_query_string.default.parse(qs);
+  const query = queryString.parse(qs);
   getTypedEntries(query).forEach(([key, value]) => {
     const validator = route.query[key];
     if (typeof validator !== "function" || !validator(value)) {
@@ -111,6 +125,16 @@ function getQueryValues(params) {
   return query;
 }
 
+// packages/core/utils/getInitialRoute.ts
+function getInitialRoute(params) {
+  const route = findRouteByPathname({ pathname: params.pathname, routes: params.routes }) || params.routes.notFound;
+  return {
+    route: route.name,
+    query: getQueryValues({ route, pathname: params.pathname }),
+    params: getDynamicValues({ route, pathname: params.pathname })
+  };
+}
+
 // packages/core/utils/history.ts
 var import_history = require("history");
 var history = constants.isClient ? (0, import_history.createBrowserHistory)() : null;
@@ -118,18 +142,32 @@ var history = constants.isClient ? (0, import_history.createBrowserHistory)() :
 // packages/core/utils/loadComponentToConfig.ts
 function loadComponentToConfig(params) {
   const { route } = params;
-  if (!route.component && route.loader) {
-    const loadingFn = route.loader;
-    return loadingFn().then((module2) => {
-      const { default: component, pageName, ...rest } = module2;
+  if (!route.component) {
+    return route.loader().then((module2) => {
+      const { default: component, ...rest } = module2;
       route.component = component;
       route.otherExports = rest;
-      route.pageName = pageName;
     });
   }
   return Promise.resolve();
 }
 
+// packages/core/utils/PreventError.ts
+var PreventError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PreventError";
+  }
+};
+
+// packages/core/utils/RedirectError.ts
+var RedirectError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedirectError";
+  }
+};
+
 // packages/core/utils/replaceDynamicValues.ts
 var re = new RegExp(`[^${constants.pathPartSeparator}]+`, "g");
 function replaceDynamicValues({
@@ -148,87 +186,85 @@ function replaceDynamicValues({
   });
 }
 
-// packages/core/createRouterStore.ts
-function createRouterStore({
-  batch,
-  routes,
-  autorun,
-  replaceObject,
-  routeError500,
-  makeObservable,
-  lifecycleParams
-}) {
-  const routerStore = makeObservable({
+// packages/core/createRouter.ts
+function createRouter(config) {
+  const router = config.adapters.makeObservable({
     routesHistory: [],
     currentRoute: {},
     isRedirecting: false,
-    redirectTo: void 0,
+    redirect: void 0,
+    restoreFromURL: void 0,
     restoreFromServer: void 0,
-    utils: {
-      batch,
-      autorun,
-      replaceObject,
-      makeObservable
+    get adapters() {
+      return config.adapters;
+    },
+    get routes() {
+      return config.routes;
+    },
+    get lifecycleParams() {
+      return config.lifecycleParams;
     }
   });
-  routerStore.restoreFromServer = function restoreFromServer(obj) {
-    batch(() => {
-      routerStore.routesHistory.push(...obj.routesHistory || []);
-      Object.assign(routerStore.currentRoute, obj.currentRoute);
+  router.restoreFromServer = function restoreFromServer(obj) {
+    router.adapters.batch(() => {
+      router.routesHistory.push(...obj.routesHistory || []);
+      Object.assign(router.currentRoute, obj.currentRoute);
     });
-    const preloadedRouteName = Object.keys(routes).find(
-      (routeName) => routerStore.currentRoute.name === routeName
+    const preloadedRouteName = Object.keys(router.routes).find(
+      (routeName) => router.currentRoute.name === routeName
     );
-    return loadComponentToConfig({ route: routes[preloadedRouteName] });
+    return loadComponentToConfig({ route: router.routes[preloadedRouteName] });
+  };
+  router.restoreFromURL = function restoreFromURL(params) {
+    return router.redirect(getInitialRoute({ routes: router.routes, ...params }));
   };
-  routerStore.redirectTo = async function redirectTo(config) {
-    const { route: routeName, noHistoryPush, asClient } = config;
-    const isClient = typeof asClient === "boolean" ? asClient : constants.isClient;
+  router.redirect = async function redirect(config2) {
+    const { route: routeName, replace } = config2;
     let currentRoute;
     let currentPathname;
     let currentUrl;
     let currentSearch;
     let currentQuery;
-    if (routerStore.currentRoute?.name) {
-      currentRoute = routes[routerStore.currentRoute.name];
+    if (router.currentRoute?.name) {
+      currentRoute = router.routes[router.currentRoute.name];
       currentPathname = replaceDynamicValues({
         route: currentRoute,
-        params: routerStore.currentRoute.params
+        params: router.currentRoute.params
       });
-      currentUrl = import_query_string2.default.stringifyUrl({
-        url: currentPathname,
-        query: routerStore.currentRoute.query
-      });
-      currentQuery = routerStore.currentRoute.query;
-      currentSearch = import_query_string2.default.stringify(routerStore.currentRoute.query);
+      currentQuery = router.currentRoute.query;
+      currentSearch = queryString.stringify(router.currentRoute.query);
+      currentUrl = `${currentPathname}${currentSearch ? `?${currentSearch}` : ""}`;
     }
-    const nextRoute = routes[routeName];
+    const nextRoute = router.routes[routeName];
     const nextPathname = replaceDynamicValues({
       route: nextRoute,
-      params: "params" in config ? config.params : void 0
+      params: "params" in config2 ? config2.params : void 0
     });
     let nextQuery;
     let nextUrl = nextPathname;
     let nextSearch;
-    if ("query" in config && config.query) {
+    if ("query" in config2 && config2.query) {
       const clearedQuery = getQueryValues({
         route: nextRoute,
-        pathname: `${nextPathname}?${import_query_string2.default.stringify(config.query)}`
+        pathname: `${nextPathname}?${queryString.stringify(config2.query)}`
       });
       if (Object.keys(clearedQuery).length > 0) {
         nextQuery = clearedQuery;
-        nextSearch = import_query_string2.default.stringify(clearedQuery);
-        nextUrl = import_query_string2.default.stringifyUrl({ url: nextPathname, query: clearedQuery });
+        nextSearch = queryString.stringify(clearedQuery);
+        nextUrl = `${nextPathname}?${nextSearch}`;
       }
     }
     if (currentUrl === nextUrl) return Promise.resolve();
     if (currentPathname === nextPathname) {
       if (currentSearch !== nextSearch) {
-        batch(() => {
-          replaceObject(routerStore.currentRoute.query, nextQuery || {});
-          routerStore.routesHistory.push(nextUrl);
+        router.adapters.batch(() => {
+          router.adapters.replaceObject(router.currentRoute, {
+            ...router.currentRoute,
+            query: nextQuery || {}
+          });
+          router.routesHistory.push(nextUrl);
         });
-        if (history && !noHistoryPush) {
+        if (history && !replace) {
           history.push({
             hash: history.location.hash,
             search: nextSearch,
@@ -238,144 +274,106 @@ function createRouterStore({
       }
       return Promise.resolve();
     }
-    batch(() => {
-      routerStore.isRedirecting = true;
+    router.adapters.batch(() => {
+      router.isRedirecting = true;
     });
     try {
-      await currentRoute?.beforeLeave?.(
-        {
-          nextUrl,
-          nextRoute,
-          nextQuery,
-          nextSearch,
-          nextPathname,
-          currentUrl,
-          currentQuery,
-          currentRoute,
-          currentSearch,
-          currentPathname
-        },
-        ...lifecycleParams || []
-      );
-      const redirectConfig = await nextRoute.beforeEnter?.(
-        {
-          nextUrl,
-          nextRoute,
-          nextQuery,
-          nextSearch,
-          nextPathname,
-          currentUrl,
-          currentQuery,
-          currentRoute,
-          currentSearch,
-          currentPathname
-        },
-        ...lifecycleParams || []
-      );
-      if (typeof redirectConfig === "object") {
-        if (isClient) return redirectTo({ ...redirectConfig, asClient });
-        const redirectRoute = routes[redirectConfig.route];
-        const redirectParams = "params" in redirectConfig && redirectConfig.params ? redirectConfig.params : void 0;
-        let redirectUrl = replaceDynamicValues({
-          params: redirectParams,
-          route: redirectRoute
-        });
-        if ("query" in redirectConfig && redirectConfig.query) {
-          const clearedQuery = getQueryValues({
-            route: nextRoute,
-            pathname: `${nextPathname}?${import_query_string2.default.stringify(redirectConfig.query)}`
+      const config3 = {
+        nextUrl,
+        nextRoute,
+        nextQuery,
+        nextSearch,
+        nextPathname,
+        currentUrl,
+        currentQuery,
+        currentRoute,
+        currentSearch,
+        currentPathname,
+        redirect: (redirectConfig2) => {
+          if (constants.isClient) return redirectConfig2;
+          const redirectRoute = router.routes[redirectConfig2.route];
+          const redirectParams = "params" in redirectConfig2 && redirectConfig2.params ? redirectConfig2.params : void 0;
+          let redirectUrl = replaceDynamicValues({
+            params: redirectParams,
+            route: redirectRoute
           });
-          if (Object.keys(clearedQuery).length > 0) {
-            redirectUrl = import_query_string2.default.stringifyUrl({ url: redirectUrl, query: clearedQuery });
+          if ("query" in redirectConfig2 && redirectConfig2.query) {
+            const clearedQuery = getQueryValues({
+              route: nextRoute,
+              pathname: `${nextPathname}?${queryString.stringify(redirectConfig2.query)}`
+            });
+            if (Object.keys(clearedQuery).length > 0) {
+              redirectUrl = `${redirectUrl}?${queryString.stringify(clearedQuery)}`;
+            }
           }
+          throw new RedirectError(redirectUrl);
+        },
+        preventRedirect: () => {
+          throw new PreventError(`Redirect to ${nextUrl} was prevented`);
         }
-        throw Object.assign(new Error(redirectUrl), { name: constants.errorRedirect });
-      }
-      await loadComponentToConfig({ route: routes[nextRoute.name] });
+      };
+      await currentRoute?.beforeLeave?.(config3, ...router.lifecycleParams || []);
+      const redirectConfig = await nextRoute.beforeEnter?.(config3, ...router.lifecycleParams || []);
+      if (redirectConfig) return redirect(redirectConfig);
+      await loadComponentToConfig({ route: router.routes[nextRoute.name] });
     } catch (error) {
-      if (error?.name === constants.errorPrevent) return Promise.resolve();
-      if (error?.name === constants.errorRedirect) {
+      if (error instanceof PreventError) {
+        return Promise.resolve();
+      }
+      if (error instanceof RedirectError) {
         throw error;
       }
       console.error(error);
-      await loadComponentToConfig({ route: routeError500 });
-      batch(() => {
-        replaceObject(routerStore.currentRoute, {
-          name: routeError500.name,
-          path: routeError500.path,
-          props: routes[routeError500.name].props,
-          query: {},
-          params: {},
-          pageName: routes[routeError500.name].pageName
+      await loadComponentToConfig({ route: router.routes.internalError });
+      router.adapters.batch(() => {
+        router.adapters.replaceObject(router.currentRoute, {
+          name: router.routes.internalError.name,
+          path: router.routes.internalError.path,
+          props: router.routes[router.routes.internalError.name].props,
+          query: router.adapters.makeObservable({}),
+          params: router.adapters.makeObservable({}),
+          pageId: router.routes[router.routes.internalError.name].pageId
         });
-        routerStore.isRedirecting = false;
+        router.isRedirecting = false;
       });
       return Promise.resolve();
     }
-    batch(() => {
-      replaceObject(routerStore.currentRoute, {
+    router.adapters.batch(() => {
+      router.adapters.replaceObject(router.currentRoute, {
         name: nextRoute.name,
         path: nextRoute.path,
-        props: routes[nextRoute.name].props,
+        props: router.routes[nextRoute.name].props,
         query: getQueryValues({ route: nextRoute, pathname: nextUrl }),
         params: getDynamicValues({ route: nextRoute, pathname: nextUrl }),
-        pageName: routes[nextRoute.name].pageName
+        pageId: router.routes[nextRoute.name].pageId
       });
-      const lastUrl = routerStore.routesHistory[routerStore.routesHistory.length - 1];
+      const lastUrl = router.routesHistory[router.routesHistory.length - 1];
       if (lastUrl !== nextUrl) {
-        routerStore.routesHistory.push(nextUrl);
+        router.routesHistory.push(nextUrl);
       }
-      if (history && !noHistoryPush) {
+      if (history && !replace) {
         history.push({
           hash: history.location.hash,
-          search: "query" in config ? `?${import_query_string2.default.stringify(config.query)}` : "",
+          search: "query" in config2 ? `?${queryString.stringify(config2.query)}` : "",
           pathname: nextPathname
         });
       }
-      routerStore.isRedirecting = false;
+      router.isRedirecting = false;
     });
     return Promise.resolve();
   };
-  return routerStore;
+  return router;
 }
 
-// packages/core/utils/findRouteByPathname.ts
-function completeStaticMatch(pathname, path) {
-  return !path.includes(constants.dynamicSeparator) && (pathname === path || pathname === `${path}${constants.pathPartSeparator}`);
-}
-function findRouteByPathname({
-  pathname,
-  routes
-}) {
-  let dynamicRouteMatch;
-  const pathnameArray = pathname.replace(/\?.+$/, "").split(constants.pathPartSeparator).filter(Boolean);
-  for (const routeName in routes) {
-    if (!Object.hasOwn(routes, routeName)) continue;
-    const route = routes[routeName];
-    if (completeStaticMatch(pathname, route.path)) return route;
-    if (dynamicRouteMatch) continue;
-    const routePathnameArray = route.path.split(constants.pathPartSeparator).filter(Boolean);
-    if (routePathnameArray.length !== pathnameArray.length) continue;
-    const someParamInvalid = routePathnameArray.some((paramName, i) => {
-      const paramFromUrl = pathnameArray[i];
-      if (!isDynamic(paramName)) return paramName !== paramFromUrl;
-      const validator = route.params?.[clearDynamic(paramName)];
-      if (typeof validator !== "function") {
-        throw new Error(`findRoute: missing validator for param "${paramName}"`);
-      }
-      return !validator(paramFromUrl);
-    });
-    if (!someParamInvalid) dynamicRouteMatch = route;
-  }
-  return dynamicRouteMatch;
+// packages/core/utils/addNames.ts
+function addNames(obj) {
+  Object.entries(obj).forEach(([key, value]) => {
+    value.name = key;
+  });
+  return obj;
 }
 
-// packages/core/utils/getInitialRoute.ts
-function getInitialRoute(params) {
-  const route = findRouteByPathname({ pathname: params.pathname, routes: params.routes }) || params.routes[params.fallback];
-  return {
-    route: route.name,
-    query: getQueryValues({ route, pathname: params.pathname }),
-    params: getDynamicValues({ route, pathname: params.pathname })
-  };
+// packages/core/createRoutes.ts
+function createRoutes(config) {
+  return addNames(config);
 }