reactive-route 0.0.1-alpha.0 → 0.0.1-alpha.10

package/dist/cjs/solid/index.js

@@ -28,133 +28,74 @@ module.exports = __toCommonJS(solid_exports);
 var import_web = require("solid-js/web");
 var import_web2 = require("solid-js/web");
 var import_reactive_route = require("reactive-route");
-var import_solid_js2 = require("solid-js");
-var import_store2 = require("solid-js/store");
-var import_web3 = require("solid-js/web");
-
-// packages/solid/replaceObject.ts
-var import_store = require("solid-js/store");
-function replaceObject(obj, newObj) {
-  (0, import_store.modifyMutable)(obj, (0, import_store.produce)((state) => {
-    if (typeof state === "object" && state != null) {
-      for (const variableKey in state) {
-        delete state[variableKey];
-      }
-    }
-    Object.assign(state || {}, newObj);
-  }));
-}
-
-// packages/solid/useStore.ts
 var import_solid_js = require("solid-js");
-var getAllProperties = (object) => {
-  const properties = /* @__PURE__ */ new Set();
-  do {
-    for (const key of Reflect.ownKeys(object)) {
-      properties.add([object, key]);
-    }
-  } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
-  return properties;
-};
-function autoBind(self) {
-  for (const [object, key] of getAllProperties(self.constructor.prototype)) {
-    if (key === "constructor") continue;
-    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
-    if (descriptor && typeof descriptor.value === "function") {
-      self[key] = self[key].bind(self);
-    }
-  }
-  return self;
-}
-function useStore(ViewModel, props) {
-  const vm = new ViewModel(props);
-  autoBind(vm);
-  vm.beforeMount?.();
-  (0, import_solid_js.onMount)(() => {
-    vm.afterMount?.();
+var import_web3 = require("solid-js/web");
+function Router(props) {
+  const config = props.routerStore.adapters.makeObservable({
+    loadedComponentName: void 0,
+    loadedComponentPage: void 0,
+    currentProps: {}
   });
-  return vm;
-}
-
-// packages/solid/Router.tsx
-var VM = class {
-  constructor(props) {
-    this.props = props;
-    return (0, import_store2.createMutable)(this);
-  }
-  loadedComponentName = void 0;
-  loadedComponentPage = void 0;
-  currentProps = {};
-  beforeMount() {
-    this.props.beforeMount?.();
-    this.redirectOnHistoryPop();
-    (0, import_solid_js2.createRenderEffect)(() => this.setLoadedComponent());
-  }
-  redirectOnHistoryPop() {
+  function redirectOnHistoryPop() {
     if (!import_reactive_route.history) return;
     import_reactive_route.history.listen((params) => {
       if (params.action !== "POP") return;
-      const previousRoutePathname = this.props.routerStore.routesHistory[this.props.routerStore.routesHistory.length - 2];
+      const previousRoutePathname = props.routerStore.routesHistory[props.routerStore.routesHistory.length - 2];
       if (previousRoutePathname === params.location.pathname) {
-        this.props.routerStore.routesHistory.pop();
+        props.routerStore.routesHistory.pop();
       }
-      void this.props.routerStore.redirectTo({
+      void props.routerStore.redirectTo({
         noHistoryPush: true,
         ...(0, import_reactive_route.getInitialRoute)({
-          routes: this.props.routes,
+          routes: props.routes,
           pathname: import_reactive_route.history.location.pathname,
           fallback: "error404"
         })
       });
     });
   }
-  setLoadedComponent() {
-    const currentRouteName = this.props.routerStore.currentRoute.name;
-    const currentRoutePage = this.props.routerStore.currentRoute.pageName;
+  function setLoadedComponent() {
+    const currentRouteName = props.routerStore.currentRoute.name;
+    const currentRoutePage = props.routerStore.currentRoute.pageName;
+    const componentConfig = props.routes[currentRouteName];
     let preventRedirect = false;
-    if (this.props.routerStore.isRedirecting) preventRedirect = true;
-    else if (this.loadedComponentName === currentRouteName) {
+    if (props.routerStore.isRedirecting) preventRedirect = true;
+    else if (config.loadedComponentName === currentRouteName) {
       preventRedirect = true;
-    } else if (this.loadedComponentPage != null && currentRouteName != null) {
-      if (this.loadedComponentPage === currentRoutePage) {
-        const componentConfig = this.props.routes[currentRouteName];
-        replaceObject(this.currentProps, "props" in componentConfig ? componentConfig.props : {});
+    } else if (config.loadedComponentPage != null && currentRouteName != null) {
+      if (config.loadedComponentPage === currentRoutePage) {
+        props.routerStore.adapters.replaceObject(config.currentProps, "props" in componentConfig ? componentConfig.props : {});
         preventRedirect = true;
       }
     }
     if (preventRedirect) return;
-    (0, import_solid_js2.batch)(() => {
-      if (!this.loadedComponentName) {
-        this.setComponent();
-      } else {
-        this.props.beforeUpdatePageComponent?.();
-        this.setComponent();
+    props.routerStore.adapters.batch(() => {
+      if (config.loadedComponentName) {
+        props.beforeUpdatePageComponent?.();
       }
+      props.beforeSetPageComponent?.(componentConfig);
+      props.routerStore.adapters.batch(() => {
+        props.routerStore.adapters.replaceObject(config.currentProps, "props" in componentConfig ? componentConfig.props : {});
+        config.loadedComponentName = currentRouteName;
+        config.loadedComponentPage = componentConfig.pageName;
+        config[Symbol.for("$adm")]?.batch();
+      });
     });
   }
-  setComponent() {
-    const currentRouteName = this.props.routerStore.currentRoute.name;
-    const componentConfig = this.props.routes[currentRouteName];
-    this.props.beforeSetPageComponent?.(componentConfig);
-    (0, import_solid_js2.batch)(() => {
-      replaceObject(this.currentProps, "props" in componentConfig ? componentConfig.props : {});
-      this.loadedComponentName = currentRouteName;
-      this.loadedComponentPage = componentConfig.pageName;
-    });
-  }
-};
-function Router(props) {
-  const vm = useStore(VM, props);
-  return (0, import_web.createComponent)(import_solid_js2.Show, {
+  props.beforeMount?.();
+  redirectOnHistoryPop();
+  setLoadedComponent();
+  props.routerStore.adapters.autorun(() => setLoadedComponent());
+  return (0, import_web.createComponent)(import_solid_js.Show, {
     get when() {
-      return vm.loadedComponentName;
+      return config.loadedComponentName;
     },
     get children() {
       return (0, import_web.createComponent)(import_web3.Dynamic, (0, import_web2.mergeProps)({
         get component() {
-          return props.routes[vm.loadedComponentName]?.component || void 0;
+          return props.routes[config.loadedComponentName]?.component || void 0;
         }
-      }, () => vm.currentProps));
+      }, () => config.currentProps));
     }
   });
 }

package/dist/esm/adapters/kr-observable/index.js

@@ -0,0 +1,19 @@
+// packages/adapters/kr-observable.ts
+import { autorun, makeObservable } from "kr-observable";
+import { observer } from "kr-observable/react";
+var adapters = {
+  batch: (cb) => cb(),
+  autorun,
+  replaceObject: (obj, newObj) => {
+    for (const variableKey in obj) {
+      delete obj[variableKey];
+    }
+    Object.assign(obj, newObj);
+  },
+  makeObservable,
+  makeAutoObservable: makeObservable,
+  observer
+};
+export {
+  adapters
+};

package/dist/esm/adapters/kr-observable/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/esm/adapters/mobx/index.js

@@ -0,0 +1,23 @@
+// packages/adapters/mobx.ts
+import { autorun, makeAutoObservable, observable, runInAction } from "mobx";
+import { observer } from "mobx-react-lite";
+var adapters = {
+  batch: runInAction,
+  autorun,
+  observer,
+  replaceObject: (obj, newObj) => {
+    runInAction(() => {
+      for (const variableKey in obj) {
+        if (obj.hasOwnProperty(variableKey)) {
+          delete obj[variableKey];
+        }
+      }
+      Object.assign(obj, newObj);
+    });
+  },
+  makeObservable: observable,
+  makeAutoObservable
+};
+export {
+  adapters
+};

package/dist/esm/adapters/mobx/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/esm/adapters/solid/index.js

@@ -0,0 +1,27 @@
+// packages/adapters/solid.ts
+import { batch, createRenderEffect } from "solid-js";
+import { createMutable, modifyMutable, produce } from "solid-js/store";
+var adapters = {
+  batch,
+  autorun: createRenderEffect,
+  replaceObject: (obj, newObj) => {
+    modifyMutable(
+      obj,
+      produce((state) => {
+        if (typeof state === "object" && state != null) {
+          for (const variableKey in state) {
+            if (state.hasOwnProperty(variableKey)) {
+              delete state[variableKey];
+            }
+          }
+        }
+        Object.assign(state || {}, newObj);
+      })
+    );
+  },
+  makeObservable: createMutable,
+  makeAutoObservable: createMutable
+};
+export {
+  adapters
+};

package/dist/esm/adapters/solid/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/esm/index.js

@@ -11,6 +11,9 @@ function createRouterConfig(config) {
   return addNames(config);
 }
 
+// packages/core/createRouterStore.ts
+import queryString2 from "query-string";
+
 // packages/core/utils/constants.ts
 var constants = {
   dynamicSeparator: ":",
@@ -31,6 +34,19 @@ function isDynamicRoute(route) {
   return "params" in route;
 }
 
+// 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}`);
@@ -62,19 +78,6 @@ function findRouteByPathname({
   return dynamicRouteMatch;
 }
 
-// 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/getQueryValues.ts
 import queryString from "query-string";
 
@@ -142,8 +145,196 @@ function replaceDynamicValues({
     return encodeURIComponent(value);
   });
 }
+
+// packages/core/createRouterStore.ts
+function createRouterStore({
+  adapters,
+  routes,
+  routeError500,
+  lifecycleParams
+}) {
+  const routerStore = adapters.makeObservable({
+    routesHistory: [],
+    currentRoute: {},
+    isRedirecting: false,
+    redirectTo: void 0,
+    restoreFromURL: void 0,
+    restoreFromServer: void 0,
+    adapters
+  });
+  routerStore.restoreFromServer = function restoreFromServer(obj) {
+    adapters.batch(() => {
+      routerStore.routesHistory.push(...obj.routesHistory || []);
+      Object.assign(routerStore.currentRoute, obj.currentRoute);
+    });
+    const preloadedRouteName = Object.keys(routes).find(
+      (routeName) => routerStore.currentRoute.name === routeName
+    );
+    return loadComponentToConfig({ route: routes[preloadedRouteName] });
+  };
+  routerStore.restoreFromURL = function restoreFromURL(params) {
+    return routerStore.redirectTo(getInitialRoute({ routes, ...params }));
+  };
+  routerStore.redirectTo = async function redirectTo(config) {
+    const { route: routeName, noHistoryPush, asClient } = config;
+    const isClient = typeof asClient === "boolean" ? asClient : constants.isClient;
+    let currentRoute;
+    let currentPathname;
+    let currentUrl;
+    let currentSearch;
+    let currentQuery;
+    if (routerStore.currentRoute?.name) {
+      currentRoute = routes[routerStore.currentRoute.name];
+      currentPathname = replaceDynamicValues({
+        route: currentRoute,
+        params: routerStore.currentRoute.params
+      });
+      currentUrl = queryString2.stringifyUrl({
+        url: currentPathname,
+        query: routerStore.currentRoute.query
+      });
+      currentQuery = routerStore.currentRoute.query;
+      currentSearch = queryString2.stringify(routerStore.currentRoute.query);
+    }
+    const nextRoute = routes[routeName];
+    const nextPathname = replaceDynamicValues({
+      route: nextRoute,
+      params: "params" in config ? config.params : void 0
+    });
+    let nextQuery;
+    let nextUrl = nextPathname;
+    let nextSearch;
+    if ("query" in config && config.query) {
+      const clearedQuery = getQueryValues({
+        route: nextRoute,
+        pathname: `${nextPathname}?${queryString2.stringify(config.query)}`
+      });
+      if (Object.keys(clearedQuery).length > 0) {
+        nextQuery = clearedQuery;
+        nextSearch = queryString2.stringify(clearedQuery);
+        nextUrl = queryString2.stringifyUrl({ url: nextPathname, query: clearedQuery });
+      }
+    }
+    if (currentUrl === nextUrl) return Promise.resolve();
+    if (currentPathname === nextPathname) {
+      if (currentSearch !== nextSearch) {
+        adapters.batch(() => {
+          adapters.replaceObject(routerStore.currentRoute.query, nextQuery || {});
+          routerStore.routesHistory.push(nextUrl);
+        });
+        if (history && !noHistoryPush) {
+          history.push({
+            hash: history.location.hash,
+            search: nextSearch,
+            pathname: nextPathname
+          });
+        }
+      }
+      return Promise.resolve();
+    }
+    adapters.batch(() => {
+      routerStore.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}?${queryString2.stringify(redirectConfig.query)}`
+          });
+          if (Object.keys(clearedQuery).length > 0) {
+            redirectUrl = queryString2.stringifyUrl({ url: redirectUrl, query: clearedQuery });
+          }
+        }
+        throw Object.assign(new Error(redirectUrl), { name: constants.errorRedirect });
+      }
+      await loadComponentToConfig({ route: routes[nextRoute.name] });
+    } catch (error) {
+      if (error?.name === constants.errorPrevent) return Promise.resolve();
+      if (error?.name === constants.errorRedirect) {
+        throw error;
+      }
+      console.error(error);
+      await loadComponentToConfig({ route: routeError500 });
+      adapters.batch(() => {
+        adapters.replaceObject(routerStore.currentRoute, {
+          name: routeError500.name,
+          path: routeError500.path,
+          props: routes[routeError500.name].props,
+          query: {},
+          params: {},
+          pageName: routes[routeError500.name].pageName
+        });
+        routerStore.isRedirecting = false;
+      });
+      return Promise.resolve();
+    }
+    adapters.batch(() => {
+      adapters.replaceObject(routerStore.currentRoute, {
+        name: nextRoute.name,
+        path: nextRoute.path,
+        props: routes[nextRoute.name].props,
+        query: getQueryValues({ route: nextRoute, pathname: nextUrl }),
+        params: getDynamicValues({ route: nextRoute, pathname: nextUrl }),
+        pageName: routes[nextRoute.name].pageName
+      });
+      const lastUrl = routerStore.routesHistory[routerStore.routesHistory.length - 1];
+      if (lastUrl !== nextUrl) {
+        routerStore.routesHistory.push(nextUrl);
+      }
+      if (history && !noHistoryPush) {
+        history.push({
+          hash: history.location.hash,
+          search: "query" in config ? `?${queryString2.stringify(config.query)}` : "",
+          pathname: nextPathname
+        });
+      }
+      routerStore.isRedirecting = false;
+    });
+    return Promise.resolve();
+  };
+  return routerStore;
+}
 export {
   createRouterConfig,
+  createRouterStore,
   findRouteByPathname,
   getInitialRoute,
   history,

package/dist/esm/react/index.js

@@ -1,125 +1,83 @@
 // packages/react/Router.tsx
-import { autorun, makeAutoObservable, runInAction as runInAction2 } from "mobx";
-import { observer } from "mobx-react-lite";
+import { memo, useCallback, useEffect, useRef, useState } from "react";
 import { getInitialRoute, history } from "reactive-route";
-
-// packages/react/useStore.ts
-import { runInAction } from "mobx";
-import { useEffect, useRef, useState } from "react";
-function useStore(ViewModel, props) {
-  const isFirstRenderRef = useRef(true);
-  const [vm] = useState(() => {
-    const instance = new ViewModel(props || {});
-    runInAction(() => {
-      instance.beforeMount?.();
-    });
-    return instance;
-  });
-  useEffect(() => {
-    if (isFirstRenderRef.current) {
-      isFirstRenderRef.current = false;
-    } else if (props) {
-      runInAction(() => {
-        vm.props = props || {};
-      });
-    }
-  }, [props]);
-  useEffect(() => {
-    vm.afterMount?.();
-    return () => {
-      vm.autorunDisposers?.forEach((disposer) => disposer());
-    };
-  }, []);
-  return vm;
-}
-
-// packages/react/Router.tsx
 import { jsx } from "react/jsx-runtime";
-var VM = class {
-  constructor(props) {
-    this.props = props;
-    makeAutoObservable(
-      this,
-      { loadedComponent: false, setLoadedComponent: false, props: false },
-      { autoBind: true }
-    );
-  }
-  autorunDisposers = [];
-  loadedComponentName = void 0;
-  loadedComponentPage = void 0;
-  loadedComponent;
-  currentProps = {};
-  beforeMount() {
-    this.props.beforeMount?.();
-    this.redirectOnHistoryPop();
-    this.setLoadedComponent();
-    this.autorunDisposers.push(autorun(this.setLoadedComponent));
-  }
-  redirectOnHistoryPop() {
+function RouterInner(props) {
+  const disposerRef = useRef(null);
+  const redirectOnHistoryPop = useCallback(() => {
     if (!history) return;
     history.listen((params) => {
       if (params.action !== "POP") return;
-      const previousRoutePathname = this.props.routerStore.routesHistory[this.props.routerStore.routesHistory.length - 2];
+      const previousRoutePathname = props.routerStore.routesHistory[props.routerStore.routesHistory.length - 2];
       if (previousRoutePathname === params.location.pathname) {
-        runInAction2(() => this.props.routerStore.routesHistory.pop());
+        props.routerStore.adapters.batch(() => props.routerStore.routesHistory.pop());
       }
-      void this.props.routerStore.redirectTo({
+      void props.routerStore.redirectTo({
         noHistoryPush: true,
         ...getInitialRoute({
-          routes: this.props.routes,
+          routes: props.routes,
           pathname: history.location.pathname,
           fallback: "error404"
         })
       });
     });
-  }
-  setLoadedComponent = () => {
-    const { loadedComponentName, loadedComponentPage } = this;
-    const { currentRoute, isRedirecting } = this.props.routerStore;
-    const currentRouteName = currentRoute.name;
-    const currentRoutePage = currentRoute.pageName;
+  }, []);
+  const [config] = useState(
+    () => props.routerStore.adapters.makeObservable({
+      loadedComponentName: void 0,
+      loadedComponentPage: void 0,
+      currentProps: {}
+    })
+  );
+  const setLoadedComponent = useCallback(() => {
+    const { loadedComponentName, loadedComponentPage } = config;
+    const { currentRoute, isRedirecting } = props.routerStore;
+    const componentConfig = props.routes[currentRoute.name];
     let preventRedirect = false;
     if (isRedirecting) preventRedirect = true;
-    else if (loadedComponentName === currentRouteName) preventRedirect = true;
-    else if (loadedComponentPage != null && currentRouteName != null) {
-      if (loadedComponentPage === currentRoutePage) {
-        const componentConfig = this.props.routes[currentRouteName];
-        runInAction2(() => {
-          this.currentProps = "props" in componentConfig ? componentConfig.props || {} : {};
+    else if (loadedComponentName === currentRoute.name) preventRedirect = true;
+    else if (loadedComponentPage != null && currentRoute.name != null) {
+      if (loadedComponentPage === currentRoute.pageName) {
+        props.routerStore.adapters.batch(() => {
+          config.currentProps = "props" in componentConfig ? componentConfig.props || {} : {};
+          config[Symbol.for("$adm")]?.batch();
         });
         preventRedirect = true;
       }
     }
     if (preventRedirect) return;
-    runInAction2(() => {
-      if (!loadedComponentName) {
-        this.setComponent(currentRouteName);
-      } else {
-        this.props.beforeUpdatePageComponent?.();
-        this.setComponent(currentRouteName);
-      }
+    props.routerStore.adapters.batch(() => {
+      if (loadedComponentName) props.beforeUpdatePageComponent?.();
+      props.beforeSetPageComponent?.(componentConfig);
+      config.currentProps = "props" in componentConfig ? componentConfig.props || {} : {};
+      config.loadedComponentName = currentRoute.name;
+      config.loadedComponentPage = componentConfig.pageName;
+      config[Symbol.for("$adm")]?.batch();
     });
-  };
-  setComponent(currentRouteName) {
-    runInAction2(() => {
-      const componentConfig = this.props.routes[currentRouteName];
-      const RouteComponent = componentConfig.component;
-      this.props.beforeSetPageComponent?.(componentConfig);
-      this.currentProps = "props" in componentConfig ? componentConfig.props || {} : {};
-      this.loadedComponentName = currentRouteName;
-      this.loadedComponentPage = componentConfig.pageName;
-      this.loadedComponent = RouteComponent;
+  }, []);
+  useState(() => {
+    props.routerStore.adapters.batch(() => {
+      props.beforeMount?.();
+      redirectOnHistoryPop();
+      setLoadedComponent();
+      disposerRef.current = props.routerStore.adapters.autorun(setLoadedComponent);
     });
-  }
-};
-var Router = observer(
-  (props) => {
-    const vm = useStore(VM, props);
-    const LoadedComponent = vm.loadedComponentName ? vm.loadedComponent : null;
-    if (LoadedComponent) return /* @__PURE__ */ jsx(LoadedComponent, { ...vm.currentProps });
-    return null;
-  }
-);
+  });
+  useEffect(() => {
+    return () => {
+      disposerRef.current?.();
+    };
+  }, []);
+  if (!config.loadedComponentName) return null;
+  const LoadedComponent = props.routes[config.loadedComponentName]?.component || null;
+  if (LoadedComponent) return /* @__PURE__ */ jsx(LoadedComponent, { ...config.currentProps });
+  return null;
+}
+function RouterWrapper(props) {
+  const Component = props.routerStore.adapters.observer ? props.routerStore.adapters.observer(RouterInner) : RouterInner;
+  return /* @__PURE__ */ jsx(Component, { ...props });
+}
+var Router = memo(RouterWrapper);
 export {
   Router
 };