reactive-route 0.0.1-alpha.2 → 0.0.1-alpha.20

package/dist/adapters/kr-observable-preact.d.ts

@@ -0,0 +1,3 @@
+import { TypeAdapters } from 'reactive-route';
+export declare const adapters: TypeAdapters;
+//# sourceMappingURL=kr-observable-preact.d.ts.map

package/dist/adapters/kr-observable-preact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kr-observable-preact.d.ts","sourceRoot":"","sources":["../../packages/adapters/kr-observable-preact.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,QAAQ,EAAE,YAYtB,CAAC"}

package/dist/adapters/kr-observable.d.ts

@@ -0,0 +1,3 @@
+import { TypeAdapters } from 'reactive-route';
+export declare const adapters: TypeAdapters;
+//# sourceMappingURL=kr-observable.d.ts.map

package/dist/adapters/kr-observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kr-observable.d.ts","sourceRoot":"","sources":["../../packages/adapters/kr-observable.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,QAAQ,EAAE,YAYtB,CAAC"}

package/dist/adapters/mobx-preact.d.ts

@@ -0,0 +1,3 @@
+import { TypeAdapters } from 'reactive-route';
+export declare const adapters: TypeAdapters;
+//# sourceMappingURL=mobx-preact.d.ts.map

package/dist/adapters/mobx-preact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobx-preact.d.ts","sourceRoot":"","sources":["../../packages/adapters/mobx-preact.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,QAAQ,EAAE,YAetB,CAAC"}

package/dist/adapters/mobx-solid.d.ts

@@ -0,0 +1,3 @@
+import { TypeAdapters } from 'reactive-route';
+export declare const adapters: TypeAdapters;
+//# sourceMappingURL=mobx-solid.d.ts.map

package/dist/adapters/mobx-solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobx-solid.d.ts","sourceRoot":"","sources":["../../packages/adapters/mobx-solid.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,QAAQ,EAAE,YAetB,CAAC"}

package/dist/adapters/mobx.d.ts

@@ -0,0 +1,3 @@
+import { TypeAdapters } from 'reactive-route';
+export declare const adapters: TypeAdapters;
+//# sourceMappingURL=mobx.d.ts.map

package/dist/adapters/mobx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobx.d.ts","sourceRoot":"","sources":["../../packages/adapters/mobx.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,QAAQ,EAAE,YAetB,CAAC"}

package/dist/adapters/solid.d.ts

@@ -0,0 +1,3 @@
+import { TypeAdapters } from 'reactive-route';
+export declare const adapters: TypeAdapters;
+//# sourceMappingURL=solid.d.ts.map

package/dist/adapters/solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.d.ts","sourceRoot":"","sources":["../../packages/adapters/solid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,eAAO,MAAM,QAAQ,EAAE,YAmBtB,CAAC"}

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

@@ -0,0 +1,39 @@
+"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/adapters/kr-observable.ts
+var kr_observable_exports = {};
+__export(kr_observable_exports, {
+  adapters: () => adapters
+});
+module.exports = __toCommonJS(kr_observable_exports);
+var import_kr_observable = require("kr-observable");
+var import_react = require("kr-observable/react");
+var adapters = {
+  batch: (cb) => cb(),
+  autorun: import_kr_observable.autorun,
+  replaceObject: (obj, newObj) => {
+    for (const variableKey in obj) {
+      delete obj[variableKey];
+    }
+    Object.assign(obj, newObj);
+  },
+  makeObservable: import_kr_observable.makeObservable,
+  observer: import_react.observer
+};

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

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

package/dist/cjs/adapters/kr-observable-preact/index.js

@@ -0,0 +1,39 @@
+"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/adapters/kr-observable-preact.ts
+var kr_observable_preact_exports = {};
+__export(kr_observable_preact_exports, {
+  adapters: () => adapters
+});
+module.exports = __toCommonJS(kr_observable_preact_exports);
+var import_kr_observable = require("kr-observable");
+var import_preact = require("kr-observable/preact");
+var adapters = {
+  batch: (cb) => cb(),
+  autorun: import_kr_observable.autorun,
+  replaceObject: (obj, newObj) => {
+    for (const variableKey in obj) {
+      delete obj[variableKey];
+    }
+    Object.assign(obj, newObj);
+  },
+  makeObservable: import_kr_observable.makeObservable,
+  observer: import_preact.observer
+};

package/dist/cjs/adapters/kr-observable-preact/package.json

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

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

@@ -0,0 +1,43 @@
+"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/adapters/mobx.ts
+var mobx_exports = {};
+__export(mobx_exports, {
+  adapters: () => adapters
+});
+module.exports = __toCommonJS(mobx_exports);
+var import_mobx = require("mobx");
+var import_mobx_react_lite = require("mobx-react-lite");
+var adapters = {
+  batch: import_mobx.runInAction,
+  autorun: import_mobx.autorun,
+  observer: import_mobx_react_lite.observer,
+  replaceObject: (obj, newObj) => {
+    (0, import_mobx.runInAction)(() => {
+      for (const variableKey in obj) {
+        if (obj.hasOwnProperty(variableKey)) {
+          delete obj[variableKey];
+        }
+      }
+      Object.assign(obj, newObj);
+    });
+  },
+  makeObservable: import_mobx.observable
+};

package/dist/cjs/adapters/mobx/package.json

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

package/dist/cjs/adapters/mobx-preact/index.js

@@ -0,0 +1,43 @@
+"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/adapters/mobx-preact.ts
+var mobx_preact_exports = {};
+__export(mobx_preact_exports, {
+  adapters: () => adapters
+});
+module.exports = __toCommonJS(mobx_preact_exports);
+var import_mobx = require("mobx");
+var import_mobx_preact = require("mobx-preact");
+var adapters = {
+  batch: import_mobx.runInAction,
+  autorun: import_mobx.autorun,
+  observer: import_mobx_preact.observer,
+  replaceObject: (obj, newObj) => {
+    (0, import_mobx.runInAction)(() => {
+      for (const variableKey in obj) {
+        if (obj.hasOwnProperty(variableKey)) {
+          delete obj[variableKey];
+        }
+      }
+      Object.assign(obj, newObj);
+    });
+  },
+  makeObservable: import_mobx.observable
+};

package/dist/cjs/adapters/mobx-preact/package.json

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

package/dist/cjs/adapters/mobx-solid/index.js

@@ -0,0 +1,42 @@
+"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/adapters/mobx-solid.ts
+var mobx_solid_exports = {};
+__export(mobx_solid_exports, {
+  adapters: () => adapters
+});
+module.exports = __toCommonJS(mobx_solid_exports);
+var import_mobx = require("mobx");
+var adapters = {
+  batch: import_mobx.runInAction,
+  autorun: import_mobx.autorun,
+  replaceObject: (obj, newObj) => {
+    (0, import_mobx.runInAction)(() => {
+      for (const variableKey in obj) {
+        if (obj.hasOwnProperty(variableKey)) {
+          delete obj[variableKey];
+        }
+      }
+      Object.assign(obj, newObj);
+    });
+  },
+  makeObservable: import_mobx.observable,
+  immediateSetComponent: true
+};

package/dist/cjs/adapters/mobx-solid/package.json

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

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

@@ -0,0 +1,45 @@
+"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/adapters/solid.ts
+var solid_exports = {};
+__export(solid_exports, {
+  adapters: () => adapters
+});
+module.exports = __toCommonJS(solid_exports);
+var import_solid_js = require("solid-js");
+var import_store = require("solid-js/store");
+var adapters = {
+  batch: import_solid_js.batch,
+  autorun: import_solid_js.createRenderEffect,
+  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);
+      })
+    );
+  },
+  makeObservable: import_store.createMutable
+};

package/dist/cjs/adapters/solid/package.json

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

package/dist/cjs/index.js

@@ -90,6 +90,37 @@ function getDynamicValues(params) {
   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/getQueryValues.ts
 var import_query_string = __toESM(require("query-string"));
 
@@ -111,6 +142,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;
@@ -150,29 +191,34 @@ function replaceDynamicValues({
 
 // packages/core/createRouterStore.ts
 function createRouterStore({
-  batch,
+  adapters,
   routes,
-  autorun,
-  replaceObject,
-  routeError500,
-  makeObservable,
   lifecycleParams
 }) {
-  const routerStore = makeObservable({
+  const routerStore = adapters.makeObservable({
     routesHistory: [],
     currentRoute: {},
     isRedirecting: false,
     redirectTo: void 0,
-    utils: {
-      batch,
-      autorun,
-      replaceObject,
-      makeObservable
-    }
+    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, pathname: params.pathname }));
+  };
   routerStore.redirectTo = async function redirectTo(config) {
-    const { route: routeName, noHistoryPush, asClient } = config;
-    const isClient = typeof asClient === "boolean" ? asClient : constants.isClient;
+    const { route: routeName, noHistoryPush } = config;
     let currentRoute;
     let currentPathname;
     let currentUrl;
@@ -213,8 +259,11 @@ function createRouterStore({
     if (currentUrl === nextUrl) return Promise.resolve();
     if (currentPathname === nextPathname) {
       if (currentSearch !== nextSearch) {
-        batch(() => {
-          replaceObject(routerStore.currentRoute.query, nextQuery || {});
+        adapters.batch(() => {
+          adapters.replaceObject(routerStore.currentRoute, {
+            ...routerStore.currentRoute,
+            query: nextQuery || {}
+          });
           routerStore.routesHistory.push(nextUrl);
         });
         if (history && !noHistoryPush) {
@@ -227,42 +276,26 @@ function createRouterStore({
       }
       return Promise.resolve();
     }
-    batch(() => {
+    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 || []
-      );
+      const config2 = {
+        nextUrl,
+        nextRoute,
+        nextQuery,
+        nextSearch,
+        nextPathname,
+        currentUrl,
+        currentQuery,
+        currentRoute,
+        currentSearch,
+        currentPathname
+      };
+      await currentRoute?.beforeLeave?.(config2, ...lifecycleParams || []);
+      const redirectConfig = await nextRoute.beforeEnter?.(config2, ...lifecycleParams || []);
       if (typeof redirectConfig === "object") {
-        if (isClient) return redirectTo({ ...redirectConfig, asClient });
+        if (constants.isClient) return redirectTo(redirectConfig);
         const redirectRoute = routes[redirectConfig.route];
         const redirectParams = "params" in redirectConfig && redirectConfig.params ? redirectConfig.params : void 0;
         let redirectUrl = replaceDynamicValues({
@@ -287,22 +320,22 @@ function createRouterStore({
         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: routes.internalError });
+      adapters.batch(() => {
+        adapters.replaceObject(routerStore.currentRoute, {
+          name: routes.internalError.name,
+          path: routes.internalError.path,
+          props: routes[routes.internalError.name].props,
+          query: adapters.makeObservable({}),
+          params: adapters.makeObservable({}),
+          pageName: routes[routes.internalError.name].pageName
         });
         routerStore.isRedirecting = false;
       });
       return Promise.resolve();
     }
-    batch(() => {
-      replaceObject(routerStore.currentRoute, {
+    adapters.batch(() => {
+      adapters.replaceObject(routerStore.currentRoute, {
         name: nextRoute.name,
         path: nextRoute.path,
         props: routes[nextRoute.name].props,
@@ -327,44 +360,3 @@ function createRouterStore({
   };
   return routerStore;
 }
-
-// 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/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 })
-  };
-}