@hsui/core
Version:
Hundsun frontend runtime core framework
1,635 lines (1,500 loc) • 67 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@hsui/sdk'), require('@hsui/logger'), require('vue'), require('vue-router'), require('@@/huiExports')) :
typeof define === 'function' && define.amd ? define(['exports', '@hsui/sdk', '@hsui/logger', 'vue', 'vue-router', '@@/huiExports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.core = {}, global.huiSdk, global.huiLogger, global.Vue, global.VueRouter, global.huiExports));
}(this, (function (exports, sdk, logger$1, Model, Router, huiExports) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var Model__default = /*#__PURE__*/_interopDefaultLegacy(Model);
var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
function _objectWithoutProperties(source, excluded) {
if (source == null) return {};
var target = _objectWithoutPropertiesLoose(source, excluded);
var key, i;
if (Object.getOwnPropertySymbols) {
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceSymbolKeys.length; i++) {
key = sourceSymbolKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
}
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
enumerableOnly && (symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
})), keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {};
i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
_defineProperty(target, key, source[key]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
function _classPrivateFieldBase(receiver, privateKey) {
if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
throw new TypeError("attempted to use private field on non-instance");
}
return receiver;
}
var id = 0;
function _classPrivateFieldKey(name) {
return "__private_" + id++ + "_" + name;
}
function _typeof(obj) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
}, _typeof(obj);
}
/**
* Native isArray
*/
var isArray = Array.isArray;
/**
* Underscore isFunction
*/
function isFunction(value) {
return Object.prototype.toString.call(value) === '[object Function]';
}
/**
* Redux isPlainObject
*/
function isPlainObject(obj) {
if (_typeof(obj) !== 'object' || obj === null) return false;
var proto = obj;
while (Object.getPrototypeOf(proto) !== null) {
proto = Object.getPrototypeOf(proto);
}
return Object.getPrototypeOf(obj) === proto;
}
/**
* Check if powered by HUI Micro App
*/
function isMicroApp() {
return Boolean(window.__POWERED_BY_HUI_MICRO_APP__);
}
/**
* simple generate uuid
* 支持 ie10 及以上
* 基于 uuid v4 添加 performance.now 避免重复
*/
function uuid() {
var d = Date.now();
if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
d += performance.now(); //use high-precision timer if available
}
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
});
}
/**
* Underscore uniqueId
*/
var idCounter = 0;
function uniqueId(prefix) {
var id = ++idCounter + '';
return prefix ? prefix + id : id;
}
/**
* Native extend
*/
var extend = Object.assign;
/**
* Lodash isObject
*/
function isObject$1(value) {
var type = _typeof(value);
return value != null && (type == 'object' || type == 'function');
}
/**
* Underscore clone
*/
function clone(value) {
if (!isObject$1(value)) return value;
if (typeof value === 'function') return value;
return isArray(value) ? value.slice() : extend({}, value);
}
/**
* DeepClone
*/
function deepClone(value) {
return JSON.parse(JSON.stringify(value));
}
var utils = /*#__PURE__*/Object.freeze({
__proto__: null,
isArray: isArray,
isFunction: isFunction,
isPlainObject: isPlainObject,
isMicroApp: isMicroApp,
uuid: uuid,
uniqueId: uniqueId,
extend: extend,
isObject: isObject$1,
clone: clone,
deepClone: deepClone
});
/**
* Lodash isUndefined
*/
function isUndefined(value) {
return value === undefined;
}
/**
* Lodash isObject
*/
function isObject(value) {
var type = _typeof(value);
return value != null && (type == 'object' || type == 'function');
}
/**
* Lodash noop
*/
function noop() {
// No operation performed.
}
function isNull(value) {
return value === null || value === undefined;
}
function isString(value) {
return typeof value === 'string';
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i];
}
return arr2;
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
/**
* @class - MiddlewareManager
* @classdesc - manager of middlewares
*/
var MiddlewareManager = /*#__PURE__*/function () {
function MiddlewareManager(type) {
_classCallCheck(this, MiddlewareManager);
this.type = type;
this.middlewares = [];
this.finalHook = noop;
}
_createClass(MiddlewareManager, [{
key: "final",
value: function final(hook) {
this.finalHook = hook;
}
}, {
key: "concat",
value: function concat(middlewares) {
this.middlewares = this.middlewares.concat(middlewares);
}
}, {
key: "push",
value: function push(middleware) {
this.middlewares.push(middleware);
}
// just run and return nothing
}, {
key: "justRun",
value: function justRun() {
this.args = Array.prototype.slice.call(arguments);
var _this = this;
var fn = function fn(index) {
if (index < this.middlewares.length) {
this.middlewares[index].apply(null, [].concat(_toConsumableArray(this.args), [function () {
fn.call(_this, ++index);
}]));
} else {
this.finalHook.apply(null, this.args);
}
};
fn.call(_this, 0);
}
// run middlewares and return a promise
}, {
key: "runAndReturn",
value: function runAndReturn() {
this.args = Array.prototype.slice.call(arguments);
var _this = this;
return new Promise(function (resolve, reject) {
var fn = function fn(index) {
if (index < this.middlewares.length) {
try {
this.middlewares[index].apply(null, [].concat(_toConsumableArray(this.args), [function () {
fn.call(_this, ++index);
}]));
} catch (error) {
reject(error);
}
} else {
// final hook should return a promise too
this.finalHook.apply(null, this.args).then(resolve).catch(reject);
}
};
fn.call(_this, 0);
});
}
}]);
return MiddlewareManager;
}();
var manager = {};
['before-route-change', 'after-route-change', 'before-request-send', 'after-request-send', 'before-launch'].forEach(function (type) {
manager[type] = new MiddlewareManager(type);
});
var beforeRouteChange = manager['before-route-change'];
var afterRouteChange = manager['after-route-change'];
var beforeRequestSend = manager['before-request-send'];
var afterRequestSend = manager['after-request-send'];
var beforeLaunch = manager['before-launch'];
function registerMiddleware(type, middleware) {
if (isFunction(middleware)) {
manager[type].push(middleware);
}
if (isArray(middleware)) {
manager[type].concat(middleware);
}
}
var logger = logger$1.createLogger();
var log = function log() {
for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
content[_key] = arguments[_key];
}
return logger.info.apply(logger, content);
};
logger.levels.forEach(function (level) {
log[level] = function () {
for (var _len2 = arguments.length, content = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
content[_key2] = arguments[_key2];
}
return logger[level].apply(logger, content);
};
});
function final_(error, response) {
if (error) {
return Promise.reject(error);
}
return Promise.resolve(response);
}
/**
* 合并全局配置和实例配置
* @param {Object} defaultConfig 全局配置
* @param {Object} config 实例配置
* @returns 合并后的请求配置
*/
function mergeConfig(defaultConfig, config) {
var mergedConfig = _objectSpread2(_objectSpread2({}, defaultConfig), config);
if (mergedConfig.shouldMergeHeaders) {
var defaultHeaders = defaultConfig.headers;
var configHeaders = config.headers;
var mergedHeaders = _objectSpread2(_objectSpread2({}, defaultHeaders), configHeaders);
mergedConfig.headers = mergedHeaders;
}
return mergedConfig;
}
/**
* fetchPromise（调用fetch函数得到） 和 ajaxPromise(调用ajax函数得到) 关联对应
* 其中，key 为 fetchPromise，value 为 ajaxPromise
*/
var fetchMap = new WeakMap();
var defaultConfig = {
method: 'post',
data: {},
timeout: 5000,
headers: {},
withCredentials: false
};
var Fetch = /*#__PURE__*/_createClass(function Fetch() {
var _config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, Fetch);
extend(defaultConfig, _config);
var ajaxPromise; // 存储 ajax 返回的 promise
beforeRequestSend.final(function (config) {
return new Promise(function (resolve, reject) {
var error, response;
ajaxPromise = sdk.ajax(config);
ajaxPromise.then(function (res) {
return response = res;
}).catch(function (err) {
return error = err;
}).finally(function () {
afterRequestSend.runAndReturn(error, response).then(resolve).catch(reject);
});
});
});
afterRequestSend.final(final_);
function fetch(config) {
log.debug('Fetch 实例初始化选项', mergeConfig(defaultConfig, config));
var fetchPromise = beforeRequestSend.runAndReturn(mergeConfig(defaultConfig, config));
fetchMap.set(fetchPromise, ajaxPromise); // 建立关联，fetchPromise 和 ajaxPromise
return fetchPromise;
}
fetch.get = function (url, config) {
if (config) {
extend(config, {
url: url,
method: 'get'
});
} else {
config = {
url: url,
method: 'get'
};
}
return fetch(config);
};
fetch.post = function (url, data, config) {
if (config) {
extend(config, {
url: url,
method: 'post',
data: data
});
} else {
config = {
url: url,
method: 'post',
data: data
};
}
return fetch(config);
};
fetch.cancel = function () {
for (var _len = arguments.length, fetchPromises = new Array(_len), _key = 0; _key < _len; _key++) {
fetchPromises[_key] = arguments[_key];
}
fetchPromises.forEach(function (fetchPromise, index) {
var ajaxPromise = fetchMap.get(fetchPromise);
var cancel = sdk.ajaxCancelMap.get(ajaxPromise);
cancel ? cancel() : log.debug("\u6CA1\u6709\u627E\u5230\u4E0B\u6807\u4E3A ".concat(index, " \u5BF9\u5E94\u7684 cancel \u51FD\u6570"));
});
};
return fetch;
});
function initFetch() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$defaultConfig = _ref.defaultConfig,
defaultConfig = _ref$defaultConfig === void 0 ? {
method: 'post',
data: {},
timeout: 5000,
headers: {},
withCredentials: false
} : _ref$defaultConfig,
_ref$beforeRequestSen = _ref.beforeRequestSendMiddlewares,
beforeRequestSendMiddlewares = _ref$beforeRequestSen === void 0 ? [] : _ref$beforeRequestSen,
_ref$afterRequestSend = _ref.afterRequestSendMiddlewares,
afterRequestSendMiddlewares = _ref$afterRequestSend === void 0 ? [] : _ref$afterRequestSend;
var beforeRequestSend = new MiddlewareManager('before-request-send');
beforeRequestSend.concat(beforeRequestSendMiddlewares);
var afterRequestSend = new MiddlewareManager('after-request-send');
afterRequestSend.concat(afterRequestSendMiddlewares);
afterRequestSend.final(final_);
var ajaxPromise; // 存储 ajax 函数返回的 promise
beforeRequestSend.final(function (config) {
return new Promise(function (resolve, reject) {
var error, response;
ajaxPromise = sdk.ajax(config);
ajaxPromise.then(function (res) {
return response = res;
}).catch(function (err) {
return error = err;
}).finally(function () {
afterRequestSend.runAndReturn(error, response).then(resolve).catch(reject);
});
});
});
var fetch = function fetch(config) {
log.debug('Fetch 实例初始化选项', mergeConfig(defaultConfig, config));
var fetchPromise = beforeRequestSend.runAndReturn(mergeConfig(defaultConfig, config));
fetchMap.set(fetchPromise, ajaxPromise);
return fetchPromise;
};
fetch.get = function (url, config) {
if (config) {
extend(config, {
url: url,
method: 'get'
});
} else {
config = {
url: url,
method: 'get'
};
}
return fetch(config);
};
fetch.post = function (url, data, config) {
if (config) {
extend(config, {
url: url,
method: 'post',
data: data
});
} else {
config = {
url: url,
method: 'post',
data: data
};
}
return fetch(config);
};
fetch.cancel = function () {
for (var _len2 = arguments.length, fetchPromises = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
fetchPromises[_key2] = arguments[_key2];
}
fetchPromises.forEach(function (fetchPromise, index) {
var ajaxPromise = fetchMap.get(fetchPromise); // 根据传入的 fetchPromise，查找对应的 ajaxPromise
var cancel = sdk.ajaxCancelMap.get(ajaxPromise); // 根据指定的 ajaxPromise，查找对应的取消函数
cancel ? cancel() : log.debug("\u6CA1\u6709\u627E\u5230\u4E0B\u6807\u4E3A ".concat(index, " \u5BF9\u5E94\u7684 cancel \u51FD\u6570"));
});
};
return fetch;
}
var _require = require('../package.json'),
version = _require.version;
var isNavigationFailure = Router__default['default'].isNavigationFailure,
NavigationFailureType = Router__default['default'].NavigationFailureType;
var encodeReserveRE = /[!'()*]/g;
var encodeReserveReplacer = function encodeReserveReplacer(c) {
return '%' + c.charCodeAt(0).toString(16);
};
var commaRE = /%2C/g;
// fixed encodeURIComponent which is more conformant to RFC3986:
// - escapes [!'()*]
// - preserve commas
var encode = function encode(str) {
return encodeURIComponent(str).replace(encodeReserveRE, encodeReserveReplacer).replace(commaRE, ',');
};
var decode = decodeURIComponent;
var defaultRouterOpts = {
scrollBehavior: function scrollBehavior() {
return {
x: 0,
y: 0
};
}
};
var router = null;
function initRouter$1(routes, opts) {
if (router) return router;
// 避免在调用 initRouter 之前注册，在 1.0 的场景下，多个子应用都访问 @hsui/core 的情况下会造成冲突
Model__default['default'].use(Router__default['default']);
// 合并 defaultRouterOpts
opts = _objectSpread2(_objectSpread2({}, defaultRouterOpts), opts);
// 保证在 hash 模式下也能从 location.search 中读取查询参数
// TODO - 暂时还没有解决方案，在主子应用同时存在路由参数的情况下，url 会存在多个 search 片段的问题
if (opts.mode === 'hash') {
opts = _objectSpread2(_objectSpread2({}, opts), {}, {
parseQuery: function parseQuery(query) {
var res = {};
query = query.trim().replace(/^(\?|#|&)/, '');
if (!query) {
var _location = location,
search = _location.search;
search = search.trim().replace(/^(\?|#|&)/, '');
if (!search) {
return res;
}
query = search;
}
query.split('&').forEach(function (param) {
var parts = param.replace(/\+/g, ' ').split('=');
var key = decode(parts.shift());
var val = parts.length > 0 ? decode(parts.join('=')) : null;
if (res[key] === undefined) {
res[key] = val;
} else if (Array.isArray(res[key])) {
res[key].push(val);
} else {
res[key] = [res[key], val];
}
});
return res;
},
stringifyQuery: function stringifyQuery(obj) {
var res = obj ? Object.keys(obj).map(function (key) {
var val = obj[key];
if (val === undefined) {
return '';
}
if (val === null) {
return encode(key);
}
if (Array.isArray(val)) {
var result = [];
val.forEach(function (val2) {
if (val2 === undefined) {
return;
}
if (val2 === null) {
result.push(encode(key));
} else {
result.push(encode(key) + '=' + encode(val2));
}
});
return result.join('&');
}
return encode(key) + '=' + encode(val);
}).filter(function (x) {
return x.length > 0;
}).join('&') : null;
if (res && !location.search.includes(res)) {
return "?".concat(res);
}
return '';
}
});
}
router = new Router__default['default'](opts);
if (routes) {
router.addRoutes(routes);
}
log.debug('Router 实例', router);
log.debug('Router 构建选项', opts);
log.debug('Routes 路由记录', router.getRoutes());
router.beforeEach(function (to, from, next) {
log.debug('路由跳转前置导航守卫', to, from);
next();
});
beforeRouteChange.middlewares.forEach(function (middleware) {
return router.beforeEach(middleware);
});
router.afterEach(function (to, from) {
log.debug('路由跳转后置导航守卫', to, from);
afterRouteChange.justRun(to, from);
});
return router;
}
/**
* Set default router options
* @param {object} opts
*/
function setRouterOpts(opts) {
extend(defaultRouterOpts, opts);
}
/**
* @description jump programmatically
* @param {String} path target path
* @param {Object} opts options
* @param {Boolean} opts.history whether to keep current browser history, perform like pushState or replaceState, default true
* @param {Boolean} opts.animation todo
* @param {Object} query query params
*/
function navigate(path, opts, query) {
if (!router) return;
var defaultOpts = {
history: true
};
var defaultQuery = {};
if (!_typeof(path) === 'string' || path === '') {
log.error('navigate 方法必须指定 path 为字符串类型且不能为空');
return false;
}
// 只有两个参数，则第二个为 query
if (isPlainObject(opts) && isUndefined(query)) {
query = opts;
opts = defaultOpts;
}
// path 是必填项
if (isUndefined(opts)) {
opts = defaultOpts;
query = defaultQuery;
}
var _opts = opts,
history = _opts.history;
var onError = function onError(err) {
if (isNavigationFailure(err, NavigationFailureType.duplicated) || isNavigationFailure(err, NavigationFailureType.redirected)) {
return;
}
log.error('路由跳转异常', err);
throw err;
};
if (history) {
router.push({
path: path,
query: query
}).catch(onError);
} else {
router.replace({
path: path,
query: query
}).catch(onError);
}
}
/**
* @description go forwards or go backwards in the history stack programmatically
* @param {Number} n steps to go, setting to 0 perform like reload
*/
function go(n) {
if (!router) return;
router.go(n);
}
/**
* https://github.com/developit/mitt
*/
function mitt(all) {
all = all || new Map();
return {
on: function on(type, handler) {
var handlers = all.get(type);
var added = handlers && handlers.push(handler);
if (!added) {
all.set(type, [handler]);
}
log.debug('部署事件监听', type);
},
off: function off(type, handler) {
var handlers = all.get(type);
if (handlers) {
if (handler) {
handlers.splice(handlers.indexOf(handler) >>> 0, 1);
} else {
all.set(type, []);
}
}
log.debug('取消事件监听', type);
},
emit: function emit(type) {
log.debug.apply(log, ['触发事件监听'].concat(Array.prototype.slice.call(arguments)));
var args = Array.prototype.slice.call(arguments);
(all.get(type) || []).slice().map(function (handler) {
log.debug('响应事件监听', type, handler);
handler.apply(null, args.slice(1));
});
(all.get('*') || []).slice().map(function (handler) {
log.debug('响应事件监听', type, handler);
handler.apply(null, args);
});
}
};
}
var emitter = mitt();
emitter.once = function (type, handler) {
var _handler = function _handler() {
handler.apply(null, Array.prototype.slice.call(arguments));
emitter.off(type, _handler);
};
emitter.on(type, _handler);
};
var on = emitter.on,
once = emitter.once,
off = emitter.off,
emit = emitter.emit,
trigger = emitter.emit;
/**
* Path parser
* - Inspired:
* Vue.js Path parser
*/
// actions
var APPEND = 0;
var PUSH = 1;
var INC_SUB_PATH_DEPTH = 2;
var PUSH_SUB_PATH = 3;
// states
var BEFORE_PATH = 0;
var IN_PATH = 1;
var BEFORE_IDENT = 2;
var IN_IDENT = 3;
var IN_SUB_PATH = 4;
var IN_SINGLE_QUOTE = 5;
var IN_DOUBLE_QUOTE = 6;
var AFTER_PATH = 7;
var ERROR = 8;
var pathStateMachine = [];
pathStateMachine[BEFORE_PATH] = {
ws: [BEFORE_PATH],
ident: [IN_IDENT, APPEND],
'[': [IN_SUB_PATH],
eof: [AFTER_PATH]
};
pathStateMachine[IN_PATH] = {
ws: [IN_PATH],
'.': [BEFORE_IDENT],
'[': [IN_SUB_PATH],
eof: [AFTER_PATH]
};
pathStateMachine[BEFORE_IDENT] = {
ws: [BEFORE_IDENT],
ident: [IN_IDENT, APPEND],
'0': [IN_IDENT, APPEND],
number: [IN_IDENT, APPEND]
};
pathStateMachine[IN_IDENT] = {
ident: [IN_IDENT, APPEND],
'0': [IN_IDENT, APPEND],
number: [IN_IDENT, APPEND],
ws: [IN_PATH, PUSH],
'.': [BEFORE_IDENT, PUSH],
'[': [IN_SUB_PATH, PUSH],
eof: [AFTER_PATH, PUSH]
};
pathStateMachine[IN_SUB_PATH] = {
"'": [IN_SINGLE_QUOTE, APPEND],
'"': [IN_DOUBLE_QUOTE, APPEND],
'[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH],
']': [IN_PATH, PUSH_SUB_PATH],
eof: ERROR,
else: [IN_SUB_PATH, APPEND]
};
pathStateMachine[IN_SINGLE_QUOTE] = {
"'": [IN_SUB_PATH, APPEND],
eof: ERROR,
else: [IN_SINGLE_QUOTE, APPEND]
};
pathStateMachine[IN_DOUBLE_QUOTE] = {
'"': [IN_SUB_PATH, APPEND],
eof: ERROR,
else: [IN_DOUBLE_QUOTE, APPEND]
};
/**
* Check if an expression is a literal value.
*/
var literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
function isLiteral(exp) {
return literalValueRE.test(exp);
}
/**
* Strip quotes from a string
*/
function stripQuotes(str) {
var a = str.charCodeAt(0);
var b = str.charCodeAt(str.length - 1);
return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
}
/**
* Determine the type of a character in a keypath.
*/
function getPathCharType(ch) {
if (ch === undefined || ch === null) {
return 'eof';
}
var code = ch.charCodeAt(0);
switch (code) {
case 0x5b: // [
case 0x5d: // ]
case 0x2e: // .
case 0x22: // "
case 0x27:
// '
return ch;
case 0x5f: // _
case 0x24: // $
case 0x2d:
// -
return 'ident';
case 0x09: // Tab
case 0x0a: // Newline
case 0x0d: // Return
case 0xa0: // No-break space
case 0xfeff: // Byte Order Mark
case 0x2028: // Line Separator
case 0x2029:
// Paragraph Separator
return 'ws';
}
return 'ident';
}
/**
* Format a subPath, return its plain form if it is
* a literal string or number. Otherwise prepend the
* dynamic indicator (*).
*/
function formatSubPath(path) {
var trimmed = path.trim();
// invalid leading 0
if (path.charAt(0) === '0') {
return false;
}
return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed;
}
/**
* Parse a string path into an array of segments
*/
function parse(path) {
var keys = [];
var index = -1;
var mode = BEFORE_PATH;
var subPathDepth = 0;
var c;
var key;
var newChar;
var type;
var transition;
var action;
var typeMap;
var actions = [];
actions[PUSH] = function () {
if (key !== undefined) {
keys.push(key);
key = undefined;
}
};
actions[APPEND] = function () {
if (key === undefined) {
key = newChar;
} else {
key += newChar;
}
};
actions[INC_SUB_PATH_DEPTH] = function () {
actions[APPEND]();
subPathDepth++;
};
actions[PUSH_SUB_PATH] = function () {
if (subPathDepth > 0) {
subPathDepth--;
mode = IN_SUB_PATH;
actions[APPEND]();
} else {
subPathDepth = 0;
if (key === undefined) {
return false;
}
key = formatSubPath(key);
if (key === false) {
return false;
} else {
actions[PUSH]();
}
}
};
function maybeUnescapeQuote() {
var nextChar = path[index + 1];
if (mode === IN_SINGLE_QUOTE && nextChar === "'" || mode === IN_DOUBLE_QUOTE && nextChar === '"') {
index++;
newChar = '\\' + nextChar;
actions[APPEND]();
return true;
}
}
while (mode !== null) {
index++;
c = path[index];
if (c === '\\' && maybeUnescapeQuote()) {
continue;
}
type = getPathCharType(c);
typeMap = pathStateMachine[mode];
transition = typeMap[type] || typeMap['else'] || ERROR;
if (transition === ERROR) {
return; // parse error
}
mode = transition[0];
action = actions[transition[1]];
if (action) {
newChar = transition[2];
newChar = newChar === undefined ? c : newChar;
if (action() === false) {
return;
}
}
if (mode === AFTER_PATH) {
return keys;
}
}
}
var I18nPath = /*#__PURE__*/function () {
function I18nPath() {
_classCallCheck(this, I18nPath);
this._cache = void 0;
this._cache = Object.create(null);
}
/**
* External parse that check for a cache hit first
*/
_createClass(I18nPath, [{
key: "parsePath",
value: function parsePath(path) {
var hit = this._cache[path];
if (!hit) {
hit = parse(path);
if (hit) {
this._cache[path] = hit;
}
}
return hit || [];
}
/**
* Get path value from path string
*/
}, {
key: "getPathValue",
value: function getPathValue(obj, path) {
if (!isObject(obj)) {
return null;
}
var paths = this.parsePath(path);
if (paths.length === 0) {
return null;
} else {
var length = paths.length;
var last = obj;
var i = 0;
while (i < length) {
var value = last[paths[i]];
if (value === undefined || value === null) {
return null;
}
last = value;
i++;
}
return last;
}
}
}]);
return I18nPath;
}();
var i18ns = [];
var I18n = /*#__PURE__*/function () {
/**
* lightweight i18n
* @param {object} options
* - locale
* - messages
*/
function I18n(options) {
_classCallCheck(this, I18n);
this.locale = options.locale || 'en-US';
this.messages = options.messages || {};
// window.__hCoreReference
var root = window.__hCoreReference__.root;
this._root = options.root || root || null;
this._path = new I18nPath();
this.watchLocale();
i18ns.push(this);
}
_createClass(I18n, [{
key: "watchLocale",
value: function watchLocale() {
// sync with vue-i18n root
if (this._root && this._root.$i18n) {
// locale watcher
var _this = this;
this.localeWatcher = this._root.$i18n.vm.$watch('locale', function (val) {
_this.locale = val;
}, {
immediate: true
});
}
return null;
}
// string support only
}, {
key: "_translate",
value: function _translate(message, key) {
var pathRet = this._path.getPathValue(message, key);
if (isArray(pathRet) || isPlainObject(pathRet)) {
return pathRet;
}
var ret;
if (isNull(pathRet) && isPlainObject(message)) {
ret = message[key];
} else if (isString(pathRet)) {
ret = pathRet;
} else {
return null;
}
return !isString(ret) ? ret.join('') : ret;
}
}, {
key: "t",
value: function t(key) {
if (!key) return '';
var message = this.messages[this.locale];
if (message) {
return this._translate(message, key);
}
return '';
}
}]);
return I18n;
}();
var _app = /*#__PURE__*/_classPrivateFieldKey("app");
var _isNavigable = /*#__PURE__*/_classPrivateFieldKey("isNavigable");
var _options = /*#__PURE__*/_classPrivateFieldKey("options");
var _walkOpts = /*#__PURE__*/_classPrivateFieldKey("walkOpts");
var HCore = /*#__PURE__*/function () {
function HCore(_opts) {
_classCallCheck(this, HCore);
Object.defineProperty(this, _walkOpts, {
value: _walkOpts2
});
Object.defineProperty(this, _app, {
writable: true,
value: void 0
});
// enable or disable router system
Object.defineProperty(this, _isNavigable, {
writable: true,
value: true
});
// model options
Object.defineProperty(this, _options, {
writable: true,
value: {
el: '#app',
beforeDestroy: function beforeDestroy() {
i18ns.forEach(function (i18n) {
if (i18n.localeWatcher) {
delete i18n.localeWatcher;
i18n = null;
}
});
}
}
});
if (!!_classPrivateFieldBase(this, _app)[_app]) {
return _classPrivateFieldBase(this, _app)[_app];
}
_classPrivateFieldBase(this, _app)[_app] = this;
_classPrivateFieldBase(this, _walkOpts)[_walkOpts](_opts);
this.Model.prototype.$hCore = _classPrivateFieldBase(this, _app)[_app];
if (!this.ajax) {
var fetch = new Fetch();
extend(this, {
ajax: fetch,
fetch: fetch
});
}
extend(this, {
middleware: registerMiddleware
});
extend(this, {
on: on,
once: once,
off: off,
emit: emit,
trigger: trigger
});
extend(this, {
log: log,
logger: logger
});
extend(this, {
utils: utils
});
extend(this, {
storage: sdk.storage
});
extend(this, {
navigate: navigate,
go: go
});
}
_createClass(HCore, [{
key: "Model",
get: function get() {
return Model__default['default'];
}
}, {
key: "options",
get: function get() {
return _classPrivateFieldBase(this, _options)[_options];
}
}, {
key: "version",
get: function get() {
return version;
}
}, {
key: "initRouter",
value: function initRouter(routes, opts) {
if (_classPrivateFieldBase(this, _isNavigable)[_isNavigable]) {
var router = initRouter$1(routes, opts);
extend(_classPrivateFieldBase(this, _options)[_options], {
router: router,
template: '<router-view></router-view>'
});
extend(this, {
router: router
});
}
}
}, {
key: "addRoutes",
value: function addRoutes(routes) {
if (this.router) {
this.log.debug('新增 Routes 路由记录', routes);
this.router.addRoutes(routes);
} else {
this.initRouter(routes);
}
}
}, {
key: "start",
value: function start(cb) {
var _this = this;
// 在应用前要确保已经完成路由系统的初始化
if (!this.router) {
this.initRouter();
}
// 这里最好不要有异步逻辑，在微前端框架下可能会出现问题
// 暂时不对外
beforeLaunch.final(function () {
// 在微前端框架下应用生命周期被接管
if (!isMicroApp()) {
_this.root = new _this.Model(_classPrivateFieldBase(_this, _options)[_options]);
_this.root.$nextTick(function () {
trigger('app-ready', _this.root);
cb && cb(_this.root);
});
} else {
// 启动的回调函数传递给 singleSpaVue，保持和独立运行一致的处理逻辑
trigger('app-start', cb);
}
});
beforeLaunch.justRun(this);
}
}]);
return HCore;
}();
function _walkOpts2(opts) {
var _this2 = this;
if (isPlainObject(opts)) {
Object.keys(opts).forEach(function (key) {
// ajaxConfig === fetchConfig
if (key === 'ajaxConfig' || key === 'fetchConfig') {
var fetch = new Fetch(opts[key]);
extend(_this2, {
ajax: fetch,
fetch: fetch
}); // ajax === fetch
}
// logLevel
if (key === 'logLevel') {
logger.setLevel(opts[key]);
}
// extra vue options
if (key === 'extraModelOptions') {
var staticModelKey = ['router'];
Object.keys(opts[key]).filter(function (modelKey) {
return !staticModelKey.includes(modelKey);
}).forEach(function (modelKey) {
extend(_classPrivateFieldBase(_this2, _options)[_options], _defineProperty({}, modelKey, opts[key][modelKey]));
// store
if (modelKey === 'store') {
extend(_this2, _defineProperty({}, modelKey, opts[key][modelKey]));
}
});
}
// extra router options
if (key === 'extraRouterOptions') {
if (typeof opts[key]['isNavigable'] !== 'undefined') {
_classPrivateFieldBase(_this2, _isNavigable)[_isNavigable] = opts[key]['isNavigable'];
}
if (_classPrivateFieldBase(_this2, _isNavigable)[_isNavigable]) {
_classPrivateFieldBase(_this2, _isNavigable)[_isNavigable] && setRouterOpts(opts[key]);
}
}
});
}
}
function _regeneratorRuntime() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
_regeneratorRuntime = function _regeneratorRuntime() {
return exports;
};
var exports = {},
Op = Object.prototype,
hasOwn = Op.hasOwnProperty,
$Symbol = "function" == typeof Symbol ? Symbol : {},
iteratorSymbol = $Symbol.iterator || "@@iterator",
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
function define(obj, key, value) {
return Object.defineProperty(obj, key, {
value: value,
enumerable: !0,
configurable: !0,
writable: !0
}), obj[key];
}
try {
define({}, "");
} catch (err) {
define = function define(obj, key, value) {
return obj[key] = value;
};
}
function wrap(innerFn, outerFn, self, tryLocsList) {
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
generator = Object.create(protoGenerator.prototype),
context = new Context(tryLocsList || []);
return generator._invoke = function (innerFn, self, context) {
var state = "suspendedStart";
return function (method, arg) {
if ("executing" === state) throw new Error("Generator is already running");
if ("completed" === state) {
if ("throw" === method) throw arg;
return doneResult();
}
for (context.method = method, context.arg = arg;;) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
if ("suspendedStart" === state) throw state = "completed", context.arg;
context.dispatchException(context.arg);
} else "return" === context.method && context.abrupt("return", context.arg);
state = "executing";
var record = tryCatch(innerFn, self, context);
if ("normal" === record.type) {
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
return {
value: record.arg,
done: context.done
};
}
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
}
};
}(innerFn, self, context), generator;
}
function tryCatch(fn, obj, arg) {
try {
return {
type: "normal",
arg: fn.call(obj, arg)
};
} catch (err) {
return {
type: "throw",
arg: err
};
}
}
exports.wrap = wrap;
var ContinueSentinel = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var IteratorPrototype = {};
define(IteratorPrototype, iteratorSymbol, function () {
return this;
});
var getProto = Object.getPrototypeOf,
NativeIteratorPrototype = getProto && getProto(getProto(values([])));
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function (method) {
define(prototype, method, function (arg) {
return this._invoke(method, arg);
});
});
}
function AsyncIterator(generator, PromiseImpl) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if ("throw" !== record.type) {
var result = record.arg,
value = result.value;
return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
invoke("next", value, resolve, reject);
}, function (err) {
invoke("throw", err, resolve, reject);
}) : PromiseImpl.resolve(value).then(function (unwrapped) {
result.value = unwrapped, resolve(result);
}, function (error) {
return invoke("throw", error, resolve, reject);
});
}
reject(record.arg);
}
var previousPromise;
this._invoke = function (method, arg) {
function callInvokeWithMethodAndArg() {
return new PromiseImpl(function (resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
};
}
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (undefined === method) {
if (context.delegate = null, "throw" === context.method) {
if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
}
return ContinueSentinel;
}
var record = tryCatch(method, delegate.iterator, context.arg);
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
var info = record.arg;
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
}
function pushTryEntry(locs) {
var entry = {
tryLoc: locs[0]
};
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal", delete record.arg, entry.completion = record;
}
function Context(tryLocsList) {
this.tryEntries = [{
tryLoc: "root"
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
}
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) return iteratorMethod.call(iterable);
if ("function" == typeof iterable.next) return iterable;
if (!isNaN(iterable.length)) {
var i = -1,
next = function next() {
for (; ++i < iterable.length;) {
if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
}
return next.value = undefined, next.done = !0, next;
};
return next.next = next;
}
}
return {
next: doneResult
};
}
function doneResult() {
return {
value: undefined,
done: !0
};
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
var ctor = "function" == typeof genFun && genFun.constructor;
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
}, exports.mark = function (genFun) {
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
}, exports.awrap = function (arg) {
return {
__await: arg
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
return this;
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
void 0 === PromiseImpl && (PromiseImpl = Promise);
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
return result.done ? result.value : iter.next();
});
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
return this;
}), define(Gp, "toString", function () {
return "[object Generator]";
}), exports.keys = function (object) {
var keys = [];
for (var key in object) {
keys.push(key);
}
return keys.reverse(), function next() {
for (; keys.length;) {
var key = keys.pop();
if (key in object) return next.value = key, next.done = !1, next;
}
return next.done = !0, next;
};
}, exports.values = values, Context.prototype = {
constructor: Context,
reset: function reset(skipTempReset) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
"t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
}
},
stop: function stop() {
this.done = !0;
var rootRecord = this.tryEntries[0].completion;
if ("throw" === rootRecord.type) throw root