@native-router/core 1.0.1 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,396 @@
+'use strict';
+
+var history = require('history');
+var pathToRegexp = require('path-to-regexp');
+var util = require('./util.cjs');
+
+/* eslint-disable max-classes-per-file */
+
+class NativeRouterError extends Error {}
+class NotFoundError extends NativeRouterError {
+  constructor(pathname) {
+    super(`Can't find the path: ${pathname}`);
+  }
+}
+
+/**
+ * Create a router instance.
+ * @group Methods
+ * @category Router
+ * @param routes routes config
+ * @param history {@link https://www.npmjs.com/package/history history} instance
+ * @param resolveView a callback to resolve view. see {@link defaultResolveView}
+ * @param options options
+ * @returns a router instance
+ */
+function create(routes, history, resolveView, options) {
+  const [currentGuard, cancelAll] = util.createCurrentGuard();
+  const {
+    index,
+    locationStack
+  } = getHistoryState({
+    history: history
+  });
+  const viewStack = new Array(locationStack.length).fill(null);
+  if (options?.currentView) {
+    viewStack[index] = options.currentView;
+  }
+  return {
+    routes: Array.isArray(routes) ? routes : [routes],
+    resolveView,
+    history: history,
+    locationStack,
+    viewStack,
+    currentGuard,
+    cancelAll,
+    errorHandler: util.reject,
+    ...options,
+    baseUrl: options?.baseUrl || ''
+  };
+}
+function setOptions(router, options) {
+  return Object.assign(router, options);
+}
+function getLocation({
+  history
+}) {
+  const state = history.location.state || {};
+  return {
+    ...history.location,
+    state: state.state
+  };
+}
+function getHistoryState(router) {
+  const {
+    location
+  } = router.history;
+  const state = location.state || {};
+  return {
+    index: state.index || 0,
+    locationStack: state.locationStack || [getLocation(router)]
+  };
+}
+function getCurrentView(router) {
+  return router.viewStack[getHistoryState(router).index];
+}
+
+/**
+ * Match a path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param pathname the pathname
+ * @returns the matched result
+ */
+function match(router, pathname) {
+  function matchRoutes(routes, baseUrl,
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  pathname) {
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+      const end = !route.children;
+      const matched = route.path ? pathToRegexp.match(route.path, {
+        strict: true,
+        sensitive: true,
+        decode: typeof decodeURIComponent === 'function' ? decodeURIComponent : undefined,
+        end
+      })(pathname) : {
+        path: '',
+        index: 0,
+        params: {}
+      };
+      if (matched) {
+        const result = {
+          route,
+          ...matched
+        };
+        if (end) return [result];
+        const children = matchRoutes(route.children, `${baseUrl}${route.path || ''}`, pathname.slice(matched.path.length));
+        if (children) return [result, ...children];
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+  return matchRoutes(router.routes, router.baseUrl, pathname.slice(router.baseUrl.length));
+}
+
+/**
+ * Path to Location.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to path string
+ * @param state the state of location
+ * @returns location
+ */
+function toLocation(router, to, state) {
+  const {
+    baseUrl
+  } = router;
+  return {
+    pathname: '',
+    search: '',
+    hash: '',
+    ...history.parsePath(baseUrl + to),
+    state
+  };
+}
+
+/**
+ * Resolve a location.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param location history instance
+ * @returns resolve task(a promise)
+ */
+function resolve(router, location) {
+  const matched = match(router, location.pathname);
+  const {
+    resolveView,
+    errorHandler
+  } = router;
+  return (matched ? resolveView(matched, {
+    router,
+    location
+  }) : Promise.reject(new NotFoundError(location.pathname))).catch(errorHandler);
+}
+
+/**
+ * Resolve a path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to the path
+ * @param state state of the path location
+ * @returns resolve task(a promise)
+ */
+function resolveTo(router, to, state) {
+  const location = toLocation(router, to, state);
+  return resolve(router, location);
+}
+
+/**
+ * Commit the resolve task and push history.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param resolvePromise resolve task(a promise)
+ * @param location the location to resolved
+ */
+function commit(router, resolvePromise, location) {
+  const {
+    history
+  } = router;
+  const nextIndex = getHistoryState(router).index + 1;
+  return commitBase(router, resolvePromise, location, resolvedView => {
+    router.locationStack = [...router.locationStack.slice(0, nextIndex), location];
+    router.viewStack = [...router.viewStack.slice(0, nextIndex), resolvedView];
+    history.push(location, {
+      index: nextIndex,
+      locationStack: router.locationStack,
+      state: location.state
+    });
+  });
+}
+
+/**
+ * Commit the resolve task and replace history.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param resolvePromise resolve task(a promise)
+ * @param location the location to resolved
+ */
+function commitReplace(router, resolvePromise, location) {
+  const {
+    history
+  } = router;
+  const {
+    index
+  } = getHistoryState(router);
+  return commitBase(router, resolvePromise, location, resolvedView => {
+    router.locationStack[index] = location;
+    router.viewStack[index] = resolvedView;
+    history.replace(location, {
+      index,
+      locationStack: router.locationStack,
+      state: location.state
+    });
+  });
+}
+function commitBase(router, resolvePromise, location, onResolved) {
+  const {
+    currentGuard,
+    onLoadingChange = util.noop
+  } = router;
+  if (router.resolving) {
+    // Cancel current resolve
+    onLoadingChange();
+  }
+  router.resolving = location;
+  onLoadingChange('pending');
+  return currentGuard(resolvePromise).then(onResolved)
+  // eslint-disable-next-line no-void
+  .then(() => void onLoadingChange('resolved')).catch(e => {
+    onLoadingChange('rejected');
+    throw e;
+  });
+}
+
+/**
+ * Navigate to a new path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to path string
+ * @param state location state
+ */
+function navigate(router, to, state) {
+  const location = toLocation(router, to, state);
+  const viewPromise = resolve(router, location);
+  return commit(router, viewPromise, location);
+}
+
+/**
+ * Refresh the page.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function refresh(router) {
+  const location = getLocation(router);
+  const viewPromise = resolve(router, location);
+  return commitReplace(router, viewPromise, location);
+}
+
+/**
+ * Navigate in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param delta history stack index
+ */
+function go(router, delta) {
+  router.history.go(delta);
+}
+
+/**
+ * Forward in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function forward(router) {
+  router.history.forward();
+}
+
+/**
+ * Back in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function back(router) {
+  router.history.back();
+}
+
+/**
+ * Create href of a route path. For {@link Link Link Component} hover url preview.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to route path
+ * @returns href
+ */
+function createHref({
+  baseUrl,
+  history
+}, to) {
+  return baseUrl + history.createHref(to);
+}
+
+/**
+ * Cancel the current navigate.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function cancel({
+  cancelAll,
+  onLoadingChange = util.noop
+}) {
+  cancelAll();
+  onLoadingChange();
+}
+function initHistoryStack(router) {
+  const {
+    history: history$1
+  } = router;
+  const {
+    locationStack
+  } = getHistoryState(router);
+  return Promise.all(locationStack.map(l => resolve(router, l))).then(views => {
+    router.viewStack = views;
+    history$1.replace(history.createPath(history$1.location), history$1.location.state);
+  });
+}
+
+/**
+ * Listen the history change.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param onViewChange a callback function will be call when view changed
+ * @returns unlisten - A function that may be used to stop listening
+ */
+function listen(router, onViewChange) {
+  const {
+    history: history$1
+  } = router;
+  const rmListener = history$1.listen(({
+    action,
+    location
+  }) => {
+    cancel(router);
+    const state = location.state;
+    const index = state?.index || 0;
+    const view = router.viewStack[index];
+    onViewChange(view);
+    if (!view) refresh(router);
+    if (action === 'POP') {
+      history$1.replace(history.createPath(history$1.location), {
+        ...state,
+        locationStack: router.locationStack
+      });
+    }
+  });
+  history$1.replace(history.createPath(history$1.location), history$1.location.state);
+  return () => {
+    cancel(router);
+    rmListener();
+  };
+}
+
+exports.NativeRouterError = NativeRouterError;
+exports.NotFoundError = NotFoundError;
+exports.back = back;
+exports.cancel = cancel;
+exports.commit = commit;
+exports.commitReplace = commitReplace;
+exports.create = create;
+exports.createHref = createHref;
+exports.forward = forward;
+exports.getCurrentView = getCurrentView;
+exports.getLocation = getLocation;
+exports.go = go;
+exports.initHistoryStack = initHistoryStack;
+exports.listen = listen;
+exports.match = match;
+exports.navigate = navigate;
+exports.refresh = refresh;
+exports.resolve = resolve;
+exports.resolveTo = resolveTo;
+exports.setOptions = setOptions;
+exports.toLocation = toLocation;

package/dist/util.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+let i = 1;
+function uniqId() {
+  return i++;
+}
+function noop() {}
+const resolve = /* @__PURE__ */Promise.resolve.bind(Promise);
+const reject = /* @__PURE__ */Promise.reject.bind(Promise);
+function cancelPromise() {
+  return new Promise(noop);
+}
+function createCurrentGuard() {
+  let current;
+  return [function currentGuard(promise) {
+    const cur = uniqId();
+    current = cur;
+    return promise.then(result => current === cur ? result : cancelPromise()).catch(err => current === cur ? Promise.reject(err) : cancelPromise());
+  }, function cancel() {
+    current = undefined;
+  }];
+}
+function splitProps(obj, keys) {
+  const picked = {};
+  const rest = {
+    ...obj
+  };
+  keys.forEach(key => {
+    picked[key] = rest[key];
+    delete rest[key];
+  });
+  return [picked, rest];
+}
+function isString(maybeString) {
+  return typeof maybeString === 'string';
+}
+
+exports.cancelPromise = cancelPromise;
+exports.createCurrentGuard = createCurrentGuard;
+exports.isString = isString;
+exports.noop = noop;
+exports.reject = reject;
+exports.resolve = resolve;
+exports.splitProps = splitProps;
+exports.uniqId = uniqId;

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "@native-router/core",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
       "types": "./dist/types/index.d.ts"
     },
     "./util": {
       "import": "./dist/util.mjs",
+      "require": "./dist/util.cjs",
       "types": "./dist/types/util.d.ts"
     }
   },
   "types": "./dist/types/index.d.ts",
   "keywords": [
-    "react",
     "router",
-    "react router",
-    "react-router",
     "async",
     "tiny",
     "data-fetching",