@ray-js/router 1.2.2 → 1.2.3

package/lib/Router.js

@@ -1,53 +1,109 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import "core-js/modules/es.string.starts-with.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.search.js";
+import "core-js/modules/es.string.replace.js";
 import { url } from '@ray-js/library';
 import { history } from './history';
-export class Router {
-    constructor(options) {
-        this.scheduler = options.scheduler;
-        // window.router = this
-    }
-    normalizeRoute(params) {
-        let { to } = params;
-        // FIXME: 绝对路径是否需要支持？
-        if (to.startsWith('//') || to.startsWith('http')) {
-            return Promise.resolve({ to });
-        }
-        // TODO: Web 应用下重复进入一个路由
-        if (this.$href) {
-            const { pathname, search, hash } = url.parse(this.$href);
-            if (url.format({ pathname, search, hash }) === to) {
-                console.warn('duplicate route to:', to);
-            }
+export var Router = /*#__PURE__*/function () {
+  /**
+   * 页面路由调度器
+   */
+
+  /**
+   * 当前环境地址栏
+   */
+  function Router(options) {
+    _classCallCheck(this, Router);
+
+    this.scheduler = options.scheduler; // window.router = this
+  }
+
+  _createClass(Router, [{
+    key: "normalizeRoute",
+    value: function normalizeRoute(params) {
+      var to = params.to; // FIXME: 绝对路径是否需要支持？
+
+      if (to.startsWith('//') || to.startsWith('http')) {
+        return Promise.resolve({
+          to: to
+        });
+      } // TODO: Web 应用下重复进入一个路由
+
+
+      if (this.$href) {
+        var _url$parse = url.parse(this.$href),
+            pathname = _url$parse.pathname,
+            search = _url$parse.search,
+            hash = _url$parse.hash;
+
+        if (url.format({
+          pathname: pathname,
+          search: search,
+          hash: hash
+        }) === to) {
+          console.warn('duplicate route to:', to);
         }
-        return Promise.resolve({ to });
+      }
+
+      return Promise.resolve({
+        to: to
+      });
     }
-    push(to, options) {
-        this.normalizeRoute({ to }).then(({ to }) => {
-            history.push(to);
-        });
+  }, {
+    key: "push",
+    value: function push(to) {
+      this.normalizeRoute({
+        to: to
+      }).then(function (_ref) {
+        var to = _ref.to;
+        history.push(to);
+      });
     }
-    replace(to, options) {
-        this.normalizeRoute({ to }).then(({ to }) => {
-            history.replace(to);
-        });
+  }, {
+    key: "replace",
+    value: function replace(to) {
+      this.normalizeRoute({
+        to: to
+      }).then(function (_ref2) {
+        var to = _ref2.to;
+        history.replace(to);
+      });
     }
-    go(delta) {
-        // 在应用堆栈内进行跳转
-        history.go(delta);
+  }, {
+    key: "go",
+    value: function go(delta) {
+      // 在应用堆栈内进行跳转
+      history.go(delta);
     }
-    back() {
-        history.goBack();
+  }, {
+    key: "back",
+    value: function back() {
+      history.goBack();
     }
-    reload(to) {
-        if (to) {
-            this.normalizeRoute({ to }).then(({ to }) => {
-                window.location.href = to;
-            });
-        }
-        else {
-            window.location.reload();
-        }
+  }, {
+    key: "reload",
+    value: function reload(to) {
+      if (to) {
+        this.normalizeRoute({
+          to: to
+        }).then(function (_ref3) {
+          var to = _ref3.to;
+          window.location.href = to;
+        });
+      } else {
+        window.location.reload();
+      }
     }
-    get href() {
-        return window.location.href;
+  }, {
+    key: "href",
+    get: function get() {
+      return window.location.href;
     }
-}
+  }]);
+
+  return Router;
+}();

package/lib/RouterScheduler.js

@@ -1,64 +1,129 @@
-import { RouterScheduler as IRouterScheduler, } from '@ray-js/types';
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.array.splice.js";
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import { RouterScheduler as IRouterScheduler } from '@ray-js/types';
+
 /**
  * web 环境下的路由协调器
  */
-export class RouterScheduler extends IRouterScheduler {
-    constructor() {
-        super(...arguments);
-        this.$currentRoute = '';
-        this.$listeners = {};
-        this.$entityMap = [];
-        this.basename = '/';
+export var RouterScheduler = /*#__PURE__*/function (_IRouterScheduler) {
+  _inherits(RouterScheduler, _IRouterScheduler);
+
+  var _super = _createSuper(RouterScheduler);
+
+  function RouterScheduler() {
+    var _this;
+
+    _classCallCheck(this, RouterScheduler);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "$currentRoute", '');
+
+    _defineProperty(_assertThisInitialized(_this), "$listeners", {});
+
+    _defineProperty(_assertThisInitialized(_this), "$entityMap", []);
+
+    _defineProperty(_assertThisInitialized(_this), "basename", '/');
+
+    return _this;
+  }
+
+  _createClass(RouterScheduler, [{
+    key: "currentRoute",
+    get:
     /**
      * 当前调度器的 route 地址
      */
-    get currentRoute() {
-        return this.$currentRoute;
+    function get() {
+      return this.$currentRoute;
+    },
+    set: function set(val) {
+      if (val !== this.currentRoute) {
+        this.$currentRoute = val.replace(/\/$/, '');
+        this.emit('routeChange', this.currentRoute);
+      }
     }
-    set currentRoute(val) {
-        if (val !== this.currentRoute) {
-            this.$currentRoute = val.replace(/\/$/, '');
-            this.emit('routeChange', this.currentRoute);
-        }
-    }
-    on(event, fn) {
-        if (!this.$listeners[event]) {
-            this.$listeners[event] = [];
-        }
-        const events = this.$listeners[event];
-        events.push(fn);
-        return () => {
-            events.splice(events.indexOf(fn), 1);
-        };
-    }
-    // 给 TabBar 监听，用于处理当前高亮状态
-    emit(event, ...args) {
-        const fns = this.$listeners[event];
-        if (Array.isArray(fns)) {
-            fns.forEach((fn) => {
-                fn(...args);
-            });
-        }
+  }, {
+    key: "on",
+    value: function on(event, fn) {
+      if (!this.$listeners[event]) {
+        this.$listeners[event] = [];
+      }
+
+      var events = this.$listeners[event];
+      events.push(fn);
+      return function () {
+        events.splice(events.indexOf(fn), 1);
+      };
+    } // 给 TabBar 监听，用于处理当前高亮状态
+
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      var fns = this.$listeners[event];
+
+      if (Array.isArray(fns)) {
+        fns.forEach(function (fn) {
+          fn.apply(void 0, args);
+        });
+      }
     }
     /**
      * 初始化路由，注册应用声明的路由，并处理映射关系
      */
-    registryPages(params) {
-        const { pages, tabBar } = params;
-        const tabBarList = (tabBar === null || tabBar === void 0 ? void 0 : tabBar.list) || [];
-        pages.forEach((page) => {
-            const isTabBar = tabBarList.some((item) => page.path === item.pagePath);
-            page.route = page.route || page.path;
-            page.originalRoute = page.route;
-            this.addPage(Object.assign(Object.assign({}, page), { isTabBar }));
+
+  }, {
+    key: "registryPages",
+    value: function registryPages(params) {
+      var _this2 = this;
+
+      var pages = params.pages,
+          tabBar = params.tabBar;
+      var tabBarList = (tabBar === null || tabBar === void 0 ? void 0 : tabBar.list) || [];
+      pages.forEach(function (page) {
+        var isTabBar = tabBarList.some(function (item) {
+          return page.path === item.pagePath;
         });
+        page.route = page.route || page.path;
+        page.originalRoute = page.route;
+
+        _this2.addPage(_objectSpread(_objectSpread({}, page), {}, {
+          isTabBar: isTabBar
+        }));
+      });
     }
-    getMatchedPage(pathname) {
-        this.currentRoute = pathname;
-        return this.matchPageByPathname(pathname);
+  }, {
+    key: "getMatchedPage",
+    value: function getMatchedPage(pathname) {
+      this.currentRoute = pathname;
+      return this.matchPageByPathname(pathname);
     }
-    addPage(page) {
-        this.$entityMap.push(page);
+  }, {
+    key: "addPage",
+    value: function addPage(page) {
+      this.$entityMap.push(page);
     }
-}
+  }]);
+
+  return RouterScheduler;
+}(IRouterScheduler);

package/lib/history/index.js

@@ -1,53 +1,86 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
 import { createBrowserHistory } from 'history';
 import React from 'react';
-export let history;
-let changeKey = '';
+export var history;
+var changeKey = '';
 export function createHistory(options) {
-    const { scheduler } = options;
-    history = createBrowserHistory(options);
-    history.listen((historyLocation) => __awaiter(this, void 0, void 0, function* () {
-        const { key, pathname } = historyLocation;
-        if (key && key === changeKey) {
-            return;
-        }
-        changeKey = key;
-        let matchedPage = scheduler.getMatchedPage(pathname);
-        if (!matchedPage) {
-            // 兜底通配页面
-            matchedPage = scheduler.getMatchedPage('*');
-        }
-        if (matchedPage) {
-            const page = yield matchedPage.component();
-            options.onChange(page, { page: matchedPage });
-        }
-        else {
-            console.warn('Not match any route!');
-            // 兜底 404 页面
-            const NotFound = function NotFound() {
-                return React.createElement('div', null, 'Page Not Found');
-            };
-            options.onChange(NotFound, {
+  var scheduler = options.scheduler;
+  history = createBrowserHistory(options);
+  history.listen( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(historyLocation) {
+      var key, pathname, matchedPage, page, NotFound;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              key = historyLocation.key, pathname = historyLocation.pathname;
+
+              if (!(key && key === changeKey)) {
+                _context.next = 3;
+                break;
+              }
+
+              return _context.abrupt("return");
+
+            case 3:
+              changeKey = key;
+              matchedPage = scheduler.getMatchedPage(pathname);
+
+              if (!matchedPage) {
+                // 兜底通配页面
+                matchedPage = scheduler.getMatchedPage('*');
+              }
+
+              if (!matchedPage) {
+                _context.next = 13;
+                break;
+              }
+
+              _context.next = 9;
+              return matchedPage.component();
+
+            case 9:
+              page = _context.sent;
+              options.onChange(page, {
+                page: matchedPage
+              });
+              _context.next = 16;
+              break;
+
+            case 13:
+              console.warn('Not match any route!'); // 兜底 404 页面
+
+              NotFound = function () {
+                return /*#__PURE__*/React.createElement('div', null, 'Page Not Found');
+              };
+
+              options.onChange(NotFound, {
                 page: {
-                    pathname: pathname,
-                    route: '*',
-                    path: '*',
-                    config: {},
-                    params: {},
-                    component: () => {
-                        return Promise.resolve(NotFound);
-                    },
-                },
-            });
+                  pathname: pathname,
+                  route: '*',
+                  path: '*',
+                  config: {},
+                  params: {},
+                  component: function component() {
+                    return Promise.resolve(NotFound);
+                  }
+                }
+              });
+
+            case 16:
+            case "end":
+              return _context.stop();
+          }
         }
+      }, _callee);
     }));
-    return history;
-}
+
+    return function () {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  return history;
+}

package/lib/index.js

@@ -1,25 +1,42 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.search.js";
+import "core-js/modules/es.string.replace.js";
 import { createHistory } from './history';
 import { Router } from './Router';
 import { RouterScheduler } from './RouterScheduler';
-const scheduler = (window.__ray__routerScheduler__ = new RouterScheduler());
-const router = (window.__ray__router__ = new Router({ scheduler }));
+var scheduler = window.__ray__routerScheduler__ = new RouterScheduler();
+var router = window.__ray__router__ = new Router({
+  scheduler: scheduler
+});
 export function createRouter(options) {
-    const { basename, onChange, routes, tabBar, pages } = options;
-    const history = createHistory({
-        basename,
-        scheduler,
-        onChange: (...args) => {
-            router.$href = window.location.href;
-            onChange(...args);
-        },
-    });
-    // 设置路由基准路径
-    router.scheduler.basename = basename || '/';
-    // 调度器注册页面
-    router.scheduler.registryPages({ routes, tabBar, pages });
-    const { pathname, search, hash } = history.location;
-    // 首次触发 history change
-    history.replace(pathname + search + hash);
-    return router;
+  var basename = options.basename,
+      _onChange = options.onChange,
+      routes = options.routes,
+      tabBar = options.tabBar,
+      pages = options.pages;
+  var history = createHistory({
+    basename: basename,
+    scheduler: scheduler,
+    onChange: function onChange() {
+      router.$href = window.location.href;
+
+      _onChange.apply(void 0, arguments);
+    }
+  }); // 设置路由基准路径
+
+  router.scheduler.basename = basename || '/'; // 调度器注册页面
+
+  router.scheduler.registryPages({
+    routes: routes,
+    tabBar: tabBar,
+    pages: pages
+  });
+  var _history$location = history.location,
+      pathname = _history$location.pathname,
+      search = _history$location.search,
+      hash = _history$location.hash; // 首次触发 history change
+
+  history.replace(pathname + search + hash);
+  return router;
 }
-export default router;
+export default router;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/router",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Ray Core",
   "keywords": [
     "ray"
@@ -20,12 +20,12 @@
     "watch": "tsc -p ./tsconfig.build.json --module esnext --outDir lib --watch"
   },
   "dependencies": {
-    "@ray-js/library": "^1.2.2",
-    "@ray-js/types": "^1.2.2",
+    "@ray-js/library": "^1.2.3",
+    "@ray-js/types": "^1.2.3",
     "history": "4.x"
   },
   "devDependencies": {
-    "@ray-js/cli": "^1.2.2",
+    "@ray-js/cli": "^1.2.3",
     "@types/history": "^4.7.9"
   },
   "maintainers": [
@@ -34,6 +34,6 @@
       "email": "tuyafe@tuya.com"
     }
   ],
-  "gitHead": "e517fe5da418e0caa4c69c9331499d510472dc5e",
+  "gitHead": "85a989192806a0e9dd297f2949778e14386ef1a6",
   "repository": {}
 }