react-view-router
Version:
react-view-router
132 lines • 5.29 kB
JavaScript
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
import _regeneratorRuntime from "@babel/runtime/regenerator";
import "core-js/modules/es6.object.to-string.js";
import "core-js/modules/es6.promise.js";
import "core-js/modules/es6.symbol.js";
import "core-js/modules/es6.array.filter.js";
import "core-js/modules/es7.object.get-own-property-descriptors.js";
import React from 'react';
import { innumerable } from './util';
import { REACT_LAZY_TYPE } from './route-guard';
function isEsModule(value) {
return value && value.__esModule;
}
export class RouteLazy {
constructor(ctor, options = {}) {
_defineProperty(this, "$$typeof", REACT_LAZY_TYPE);
_defineProperty(this, "updaters", []);
this._ctor = ctor;
this._result = null;
this.routeLazyInstance = true;
this.options = options;
this.render = this.render.bind(this);
this.resolved = false;
this.updaters = [];
}
toResolve(router, route, key) {
var _this = this;
return new Promise(/*#__PURE__*/function () {
var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(resolve, reject) {
var _resolve, component, _t, _t2;
return _regeneratorRuntime.wrap(function (_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_resolve = v => {
v = isEsModule(v) ? v.default : v;
var updaters = _this.updaters.splice(0, _this.updaters.length);
updaters.forEach(updater => v = updater(v, router) || v);
if (!_this.resolved) {
_this._result = v;
_this.resolved = true;
}
resolve(v);
};
if (!_this.resolved) {
_context.next = 1;
break;
}
_resolve(_this._result);
return _context.abrupt("return");
case 1:
component = _this._ctor.__lazyImportMethod ? _this._ctor(route, key, router, _this.options) : _this._ctor;
_context.prev = 2;
if (!isPromise(component)) {
_context.next = 4;
break;
}
_context.next = 3;
return component;
case 3:
_t = _context.sent;
_context.next = 5;
break;
case 4:
_t = component;
case 5:
component = _t;
_context.next = 7;
break;
case 6:
_context.prev = 6;
_t2 = _context["catch"](2);
reject(_t2);
return _context.abrupt("return");
case 7:
if (component) {
_context.next = 8;
break;
}
reject(new Error('component should not null!'));
return _context.abrupt("return");
case 8:
if (component instanceof Promise) {
component.then(_resolve).catch(function () {
return reject(...arguments);
});
} else _resolve(component);
case 9:
case "end":
return _context.stop();
}
}, _callee, null, [[2, 6]]);
}));
return function (_x, _x2) {
return _ref.apply(this, arguments);
};
}());
}
render(props, ref) {
if (!this.resolved || !this._result) return null;
return /*#__PURE__*/React.createElement(this._result, _objectSpread(_objectSpread({}, props), {}, {
ref
}), props.children);
}
}
export function hasRouteLazy(route) {
var config = route.config || route;
if (config.components instanceof RouteLazy) return true;
if (config.components) {
for (var _i = 0, _Object$keys = Object.keys(config.components); _i < _Object$keys.length; _i++) {
var key = _Object$keys[_i];
if (config.components[key] instanceof RouteLazy) return true;
}
}
return false;
}
export function hasMatchedRouteLazy(matched) {
return matched && matched.some(r => hasRouteLazy(r));
}
export function lazyImport(importMethod, options = {}) {
innumerable(importMethod, '__lazyImportMethod', true);
return new RouteLazy(importMethod, options || {});
}
export function isRouteLazy(value) {
return value && value.routeLazyInstance;
}
export function isPromise(value) {
return value && value.then;
}
//# sourceMappingURL=route-lazy.js.map