reactive-route 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dmitry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,10 @@
+## Config-based routing
+
+![coverage](https://github.com/dkazakov8/reactive-route/blob/master/assets/coverage.svg)
+[![npm](https://img.shields.io/npm/v/reactive-route)](https://www.npmjs.com/package/reactive-route)
+![size-core](https://github.com/dkazakov8/reactive-route/blob/master/assets/core.svg)
+![size-react](https://github.com/dkazakov8/reactive-route/blob/master/assets/react.svg)
+![size-solid](https://github.com/dkazakov8/reactive-route/blob/master/assets/solid.svg)
+
+> [!WARNING]
+> Work in progress

package/dist/cjs/index.js

@@ -0,0 +1,186 @@
+"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)
+    __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 __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,
+  findRouteByPathname: () => findRouteByPathname,
+  getInitialRoute: () => getInitialRoute,
+  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/utils/constants.ts
+var constants = {
+  dynamicSeparator: ":",
+  pathPartSeparator: "/",
+  isClient: typeof window !== "undefined",
+  errorRedirect: "REDIRECT",
+  errorPrevent: "PREVENT_REDIRECT"
+};
+
+// packages/core/utils/dynamic.ts
+function isDynamic(param) {
+  return param[0] === constants.dynamicSeparator;
+}
+function clearDynamic(param) {
+  return param.replace(new RegExp(`^${constants.dynamicSeparator}`), "");
+}
+function isDynamicRoute(route) {
+  return "params" in route;
+}
+
+// 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/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
+var import_query_string = __toESM(require("query-string"));
+
+// packages/core/utils/getTypedEntries.ts
+var getTypedEntries = Object.entries;
+
+// packages/core/utils/getQueryValues.ts
+function getQueryValues(params) {
+  const { route, pathname } = params;
+  const qs = import_query_string.default.extract(pathname);
+  if (!qs || !route.query) return {};
+  const query = import_query_string.default.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[params.fallback];
+  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 && route.loader) {
+    const loadingFn = route.loader;
+    return loadingFn().then((module2) => {
+      const { default: component, pageName, ...rest } = module2;
+      route.component = component;
+      route.otherExports = rest;
+      route.pageName = pageName;
+    });
+  }
+  return Promise.resolve();
+}
+
+// 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);
+  });
+}

package/dist/cjs/package.json

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

package/dist/cjs/react/index.js

@@ -0,0 +1,148 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  Router: () => Router
+});
+module.exports = __toCommonJS(react_exports);
+
+// packages/react/Router.tsx
+var import_mobx2 = require("mobx");
+var import_mobx_react_lite = require("mobx-react-lite");
+var import_reactive_route = require("reactive-route");
+
+// packages/react/useStore.ts
+var import_mobx = require("mobx");
+var import_react = require("react");
+function useStore(ViewModel, props) {
+  const isFirstRenderRef = (0, import_react.useRef)(true);
+  const [vm] = (0, import_react.useState)(() => {
+    const instance = new ViewModel(props || {});
+    (0, import_mobx.runInAction)(() => {
+      instance.beforeMount?.();
+    });
+    return instance;
+  });
+  (0, import_react.useEffect)(() => {
+    if (isFirstRenderRef.current) {
+      isFirstRenderRef.current = false;
+    } else if (props) {
+      (0, import_mobx.runInAction)(() => {
+        vm.props = props || {};
+      });
+    }
+  }, [props]);
+  (0, import_react.useEffect)(() => {
+    vm.afterMount?.();
+    return () => {
+      vm.autorunDisposers?.forEach((disposer) => disposer());
+    };
+  }, []);
+  return vm;
+}
+
+// packages/react/Router.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var VM = class {
+  constructor(props) {
+    this.props = props;
+    (0, import_mobx2.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((0, import_mobx2.autorun)(this.setLoadedComponent));
+  }
+  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];
+      if (previousRoutePathname === params.location.pathname) {
+        (0, import_mobx2.runInAction)(() => this.props.routerStore.routesHistory.pop());
+      }
+      void this.props.routerStore.redirectTo({
+        noHistoryPush: true,
+        ...(0, import_reactive_route.getInitialRoute)({
+          routes: this.props.routes,
+          pathname: import_reactive_route.history.location.pathname,
+          fallback: "error404"
+        })
+      });
+    });
+  }
+  setLoadedComponent = () => {
+    const { loadedComponentName, loadedComponentPage } = this;
+    const { currentRoute, isRedirecting } = this.props.routerStore;
+    const currentRouteName = currentRoute.name;
+    const currentRoutePage = currentRoute.pageName;
+    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];
+        (0, import_mobx2.runInAction)(() => {
+          this.currentProps = "props" in componentConfig ? componentConfig.props || {} : {};
+        });
+        preventRedirect = true;
+      }
+    }
+    if (preventRedirect) return;
+    (0, import_mobx2.runInAction)(() => {
+      if (!loadedComponentName) {
+        this.setComponent(currentRouteName);
+      } else {
+        this.props.beforeUpdatePageComponent?.();
+        this.setComponent(currentRouteName);
+      }
+    });
+  };
+  setComponent(currentRouteName) {
+    (0, import_mobx2.runInAction)(() => {
+      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;
+    });
+  }
+};
+var Router = (0, import_mobx_react_lite.observer)(
+  (props) => {
+    const vm = useStore(VM, props);
+    const LoadedComponent = vm.loadedComponentName ? vm.loadedComponent : null;
+    if (LoadedComponent) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoadedComponent, { ...vm.currentProps });
+    return null;
+  }
+);

package/dist/cjs/react/package.json

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

package/dist/cjs/solid/index.js

@@ -0,0 +1,160 @@
+"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/solid/index.ts
+var solid_exports = {};
+__export(solid_exports, {
+  Router: () => Router
+});
+module.exports = __toCommonJS(solid_exports);
+
+// packages/solid/Router.tsx
+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?.();
+  });
+  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() {
+    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];
+      if (previousRoutePathname === params.location.pathname) {
+        this.props.routerStore.routesHistory.pop();
+      }
+      void this.props.routerStore.redirectTo({
+        noHistoryPush: true,
+        ...(0, import_reactive_route.getInitialRoute)({
+          routes: this.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;
+    let preventRedirect = false;
+    if (this.props.routerStore.isRedirecting) preventRedirect = true;
+    else if (this.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 : {});
+        preventRedirect = true;
+      }
+    }
+    if (preventRedirect) return;
+    (0, import_solid_js2.batch)(() => {
+      if (!this.loadedComponentName) {
+        this.setComponent();
+      } else {
+        this.props.beforeUpdatePageComponent?.();
+        this.setComponent();
+      }
+    });
+  }
+  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, {
+    get when() {
+      return vm.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;
+        }
+      }, () => vm.currentProps));
+    }
+  });
+}

package/dist/cjs/solid/package.json

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

package/dist/esm/index.js

@@ -0,0 +1,153 @@
+// 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/utils/constants.ts
+var constants = {
+  dynamicSeparator: ":",
+  pathPartSeparator: "/",
+  isClient: typeof window !== "undefined",
+  errorRedirect: "REDIRECT",
+  errorPrevent: "PREVENT_REDIRECT"
+};
+
+// packages/core/utils/dynamic.ts
+function isDynamic(param) {
+  return param[0] === constants.dynamicSeparator;
+}
+function clearDynamic(param) {
+  return param.replace(new RegExp(`^${constants.dynamicSeparator}`), "");
+}
+function isDynamicRoute(route) {
+  return "params" in route;
+}
+
+// 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/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";
+
+// packages/core/utils/getTypedEntries.ts
+var getTypedEntries = Object.entries;
+
+// 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[params.fallback];
+  return {
+    route: route.name,
+    query: getQueryValues({ route, pathname: params.pathname }),
+    params: getDynamicValues({ route, pathname: params.pathname })
+  };
+}
+
+// packages/core/utils/history.ts
+import { createBrowserHistory } from "history";
+var history = constants.isClient ? createBrowserHistory() : null;
+
+// packages/core/utils/loadComponentToConfig.ts
+function loadComponentToConfig(params) {
+  const { route } = params;
+  if (!route.component && route.loader) {
+    const loadingFn = route.loader;
+    return loadingFn().then((module) => {
+      const { default: component, pageName, ...rest } = module;
+      route.component = component;
+      route.otherExports = rest;
+      route.pageName = pageName;
+    });
+  }
+  return Promise.resolve();
+}
+
+// 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);
+  });
+}
+export {
+  createRouterConfig,
+  findRouteByPathname,
+  getInitialRoute,
+  history,
+  isDynamicRoute,
+  loadComponentToConfig,
+  replaceDynamicValues
+};

package/dist/esm/package.json

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