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

package/index.cjs

@@ -0,0 +1,406 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  RedirectError: () => RedirectError,
+  createRouter: () => createRouter,
+  createRoutes: () => createRoutes,
+  history: () => history,
+  loadComponentToConfig: () => loadComponentToConfig,
+  replaceDynamicValues: () => replaceDynamicValues,
+  routerSetLoadedComponent: () => routerSetLoadedComponent
+});
+module.exports = __toCommonJS(core_exports);
+
+// packages/core/utils/constants.ts
+var constants = {
+  dynamicSeparator: ":",
+  pathPartSeparator: "/",
+  isClient: typeof window !== "undefined"
+};
+
+// packages/core/utils/dynamic.ts
+function isDynamic(param) {
+  return param[0] === constants.dynamicSeparator;
+}
+function clearDynamic(param) {
+  return param.replace(new RegExp(`^${constants.dynamicSeparator}`), "");
+}
+
+// packages/core/utils/getDynamicValues.ts
+function getDynamicValues(params) {
+  const { route, pathname } = params;
+  const pathnameArray = pathname.replace(/\?.+$/, "").split(constants.pathPartSeparator).filter(Boolean).map((str) => decodeURIComponent(str));
+  const routePathnameArray = route.path.split(constants.pathPartSeparator).filter(Boolean);
+  const dynamicParams = {};
+  for (let i = 0; i < routePathnameArray.length; i++) {
+    const paramName = routePathnameArray[i];
+    if (isDynamic(paramName)) dynamicParams[clearDynamic(paramName)] = pathnameArray[i];
+  }
+  return dynamicParams;
+}
+
+// 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 = queryString.extract(pathname);
+  if (!qs || !route.query) return {};
+  const query = queryString.parse(qs);
+  getTypedEntries(query).forEach(([key, value]) => {
+    const validator = route.query[key];
+    if (typeof validator !== "function" || !validator(value)) {
+      delete query[key];
+    }
+  });
+  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;
+
+// packages/core/utils/loadComponentToConfig.ts
+function loadComponentToConfig(params) {
+  const { route } = params;
+  if (!route.component) {
+    return route.loader().then((module2) => {
+      const { default: component, ...rest } = module2;
+      route.component = component;
+      route.otherExports = rest;
+    });
+  }
+  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({
+  route,
+  params = {}
+}) {
+  return route.path.replace(re, (paramName) => {
+    if (!isDynamic(paramName)) return paramName;
+    const value = params[clearDynamic(paramName)];
+    if (!value) {
+      throw new Error(
+        `replaceDynamicValues: no param "${paramName}" passed for route ${route.name}`
+      );
+    }
+    return encodeURIComponent(value);
+  });
+}
+
+// packages/core/createRouter.ts
+function createRouter(config) {
+  const router = config.adapters.makeObservable({
+    routesHistory: [],
+    currentRoute: {},
+    isRedirecting: false,
+    redirect: void 0,
+    restoreFromURL: void 0,
+    restoreFromServer: void 0,
+    get adapters() {
+      return config.adapters;
+    },
+    get routes() {
+      return config.routes;
+    },
+    get lifecycleParams() {
+      return config.lifecycleParams;
+    }
+  });
+  router.restoreFromServer = function restoreFromServer(obj) {
+    router.adapters.batch(() => {
+      router.routesHistory.push(...obj.routesHistory || []);
+      Object.assign(router.currentRoute, obj.currentRoute);
+    });
+    const preloadedRouteName = Object.keys(router.routes).find(
+      (routeName) => router.currentRoute.name === routeName
+    );
+    return loadComponentToConfig({ route: router.routes[preloadedRouteName] });
+  };
+  router.restoreFromURL = function restoreFromURL(params) {
+    return router.redirect(getInitialRoute({ routes: router.routes, ...params }));
+  };
+  router.redirect = async function redirect(config2) {
+    const { route: routeName, replace } = config2;
+    let currentRoute;
+    let currentPathname;
+    let currentUrl;
+    let currentSearch;
+    let currentQuery;
+    if (router.currentRoute?.name) {
+      currentRoute = router.routes[router.currentRoute.name];
+      currentPathname = replaceDynamicValues({
+        route: currentRoute,
+        params: router.currentRoute.params
+      });
+      currentQuery = router.currentRoute.query;
+      currentSearch = queryString.stringify(router.currentRoute.query);
+      currentUrl = `${currentPathname}${currentSearch ? `?${currentSearch}` : ""}`;
+    }
+    const nextRoute = router.routes[routeName];
+    const nextPathname = replaceDynamicValues({
+      route: nextRoute,
+      params: "params" in config2 ? config2.params : void 0
+    });
+    let nextQuery;
+    let nextUrl = nextPathname;
+    let nextSearch;
+    if ("query" in config2 && config2.query) {
+      const clearedQuery = getQueryValues({
+        route: nextRoute,
+        pathname: `${nextPathname}?${queryString.stringify(config2.query)}`
+      });
+      if (Object.keys(clearedQuery).length > 0) {
+        nextQuery = clearedQuery;
+        nextSearch = queryString.stringify(clearedQuery);
+        nextUrl = `${nextPathname}?${nextSearch}`;
+      }
+    }
+    if (currentUrl === nextUrl) return Promise.resolve();
+    if (currentPathname === nextPathname) {
+      if (currentSearch !== nextSearch) {
+        router.adapters.batch(() => {
+          router.adapters.replaceObject(router.currentRoute, {
+            ...router.currentRoute,
+            query: nextQuery || {}
+          });
+          router.routesHistory.push(nextUrl);
+        });
+        if (history && !replace) {
+          history.push({
+            hash: history.location.hash,
+            search: nextSearch,
+            pathname: nextPathname
+          });
+        }
+      }
+      return Promise.resolve();
+    }
+    router.adapters.batch(() => {
+      router.isRedirecting = true;
+    });
+    try {
+      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 ("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`);
+        }
+      };
+      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 instanceof PreventError) {
+        return Promise.resolve();
+      }
+      if (error instanceof RedirectError) {
+        throw error;
+      }
+      console.error(error);
+      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
+        });
+        router.isRedirecting = false;
+      });
+      return Promise.resolve();
+    }
+    router.adapters.batch(() => {
+      router.adapters.replaceObject(router.currentRoute, {
+        name: nextRoute.name,
+        path: nextRoute.path,
+        props: router.routes[nextRoute.name].props,
+        query: getQueryValues({ route: nextRoute, pathname: nextUrl }),
+        params: getDynamicValues({ route: nextRoute, pathname: nextUrl }),
+        pageId: router.routes[nextRoute.name].pageId
+      });
+      const lastUrl = router.routesHistory[router.routesHistory.length - 1];
+      if (lastUrl !== nextUrl) {
+        router.routesHistory.push(nextUrl);
+      }
+      if (history && !replace) {
+        history.push({
+          hash: history.location.hash,
+          search: "query" in config2 ? `?${queryString.stringify(config2.query)}` : "",
+          pathname: nextPathname
+        });
+      }
+      router.isRedirecting = false;
+    });
+    return Promise.resolve();
+  };
+  return router;
+}
+
+// packages/core/utils/addNames.ts
+function addNames(obj) {
+  Object.entries(obj).forEach(([key, value]) => {
+    value.name = key;
+  });
+  return obj;
+}
+
+// packages/core/createRoutes.ts
+function createRoutes(config) {
+  return addNames(config);
+}
+
+// packages/core/utils/routerSetLoadedComponent.ts
+function routerSetLoadedComponent(props, config) {
+  const currentRouteName = props.router.currentRoute.name;
+  const currentRoutePage = props.router.currentRoute.pageId;
+  const componentConfig = props.router.routes[currentRouteName];
+  let preventRedirect = false;
+  if (props.router.isRedirecting) preventRedirect = true;
+  else if (config.loadedComponentName === currentRouteName) preventRedirect = true;
+  else if (config.loadedComponentPage != null && currentRouteName != null) {
+    if (config.loadedComponentPage === currentRoutePage) {
+      props.router.adapters.batch(() => {
+        config.currentProps = "props" in componentConfig ? componentConfig.props || {} : {};
+      });
+      preventRedirect = true;
+    }
+  }
+  if (preventRedirect) return;
+  props.router.adapters.batch(() => {
+    if (config.loadedComponentName) props.beforeUpdatePageComponent?.();
+    props.beforeSetPageComponent?.(componentConfig);
+    config.currentProps = "props" in componentConfig ? componentConfig.props : {};
+    config.loadedComponentName = currentRouteName;
+    config.loadedComponentPage = componentConfig.pageId;
+  });
+}