icemilk
Version:
Shanghai jinbaozheng easy network technology Co.,Ltd sdk
1,440 lines (1,397 loc) • 85.1 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var axios = _interopDefault(require('axios'));
var moment = _interopDefault(require('moment'));
const __LhtFsgSwWaN__ = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__ = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__ = ' oHT8zX*i#3BMac', __VIynuBdCjTo__ = 'DCr~q_PVvNYWpym', __ckPQmJx__ = 'kSt64xLRZJw';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
}
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function commonjsRequire () {
throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
}
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
function getCjsExportFromNamespace (n) {
return n && n['default'] || n;
}
var urlPattern = createCommonjsModule(function (module, exports) {
const __LhtFsgSwWaN__ = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__ = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__ = ' oHT8zX*i#3BMac', __VIynuBdCjTo__ = 'DCr~q_PVvNYWpym', __ckPQmJx__ = 'kSt64xLRZJw';
// Generated by CoffeeScript 1.10.0
var slice = [].slice;
(function(root, factory) {
if (('function' === typeof undefined) && (undefined.amd != null)) {
return undefined([], factory);
} else if ('object' !== "undefined" && exports !== null) {
return module.exports = factory();
} else {
return root.UrlPattern = factory();
}
})(commonjsGlobal, function() {
var P, UrlPattern, astNodeContainsSegmentsForProvidedParams, astNodeToNames, astNodeToRegexString, baseAstNodeToRegexString, concatMap, defaultOptions, escapeForRegex, getParam, keysAndValuesToObject, newParser, regexGroupCount, stringConcatMap, stringify;
escapeForRegex = function(string) {
return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
};
concatMap = function(array, f) {
var i, length, results;
results = [];
i = -1;
length = array.length;
while (++i < length) {
results = results.concat(f(array[i]));
}
return results;
};
stringConcatMap = function(array, f) {
var i, length, result;
result = '';
i = -1;
length = array.length;
while (++i < length) {
result += f(array[i]);
}
return result;
};
regexGroupCount = function(regex) {
return (new RegExp(regex.toString() + '|')).exec('').length - 1;
};
keysAndValuesToObject = function(keys, values) {
var i, key, length, object, value;
object = {};
i = -1;
length = keys.length;
while (++i < length) {
key = keys[i];
value = values[i];
if (value == null) {
continue;
}
if (object[key] != null) {
if (!Array.isArray(object[key])) {
object[key] = [object[key]];
}
object[key].push(value);
} else {
object[key] = value;
}
}
return object;
};
P = {};
P.Result = function(value, rest) {
this.value = value;
this.rest = rest;
};
P.Tagged = function(tag, value) {
this.tag = tag;
this.value = value;
};
P.tag = function(tag, parser) {
return function(input) {
var result, tagged;
result = parser(input);
if (result == null) {
return;
}
tagged = new P.Tagged(tag, result.value);
return new P.Result(tagged, result.rest);
};
};
P.regex = function(regex) {
return function(input) {
var matches, result;
matches = regex.exec(input);
if (matches == null) {
return;
}
result = matches[0];
return new P.Result(result, input.slice(result.length));
};
};
P.sequence = function() {
var parsers;
parsers = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return function(input) {
var i, length, parser, rest, result, values;
i = -1;
length = parsers.length;
values = [];
rest = input;
while (++i < length) {
parser = parsers[i];
result = parser(rest);
if (result == null) {
return;
}
values.push(result.value);
rest = result.rest;
}
return new P.Result(values, rest);
};
};
P.pick = function() {
var indexes, parsers;
indexes = arguments[0], parsers = 2 <= arguments.length ? slice.call(arguments, 1) : [];
return function(input) {
var array, result;
result = P.sequence.apply(P, parsers)(input);
if (result == null) {
return;
}
array = result.value;
result.value = array[indexes];
return result;
};
};
P.string = function(string) {
var length;
length = string.length;
return function(input) {
if (input.slice(0, length) === string) {
return new P.Result(string, input.slice(length));
}
};
};
P.lazy = function(fn) {
var cached;
cached = null;
return function(input) {
if (cached == null) {
cached = fn();
}
return cached(input);
};
};
P.baseMany = function(parser, end, stringResult, atLeastOneResultRequired, input) {
var endResult, parserResult, rest, results;
rest = input;
results = stringResult ? '' : [];
while (true) {
if (end != null) {
endResult = end(rest);
if (endResult != null) {
break;
}
}
parserResult = parser(rest);
if (parserResult == null) {
break;
}
if (stringResult) {
results += parserResult.value;
} else {
results.push(parserResult.value);
}
rest = parserResult.rest;
}
if (atLeastOneResultRequired && results.length === 0) {
return;
}
return new P.Result(results, rest);
};
P.many1 = function(parser) {
return function(input) {
return P.baseMany(parser, null, false, true, input);
};
};
P.concatMany1Till = function(parser, end) {
return function(input) {
return P.baseMany(parser, end, true, true, input);
};
};
P.firstChoice = function() {
var parsers;
parsers = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return function(input) {
var i, length, parser, result;
i = -1;
length = parsers.length;
while (++i < length) {
parser = parsers[i];
result = parser(input);
if (result != null) {
return result;
}
}
};
};
newParser = function(options) {
var U;
U = {};
U.wildcard = P.tag('wildcard', P.string(options.wildcardChar));
U.optional = P.tag('optional', P.pick(1, P.string(options.optionalSegmentStartChar), P.lazy(function() {
return U.pattern;
}), P.string(options.optionalSegmentEndChar)));
U.name = P.regex(new RegExp("^[" + options.segmentNameCharset + "]+"));
U.named = P.tag('named', P.pick(1, P.string(options.segmentNameStartChar), P.lazy(function() {
return U.name;
})));
U.escapedChar = P.pick(1, P.string(options.escapeChar), P.regex(/^./));
U["static"] = P.tag('static', P.concatMany1Till(P.firstChoice(P.lazy(function() {
return U.escapedChar;
}), P.regex(/^./)), P.firstChoice(P.string(options.segmentNameStartChar), P.string(options.optionalSegmentStartChar), P.string(options.optionalSegmentEndChar), U.wildcard)));
U.token = P.lazy(function() {
return P.firstChoice(U.wildcard, U.optional, U.named, U["static"]);
});
U.pattern = P.many1(P.lazy(function() {
return U.token;
}));
return U;
};
defaultOptions = {
escapeChar: '\\',
segmentNameStartChar: ':',
segmentValueCharset: 'a-zA-Z0-9-_~ %',
segmentNameCharset: 'a-zA-Z0-9',
optionalSegmentStartChar: '(',
optionalSegmentEndChar: ')',
wildcardChar: '*'
};
baseAstNodeToRegexString = function(astNode, segmentValueCharset) {
if (Array.isArray(astNode)) {
return stringConcatMap(astNode, function(node) {
return baseAstNodeToRegexString(node, segmentValueCharset);
});
}
switch (astNode.tag) {
case 'wildcard':
return '(.*?)';
case 'named':
return "([" + segmentValueCharset + "]+)";
case 'static':
return escapeForRegex(astNode.value);
case 'optional':
return '(?:' + baseAstNodeToRegexString(astNode.value, segmentValueCharset) + ')?';
}
};
astNodeToRegexString = function(astNode, segmentValueCharset) {
if (segmentValueCharset == null) {
segmentValueCharset = defaultOptions.segmentValueCharset;
}
return '^' + baseAstNodeToRegexString(astNode, segmentValueCharset) + '$';
};
astNodeToNames = function(astNode) {
if (Array.isArray(astNode)) {
return concatMap(astNode, astNodeToNames);
}
switch (astNode.tag) {
case 'wildcard':
return ['_'];
case 'named':
return [astNode.value];
case 'static':
return [];
case 'optional':
return astNodeToNames(astNode.value);
}
};
getParam = function(params, key, nextIndexes, sideEffects) {
var index, maxIndex, result, value;
if (sideEffects == null) {
sideEffects = false;
}
value = params[key];
if (value == null) {
if (sideEffects) {
throw new Error("no values provided for key `" + key + "`");
} else {
return;
}
}
index = nextIndexes[key] || 0;
maxIndex = Array.isArray(value) ? value.length - 1 : 0;
if (index > maxIndex) {
if (sideEffects) {
throw new Error("too few values provided for key `" + key + "`");
} else {
return;
}
}
result = Array.isArray(value) ? value[index] : value;
if (sideEffects) {
nextIndexes[key] = index + 1;
}
return result;
};
astNodeContainsSegmentsForProvidedParams = function(astNode, params, nextIndexes) {
var i, length;
if (Array.isArray(astNode)) {
i = -1;
length = astNode.length;
while (++i < length) {
if (astNodeContainsSegmentsForProvidedParams(astNode[i], params, nextIndexes)) {
return true;
}
}
return false;
}
switch (astNode.tag) {
case 'wildcard':
return getParam(params, '_', nextIndexes, false) != null;
case 'named':
return getParam(params, astNode.value, nextIndexes, false) != null;
case 'static':
return false;
case 'optional':
return astNodeContainsSegmentsForProvidedParams(astNode.value, params, nextIndexes);
}
};
stringify = function(astNode, params, nextIndexes) {
if (Array.isArray(astNode)) {
return stringConcatMap(astNode, function(node) {
return stringify(node, params, nextIndexes);
});
}
switch (astNode.tag) {
case 'wildcard':
return getParam(params, '_', nextIndexes, true);
case 'named':
return getParam(params, astNode.value, nextIndexes, true);
case 'static':
return astNode.value;
case 'optional':
if (astNodeContainsSegmentsForProvidedParams(astNode.value, params, nextIndexes)) {
return stringify(astNode.value, params, nextIndexes);
} else {
return '';
}
}
};
UrlPattern = function(arg1, arg2) {
var groupCount, options, parsed, parser, withoutWhitespace;
if (arg1 instanceof UrlPattern) {
this.isRegex = arg1.isRegex;
this.regex = arg1.regex;
this.ast = arg1.ast;
this.names = arg1.names;
return;
}
this.isRegex = arg1 instanceof RegExp;
if (!(('string' === typeof arg1) || this.isRegex)) {
throw new TypeError('argument must be a regex or a string');
}
if (this.isRegex) {
this.regex = arg1;
if (arg2 != null) {
if (!Array.isArray(arg2)) {
throw new Error('if first argument is a regex the second argument may be an array of group names but you provided something else');
}
groupCount = regexGroupCount(this.regex);
if (arg2.length !== groupCount) {
throw new Error("regex contains " + groupCount + " groups but array of group names contains " + arg2.length);
}
this.names = arg2;
}
return;
}
if (arg1 === '') {
throw new Error('argument must not be the empty string');
}
withoutWhitespace = arg1.replace(/\s+/g, '');
if (withoutWhitespace !== arg1) {
throw new Error('argument must not contain whitespace');
}
options = {
escapeChar: (arg2 != null ? arg2.escapeChar : void 0) || defaultOptions.escapeChar,
segmentNameStartChar: (arg2 != null ? arg2.segmentNameStartChar : void 0) || defaultOptions.segmentNameStartChar,
segmentNameCharset: (arg2 != null ? arg2.segmentNameCharset : void 0) || defaultOptions.segmentNameCharset,
segmentValueCharset: (arg2 != null ? arg2.segmentValueCharset : void 0) || defaultOptions.segmentValueCharset,
optionalSegmentStartChar: (arg2 != null ? arg2.optionalSegmentStartChar : void 0) || defaultOptions.optionalSegmentStartChar,
optionalSegmentEndChar: (arg2 != null ? arg2.optionalSegmentEndChar : void 0) || defaultOptions.optionalSegmentEndChar,
wildcardChar: (arg2 != null ? arg2.wildcardChar : void 0) || defaultOptions.wildcardChar
};
parser = newParser(options);
parsed = parser.pattern(arg1);
if (parsed == null) {
throw new Error("couldn't parse pattern");
}
if (parsed.rest !== '') {
throw new Error("could only partially parse pattern");
}
this.ast = parsed.value;
this.regex = new RegExp(astNodeToRegexString(this.ast, options.segmentValueCharset));
this.names = astNodeToNames(this.ast);
};
UrlPattern.prototype.match = function(url) {
var groups, match;
match = this.regex.exec(url);
if (match == null) {
return null;
}
groups = match.slice(1);
if (this.names) {
return keysAndValuesToObject(this.names, groups);
} else {
return groups;
}
};
UrlPattern.prototype.stringify = function(params) {
if (params == null) {
params = {};
}
if (this.isRegex) {
throw new Error("can't stringify patterns generated from a regex");
}
if (params !== Object(params)) {
throw new Error("argument must be an object or undefined");
}
return stringify(this.ast, params, {});
};
UrlPattern.escapeForRegex = escapeForRegex;
UrlPattern.concatMap = concatMap;
UrlPattern.stringConcatMap = stringConcatMap;
UrlPattern.regexGroupCount = regexGroupCount;
UrlPattern.keysAndValuesToObject = keysAndValuesToObject;
UrlPattern.P = P;
UrlPattern.newParser = newParser;
UrlPattern.defaultOptions = defaultOptions;
UrlPattern.astNodeToRegexString = astNodeToRegexString;
UrlPattern.astNodeToNames = astNodeToNames;
UrlPattern.getParam = getParam;
UrlPattern.astNodeContainsSegmentsForProvidedParams = astNodeContainsSegmentsForProvidedParams;
UrlPattern.stringify = stringify;
return UrlPattern;
});
});
var __LhtFsgSwWaN__$1 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$1 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$1 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$1 = 'DCr~q_PVvNYWpym', __ckPQmJx__$1 = 'kSt64xLRZJw';
/**
* 网络地址工具类
*/
var UrlTool = /** @class */ (function () {
function UrlTool() {
}
/**
* 合成URL完整地址
* @param baseUrl 基础地址
* @param subUrl 相对地址
* @param parameters 参数
* @returns 返回拼接后的地址
*/
UrlTool.urlFromPortion = function (baseUrl, subUrl, parameters) {
if (!parameters) {
parameters = {};
}
var params = [];
for (var key in parameters) {
if (!parameters.hasOwnProperty(key)) {
continue;
}
if (parameters[key] !== undefined) {
params.push(key + '=' + parameters[key]);
}
}
var iUrl = baseUrl + subUrl;
if (params.length > 0) {
iUrl = iUrl + '?' + params.join('&');
}
return iUrl;
};
/**
* 分析Url并解析为对象结构
* @param url 待分析Url
* @param options 分析Url配置
* @return 返回解析后的结果，url无效时返回Null
*/
UrlTool.portionFromUrl = function (url, options) {
options = __assign({ complete: false }, options);
try {
var urlObj = null;
try {
urlObj = new URL(url);
}
catch (e) {
return null;
}
if (urlObj) {
var _getKV = function (obj) {
var queryMap = {};
if (obj) {
for (var _i = 0, _a = obj.split('&'); _i < _a.length; _i++) {
var kv = _a[_i];
var kv_l = kv.split('=');
if (kv_l.length < 2)
continue;
queryMap[kv_l[0]] = kv_l[1];
}
}
return queryMap;
};
var query = new urlPattern(/^\??(.*)$/, ['query']).match(urlObj.search).query;
var queryMap = _getKV(query);
var hashObj = new urlPattern(/^#?(([\w-]*(\/)?)+)?((\?)+(.*))?$/, ['hashpath', '', '', 'hashsearch', '', '_hashsearch']).match(urlObj.hash);
var hashMap = _getKV(hashObj._hashsearch);
var p = {
host: urlObj.host,
href: urlObj.href,
pathname: urlObj.pathname,
protocol: urlObj.protocol,
query: queryMap,
hashpath: hashObj.hashpath,
hashquery: hashMap
};
if (options.complete) {
p = __assign(__assign({}, p), { origin: urlObj.origin, hostname: urlObj.hostname, port: urlObj.port, search: urlObj.search, username: urlObj.username, password: urlObj.password, hashsearch: hashObj.hashsearch, hash: urlObj.hash });
}
return p;
}
else {
return null;
}
}
catch (e) {
throw e;
}
};
return UrlTool;
}());
var __LhtFsgSwWaN__$2 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$2 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$2 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$2 = 'DCr~q_PVvNYWpym', __ckPQmJx__$2 = 'kSt64xLRZJw';
var DEFAULT_DELEGATE = {
globalParams: function () { },
globalHeaders: function () { },
globalBodyData: function () { },
requestInterceptor: function (config) {
// Do something before request is sent
console.log(config.method + " " + UrlTool.urlFromPortion(config.url, '', config.params));
return config;
},
requestInterceptorError: function (error) {
// Do something with request error
return Promise.reject(error);
},
responseInterceptor: function (response) {
// Do something with response data
return response;
},
responseInterceptorError: function (error) {
// Do something with response error
return Promise.reject(error);
},
responseDataInterceptor: function (data, response) {
return data;
},
responseErrorInterceptor: function (error, response) {
return error;
}
};
var __LhtFsgSwWaN__$3 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$3 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$3 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$3 = 'DCr~q_PVvNYWpym', __ckPQmJx__$3 = 'kSt64xLRZJw';
var CancelPromiseFactory = /** @class */ (function () {
function CancelPromiseFactory(args) {
return __assign(__assign({}, new Promise(args)), { terminate: function () { } });
}
CancelPromiseFactory.createJPromise = function (para) {
var promise = null;
if (typeof para == "function") {
promise = new Promise(para);
}
else {
promise = para;
}
var hasCanceled_ = false;
var wrappedPromise = new Promise(function (resolve, reject) {
promise.then(function (val) { return hasCanceled_
? function () {
}
: resolve(val); }, function () {
// 不写会有警告
});
promise.catch(function (error) { return hasCanceled_
? function () {
}
: reject(error); });
});
wrappedPromise.terminate = function () {
hasCanceled_ = true;
};
return wrappedPromise;
};
return CancelPromiseFactory;
}());
var __LhtFsgSwWaN__$4 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$4 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$4 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$4 = 'DCr~q_PVvNYWpym', __ckPQmJx__$4 = 'kSt64xLRZJw';
/**
* Created by cuppi on 2017/5/10.
*/
/**
* 对象工具类
*/
var ObjectTool = /** @class */ (function () {
function ObjectTool() {
}
/**
* 删除对象某个属性
* @param target 对象
* @param propertyKey 属性
* @returns 是否删除成功
*/
ObjectTool.deleteProperty = function (target, propertyKey) {
if (target) {
return Reflect.deleteProperty(target, propertyKey);
}
return true;
};
/**
* 安全的获取链式属性 eg: a.b.c.d
* @param target 目标对象
* @param pChain 对象链式属性
* @returns {*}
*/
ObjectTool.safeGet = function (target) {
var pChain = [];
for (var _i = 1; _i < arguments.length; _i++) {
pChain[_i - 1] = arguments[_i];
}
if (!target || !pChain || pChain.length <= 0) {
return undefined;
}
var property = target;
var chainIndex = 0;
do {
property = property[pChain[chainIndex++]];
} while (property && (chainIndex < pChain.length));
return chainIndex === pChain.length ? property : undefined;
};
ObjectTool.isEmptyObject = function (obj) {
return Object.keys(obj).length === 0 && obj.constructor === Object;
};
/**
* 如果未知参数是对象 f返回该对象 如果是方法 则返回方法该方法的运行结果
* @param obj 未知参数
* @param args 如果是方法，则为方法参数
*/
ObjectTool.getObjOrFuncResult = function (obj) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var o = null;
if (obj) {
if (typeof obj == "function") {
o = obj.apply(void 0, args);
}
if (typeof obj == "object") {
o = obj;
}
}
return o || {};
};
return ObjectTool;
}());
var __LhtFsgSwWaN__$5 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$5 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$5 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$5 = 'DCr~q_PVvNYWpym', __ckPQmJx__$5 = 'kSt64xLRZJw';
var REQUESTER_COUNT = 0;
var JRequester = /** @class */ (function () {
function JRequester(method, baseUrl, url, parameters, headers, bodyData, otherObject, delegate) {
this.method = method;
this.baseUrl = baseUrl;
this.url = url;
this.parameters = parameters;
this.headers = headers;
this.bodyData = bodyData;
this.otherObject = otherObject;
this.delegate = delegate;
this.requesterId = ++REQUESTER_COUNT;
}
/**
* 包裹可取消的请求 （使用fetch请求时使用，目前通过axios请求，无需使用）
* @private
* @param promise 异步请求块
* @returns {Promise} 被包裹后的异步请求块
*/
JRequester.wrapCancelablePromise = function (promise) {
return CancelPromiseFactory.createJPromise(promise);
};
/**
* 发送请求
* @param method 方法类型
* @param baseUrl 基地址
* @param url 相对地址
* @param parameters 参数
* @param bodyData data参数
* @param headers 头参数
* @param otherObject 其他相关设置
* @param delegate 网络请求代理
* @returns {CancelPromiseFactory<any>}
*/
JRequester.create = function (method, baseUrl, url, parameters, bodyData, headers, otherObject, delegate) {
var requester = new JRequester(method, baseUrl, url, parameters, headers, bodyData, otherObject, delegate);
if (ObjectTool.isEmptyObject(bodyData)) {
bodyData = null;
}
var axiosProps = __assign({ method: method, params: parameters, baseURL: baseUrl, data: bodyData, headers: headers }, otherObject);
/**
* 只传指定的属性 或 忽略某些属性
* 只传 a 参数 头参数正常
* specific: {
* params: ['a']
* }
* 参数 a 将被忽略
* ignore: {
* params: ['a']
* }
*/
if (otherObject.hasOwnProperty('specific') || otherObject.hasOwnProperty('ignore')) {
[{ k: 'params', ak: 'params' }, { k: 'headers', ak: 'headers' }, { k: 'bodyData', ak: 'data' }].forEach(function (_) {
var specV = otherObject.specific ? otherObject.specific[_.k] : null;
var ignoV = otherObject.ignore ? otherObject.ignore[_.k] : null;
var apl = Object.keys(axiosProps[_.ak]) || [];
specV && (axiosProps[_.ak] = apl
.filter(function (_) { return specV.some(function (__) { return _ === __; }); })
.map(function (k) { return ({ k: k, v: axiosProps[_.ak][k] }); })
.reduce(function (_, _a) {
var _b;
var k = _a.k, v = _a.v;
return (__assign(__assign({}, _), (_b = {}, _b[k] = v, _b)));
}, {}));
ignoV && (axiosProps[_.ak] = apl
.filter(function (_) { return ignoV.some(function (__) { return _ !== __; }); })
.map(function (k) { return ({ k: k, v: axiosProps[_.ak][k] }); })
.reduce(function (_, _a) {
var _b;
var k = _a.k, v = _a.v;
return (__assign(__assign({}, _), (_b = {}, _b[k] = v, _b)));
}, {}));
});
}
var jaxios = axios.create(axiosProps);
delegate = __assign(__assign({}, DEFAULT_DELEGATE), (delegate || {}));
requester.jaxios = jaxios;
jaxios.interceptors.request.use(function (config) {
config.params = __assign({}, parameters);
config.headers = __assign({}, headers);
return delegate.requestInterceptor(config);
}, function (error) {
return delegate.requestInterceptorError(error);
});
jaxios.interceptors.response.use(function (response) {
return delegate.responseInterceptor(response);
}, function (error) {
return delegate.responseInterceptorError(error);
});
return requester;
};
JRequester.prototype.request = function () {
var _this = this;
return CancelPromiseFactory.createJPromise(function (resolve, reject) {
_this.jaxios.request({ url: _this.url }).then(function (response) {
resolve(response);
}, function (error) {
reject(error);
});
});
};
JRequester.prototype.repeat = function () {
var _this = this;
return CancelPromiseFactory.createJPromise(function (resolve, reject) {
_this.jaxios.request({ url: _this.url }).then(function (response) {
resolve(response);
}, function (error) {
reject(error);
});
});
};
return JRequester;
}());
var __LhtFsgSwWaN__$6 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$6 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$6 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$6 = 'DCr~q_PVvNYWpym', __ckPQmJx__$6 = 'kSt64xLRZJw';
var DEFAULT_CONFIG = {
baseUrl: '',
delegate: DEFAULT_DELEGATE,
carryParams: {},
carryHeaders: {},
carryBodyData: {},
axiosConfig: {
timeout: 10 * 1000
},
otherContent: null
};
var __LhtFsgSwWaN__$7 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$7 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$7 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$7 = 'DCr~q_PVvNYWpym', __ckPQmJx__$7 = 'kSt64xLRZJw';
/**
* @private
*/
var Jparam = /** @class */ (function () {
function Jparam() {
var params = [];
for (var _i = 0; _i < arguments.length; _i++) {
params[_i] = arguments[_i];
}
this._params = [];
for (var _a = 0, params_1 = params; _a < params_1.length; _a++) {
var para = params_1[_a];
this._params.push(para);
}
this.isJpara = true;
}
Jparam.prototype.items = function () {
return this._params;
};
Jparam.emptyPara = function () {
return new Jparam();
};
return Jparam;
}());
/**
* 辅助任务类
* @private
*/
var Jtask = /** @class */ (function () {
function Jtask(task, paramsPicker, resolve, reject) {
this._task = task;
this._resolve = resolve;
this._reject = reject;
this._paramsPicker = paramsPicker;
}
Jtask.prototype.setNextTask = function (task) {
this._nextTask = task;
};
Jtask.prototype.do = function (params) {
var _this = this;
params = params ? params : this._paramsPicker();
this._task.apply(this, this.paraItems(params)).then(function (data) {
var nextPara = _this._resolve.apply(_this, __spreadArrays([data], _this.paraItems(params)));
if (_this._nextTask) {
_this._nextTask.do(nextPara);
}
}, function (error) {
if (_this._reject) {
_this._reject.apply(_this, __spreadArrays([error], _this.paraItems(params)));
}
else {
console.log('ERROR: Don\'t find the error handler for task (' + _this._task.name + ')');
}
});
};
Jtask.prototype.paraItems = function (nextPara) {
if (nextPara && nextPara.isJpara) {
return nextPara.items();
}
return Jparam.emptyPara().items();
};
return Jtask;
}());
/**
*
* 任务连接类
* @private
*/
var Jlink = /** @class */ (function () {
function Jlink() {
var tasks = [];
for (var _i = 0; _i < arguments.length; _i++) {
tasks[_i] = arguments[_i];
}
this._tasks = [];
for (var _a = 0, tasks_1 = tasks; _a < tasks_1.length; _a++) {
var task = tasks_1[_a];
this._tasks.push(task);
}
this._taskIndex = 0;
}
Jlink.prototype.para = function (para) {
this._headTaskPara = para;
return this;
};
Jlink.prototype.params = function () {
var params = [];
for (var _i = 0; _i < arguments.length; _i++) {
params[_i] = arguments[_i];
}
this._allTaskPara = params;
return this;
};
Jlink.prototype.next = function (resolve, reject) {
if (this._taskIndex >= this._tasks.length) {
return this;
}
var nextTask = new Jtask(this._tasks[this._taskIndex], this._paramsPicker(this._taskIndex), resolve, reject);
this._taskIndex++;
if (this._nextTask) {
this._nextTask.setNextTask(nextTask);
}
else {
this._headTask = nextTask;
}
this._nextTask = nextTask;
return this;
};
Jlink.prototype.run = function () {
this._headTask.do(this._paramsPicker(0)());
return this;
};
/**
* 指定任务的params的获取者 (目前实现会浪费内存，多个相同函数推入函数栈，后期优化）
* @returns {Array}
* @private
*/
Jlink.prototype._paramsPicker = function (index) {
var _this = this;
return function () {
if (_this._allTaskPara && _this._allTaskPara.length > index) {
return _this._allTaskPara[index];
}
if (index === 0 && _this._headTaskPara) {
return _this._headTaskPara;
}
return Jparam.emptyPara();
};
};
return Jlink;
}());
// let pro1 = () => {
// return new Promise()
// };
//
// let pro2 = () => {
// return new Promise
// };
// let l = jlink(pro1, pro2).next(
// (data) => {
// console.log(data);
// },
// error => {
// console.log(error);
// }).next(
// (data) => {
// console.log(data);
// },
// error => {
// console.log(error);
// }
// ).run();
/**
* 任务组合类
* @private
*/
// class Jcombine {
// _tasks: Function[];
// _headTaskPara: object;
// _taskIndex: number;
// _paramsPicker: Function;
// _headTask: Jtask;
//
// constructor(...tasks) {
// this._tasks = [];
// for (var task of tasks) {
// this._tasks.push(task);
// }
// this._taskIndex = 0;
// }
//
// para(para) {
// this._headTaskPara = para;
// return this;
// }
//
// params(...params) {
// this._allTaskPara = params;
// return this;
// }
//
// next(resolve, reject) {
// if (this._taskIndex >= this._tasks.length) {
// return this;
// }
// let nextTask = new Jtask(this._tasks[this._taskIndex], this._paramsPicker(this._taskIndex), resolve, reject);
// this._taskIndex++;
// if (this._nextTask) {
// this._nextTask.setNextTask(nextTask);
// } else {
// this._headTask = nextTask;
// }
// this._nextTask = nextTask;
// return this;
// }
//
// run() {
// this._headTask.do(this._paramsPicker(0)());
// return this;
// }
// }
/**
* 任务连接类
* @alias other/jlink
* @param tasks
* @returns {Jlink}
*/
function jlink() {
var tasks = [];
for (var _i = 0; _i < arguments.length; _i++) {
tasks[_i] = arguments[_i];
}
return new (Jlink.bind.apply(Jlink, __spreadArrays([void 0], tasks)))();
}
/**
* @private
* @param params
* @returns {Jpara}
*/
function jparam() {
var params = [];
for (var _i = 0; _i < arguments.length; _i++) {
params[_i] = arguments[_i];
}
return new (Jparam.bind.apply(Jparam, __spreadArrays([void 0], params)))();
}
/**
* @alias other/jcombine
* @param tasks
* @returns {Jcombine}
*/
// function jcombine(...tasks) {
// return new Jcombine(...tasks);
// }
/**
*
* @param {GlobalValueRegistry | ((delegate: INetworkDelegate) => GlobalValueRegistry)} x
* @return {x is (delegate: INetworkDelegate) => GlobalValueRegistry}
*/
function isGlobalValueRegistry(x) {
return typeof x === 'function';
}
function isGlobalValueRegistryObject(x) {
return typeof x === 'object';
}
function isGlobalValueRegistryFunction(x) {
return typeof x === 'function';
}
/**
* 获取全局指定参数
* @param extraValues 全局参数列表
* @param delegate 全局代理
* @param globalValueRegistryPicker 全局参数代理对象
* @return {{}}
*/
function jgetGlobalValue(extraValues, delegate, globalValueRegistryPicker) {
var jgetGlobalValueWithKey = function (key) {
var otherValues = {};
if (!globalValueRegistryPicker) {
throw new Error('未找到全局参数，请确认是否设置global代理');
}
var globalValueRegistry;
if (isGlobalValueRegistry(globalValueRegistryPicker)) {
globalValueRegistry = globalValueRegistryPicker(delegate);
}
else {
globalValueRegistry = globalValueRegistryPicker;
}
var globalParaFunc = null;
if (isGlobalValueRegistryObject(globalValueRegistry)) {
globalParaFunc = globalValueRegistry[key];
}
if (isGlobalValueRegistryFunction(globalValueRegistry)) {
globalParaFunc = globalValueRegistry()[key];
}
if (globalParaFunc !== null) {
var globalPara = null;
if (typeof globalParaFunc == "function") {
globalPara = globalParaFunc();
}
else {
globalPara = globalParaFunc;
}
if (typeof globalPara == "object") {
otherValues = __assign(__assign({}, otherValues), globalPara);
}
else if (typeof globalPara === 'string' || typeof globalPara === 'number') {
otherValues[key] = globalPara;
}
else {
throw new Error("\u5168\u5C40\u53D8\u91CF\u7C7B\u578B\u4E0D\u6B63\u786E:" + key);
}
}
else {
throw new Error("\u4E0D\u5B58\u5728\u7684\u5168\u5C40\u53D8\u91CF:" + key);
}
return otherValues;
};
var globalOtherValues = {};
extraValues.forEach(function (key) {
if (typeof key == "object") {
globalOtherValues = __assign(__assign({}, globalOtherValues), key);
}
else {
if (!delegate)
return;
globalOtherValues = __assign(__assign({}, globalOtherValues), jgetGlobalValueWithKey(key));
}
});
return globalOtherValues;
}
var __LhtFsgSwWaN__$8 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$8 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$8 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$8 = 'DCr~q_PVvNYWpym', __ckPQmJx__$8 = 'kSt64xLRZJw';
var JNetworkError = /** @class */ (function (_super) {
__extends(JNetworkError, _super);
function JNetworkError(errorMessage, code) {
var _this = this;
if (typeof errorMessage === 'string') {
_this = _super.call(this, errorMessage) || this;
}
else if (errorMessage instanceof Error) {
_this = _super.call(this, errorMessage.message) || this;
}
else {
throw new Error('JNetworkError: 构造函数非法类型');
}
_this.errorCode = code;
return _this;
// Reflect.defineProperty(this, 'errorCode', {value: code});
}
return JNetworkError;
}(Error));
var __LhtFsgSwWaN__$9 = 'UnflQ!21.IEs7hF', __KrifbHpGqvR__$9 = '-50Gu+jdAg9ObeK', __OUYADeXlzEM__$9 = ' oHT8zX*i#3BMac', __VIynuBdCjTo__$9 = 'DCr~q_PVvNYWpym', __ckPQmJx__$9 = 'kSt64xLRZJw';
// import {AxiosResponse} from "axios";
// import JNetworkError from "../network/JNetworkError";
// import {listeners} from "cluster";
var Event = /** @class */ (function () {
function Event(name) {
this.name = name;
this.callbacks = [];
}
Event.prototype.registerCallback = function (callback) {
this.callbacks.push(callback);
};
Event.prototype.removeCallback = function (callback) {
this.callbacks = this.callbacks.filter(function (c) {
return c !== callback;
});
};
return Event;
}());
var Reactor = /** @class */ (function () {
function Reactor() {
this.events = {};
}
Reactor.prototype.registerEvent = function (eventName) {
this.events[eventName] = new Event(eventName);
};
Reactor.prototype.dispatchEvent = function (eventName, eventArgs) {
this.events[eventName].callbacks.forEach(function (callback) {
callback(eventArgs);
});
};
Reactor.prototype.addEventListener = function (eventName, callback) {
this.events[eventName].registerCallback(callback);
};
Reactor.prototype.removeEventListener = function (eventName, callback) {
this.events[eventName].removeCallback(callback);
};
return Reactor;
}());
var JRequestEngine = /** @class */ (function () {
// private readonly reactor;
function JRequestEngine() {
this.isRunning = false;
this.runQueue = [];
// let reactor = new Reactor();
// this.reactor = reactor;
// reactor.registerEvent('requestCanLoad');
}
JRequestEngine.prototype._pushRunQueue = function (request, resolve, reject) {
this.runQueue.push({
request: request,
resolve: resolve,
reject: reject
});
};
JRequestEngine.prototype._popRunQueue = function () {
return this.runQueue.shift();
};
JRequestEngine.prototype.addRequest = function (request) {
var _this = this;
return CancelPromiseFactory.createJPromise(function (resolve, reject) {
if (!_this.isRunning) {
_this.isRunning = true;
_this.do(request, resolve, reject);
}
else {
_this._pushRunQueue(request, resolve, reject);
}
});
};
JRequestEngine.prototype.do = function (request, resolve, reject) {
var _this = this;
request.request().then(function (data) {
setTimeout(resolve(data), 0);
var task = _this._popRunQueue();
if (task) {
_this.do(task.request, task.resolve, task.reject);
}
else {
_this.isRunning = false;
}
}, function (error) {
reject(error);
});
};
return JRequestEngine;
}())