tools-min-ns 1.5.2

package/lib/request/uniRquest/index.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+var index_1 = __importDefault(require("./web/index"));
+var index_2 = __importDefault(require("./weex/index"));
+var index_3 = __importDefault(require("./miniapp/index"));
+var index_4 = __importDefault(require("./wechat-miniprogram/index"));
+var index_5 = __importDefault(require("./miniapp-bytedance/index"));
+var EnvUtil_1 = __importDefault(require("../../env/EnvUtil"));
+var isWeex = EnvUtil_1.default.isWeex,
+  isMiniApp = EnvUtil_1.default.isMiniApp,
+  isWeChatMiniProgram = EnvUtil_1.default.isWeChatMiniProgram,
+  isWeb = EnvUtil_1.default.isWeb,
+  isByteDanceMicroApp = EnvUtil_1.default.isByteDanceMicroApp;
+function dutyChain() {
+  var fns = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    fns[_i] = arguments[_i];
+  }
+  for (var i = 0; i < fns.length; i++) {
+    var result = fns[i]();
+    if (result) {
+      return result;
+    }
+  }
+}
+function handleWeb(afterOptions) {
+  if (isWeb) {
+    var request = index_1.default;
+    return request(afterOptions);
+  }
+  return null;
+}
+function handleMiniApp(afterOptions) {
+  if (isMiniApp) {
+    var request = index_3.default;
+    return request(afterOptions);
+  }
+  return null;
+}
+function handleWeex(afterOptions) {
+  if (isWeex) {
+    var request = index_2.default;
+    return request(afterOptions);
+  }
+  return null;
+}
+function handleWeChatMiniprogram(afterOptions) {
+  if (isWeChatMiniProgram) {
+    var request = index_4.default;
+    return request(afterOptions);
+  }
+  return null;
+}
+function handleBytedanceMiniprogram(afterOptions) {
+  if (isByteDanceMicroApp) {
+    var request = index_5.default;
+    return request(afterOptions);
+  }
+}
+function default_1(options) {
+  var afterOptions = Object.assign({}, types_1.DEFAULT_REQUEST_OPTIONS, options, {
+    method: (options.method || 'GET').toUpperCase()
+  });
+  options.headers = (0, utils_1.normalizeHeaders)(options.headers || {});
+  return dutyChain(handleWeex.bind(null, afterOptions), handleWeb.bind(null, afterOptions), handleMiniApp.bind(null, afterOptions), handleBytedanceMiniprogram.bind(null, afterOptions), handleWeChatMiniprogram.bind(null, afterOptions));
+}
+exports.default = default_1;

package/lib/request/uniRquest/miniapp/index.d.ts

@@ -0,0 +1,2 @@
+import { RequestOptions, ResponseData } from '../types';
+export default function (options: RequestOptions): Promise<ResponseData>;

package/lib/request/uniRquest/miniapp/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+function default_1(options) {
+  return new Promise(function (resolve, reject) {
+    var url = options.url,
+      method = options.method,
+      data = options.data,
+      dataType = options.dataType,
+      headers = options.headers,
+      timeout = options.timeout;
+    my.request({
+      url: url,
+      headers: headers,
+      method: method,
+      data: data,
+      timeout: timeout,
+      dataType: dataType,
+      success: function success(res) {
+        resolve(res);
+      },
+      fail: function fail(res) {
+        reject({
+          code: types_1.ERROR_REQUEST_ABORT.code,
+          message: (0, utils_1.object2json)(res)
+        });
+      }
+    });
+  });
+}
+exports.default = default_1;

package/lib/request/uniRquest/miniapp-bytedance/index.d.ts

@@ -0,0 +1,2 @@
+import { RequestOptions, ResponseData } from '../types';
+export default function (options: RequestOptions): Promise<ResponseData>;

package/lib/request/uniRquest/miniapp-bytedance/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+function default_1(options) {
+  return new Promise(function (resolve, reject) {
+    var url = options.url,
+      method = options.method,
+      data = options.data,
+      dataType = options.dataType,
+      headers = options.headers,
+      timeout = options.timeout;
+    var timeoutTimer;
+    var requestTask = tt.request({
+      url: url,
+      headers: headers,
+      method: method,
+      data: data,
+      timeout: timeout,
+      dataType: dataType,
+      success: function success(res) {
+        resolve(res);
+      },
+      fail: function fail(res) {
+        reject({
+          code: types_1.ERROR_REQUEST_ABORT.code,
+          message: (0, utils_1.object2json)(res)
+        });
+      },
+      complete: function complete() {
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+        }
+      }
+    });
+    if (timeout) {
+      timeoutTimer = setTimeout(function () {
+        requestTask.abort();
+        reject(types_1.ERROR_REQUEST_TIMEOUT);
+      }, timeout);
+    }
+  });
+}
+exports.default = default_1;

package/lib/request/uniRquest/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ *  Common
+ */
+export declare enum DATA_TYPE {
+    json = "json",
+    text = "text"
+}
+export declare const DEFAULT_TIMEOUT = 20000;
+export declare const DEFAULT_JSON_CALLBACK = "callback";
+export declare const DEFAULT_JSONP_OPTIONS: {
+    timeout: number;
+    jsonpCallback: string;
+    dataType: DATA_TYPE;
+};
+export interface AsObject {
+    [key: string]: string | number;
+}
+/**
+ * Request
+ */
+export interface JsonpOptions {
+    url: string;
+    timeout?: number;
+    dataType?: DATA_TYPE;
+    jsonpCallback?: string;
+    jsonpCallbackFunctionName?: string;
+}
+export interface RequestOptions {
+    url: string;
+    headers?: AsObject;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
+    data?: AsObject;
+    timeout?: number;
+    dataType?: DATA_TYPE;
+}
+export interface InnerRequestOptions extends RequestOptions {
+    headers: AsObject;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
+    data: AsObject;
+    timeout: number;
+    dataType: DATA_TYPE;
+}
+export declare const DEFAULT_REQUEST_OPTIONS: RequestOptions;
+/**
+ * Response
+ */
+export interface ResponseData {
+    data: string | object;
+    headers?: AsObject;
+    status?: number;
+}
+export interface ResponseError extends ErrorData {
+    code: number;
+    message: string;
+}
+/**
+ * Error
+ */
+export interface ErrorData {
+    code: number;
+    message?: string;
+}
+export declare const ERROR_REQUEST_ABORT: ErrorData;
+export declare const ERROR_REQUEST_TIMEOUT: ErrorData;
+export declare const ERROR_REQUEST_NOT_SUPPORT: ErrorData;

package/lib/request/uniRquest/types.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ERROR_REQUEST_NOT_SUPPORT = exports.ERROR_REQUEST_TIMEOUT = exports.ERROR_REQUEST_ABORT = exports.DEFAULT_REQUEST_OPTIONS = exports.DEFAULT_JSONP_OPTIONS = exports.DEFAULT_JSON_CALLBACK = exports.DEFAULT_TIMEOUT = exports.DATA_TYPE = void 0;
+/**
+ *  Common
+ */
+var DATA_TYPE;
+(function (DATA_TYPE) {
+  DATA_TYPE["json"] = "json";
+  DATA_TYPE["text"] = "text";
+})(DATA_TYPE = exports.DATA_TYPE || (exports.DATA_TYPE = {}));
+exports.DEFAULT_TIMEOUT = 20000;
+exports.DEFAULT_JSON_CALLBACK = 'callback';
+exports.DEFAULT_JSONP_OPTIONS = {
+  timeout: exports.DEFAULT_TIMEOUT,
+  jsonpCallback: exports.DEFAULT_JSON_CALLBACK,
+  dataType: DATA_TYPE.json
+};
+exports.DEFAULT_REQUEST_OPTIONS = {
+  url: '',
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  method: 'GET',
+  timeout: exports.DEFAULT_TIMEOUT,
+  dataType: DATA_TYPE.json
+};
+exports.ERROR_REQUEST_ABORT = {
+  code: 0,
+  message: 'Request Abort'
+};
+exports.ERROR_REQUEST_TIMEOUT = {
+  code: 1,
+  message: 'Request timeout'
+};
+exports.ERROR_REQUEST_NOT_SUPPORT = {
+  code: 2,
+  message: 'Request not support this platform'
+};

package/lib/request/uniRquest/utils.d.ts

@@ -0,0 +1,9 @@
+import { DATA_TYPE, AsObject } from './types';
+export declare function getDataWithType(data: any, type: DATA_TYPE): any;
+export declare function stringifyQS(qs: AsObject): string;
+export declare function applyParamToURL(param: AsObject | void, url: string): string;
+export declare function object2json(obj: any): any;
+export declare function isObject(obj: any): boolean;
+export declare function normalizeHeaders(obj: AsObject): AsObject;
+export declare function checkIsApplyDataToURL(headers: AsObject | undefined): boolean;
+export declare function isPlainObject(obj: any): boolean;

package/lib/request/uniRquest/utils.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPlainObject = exports.checkIsApplyDataToURL = exports.normalizeHeaders = exports.isObject = exports.object2json = exports.applyParamToURL = exports.stringifyQS = exports.getDataWithType = void 0;
+var types_1 = require("./types");
+function getDataWithType(data, type) {
+  if (type === types_1.DATA_TYPE.json) {
+    try {
+      return JSON.parse(data);
+    } catch (e) {}
+  }
+  if (type === types_1.DATA_TYPE.text) {
+    try {
+      return JSON.stringify(data);
+    } catch (e) {}
+  }
+  return data;
+}
+exports.getDataWithType = getDataWithType;
+function stringifyQS(qs) {
+  if (!qs) {
+    return '';
+  }
+  var str = [];
+  for (var key in qs) {
+    if (qs[key] !== undefined && qs[key] !== null) {
+      str.push("".concat(key, "=").concat(encodeURIComponent(String(qs[key]))));
+    }
+  }
+  return str.join('&');
+}
+exports.stringifyQS = stringifyQS;
+function applyParamToURL(param, url) {
+  if (!param) {
+    return url;
+  }
+  return "".concat(url).concat(url.indexOf('?') === -1 ? '?' : '&').concat(stringifyQS(param));
+}
+exports.applyParamToURL = applyParamToURL;
+function object2json(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch (e) {
+    return obj || '';
+  }
+}
+exports.object2json = object2json;
+function isObject(obj) {
+  return typeof obj === 'object' && obj !== null;
+}
+exports.isObject = isObject;
+function normalizeHeaders(obj) {
+  if (!isObject(obj)) {
+    return obj;
+  }
+  var keyList = ['Accept', 'Content-Type'];
+  keyList.forEach(function (key) {
+    Object.keys(obj).some(function (headerKey) {
+      if (headerKey.toUpperCase() === key.toUpperCase() && headerKey !== key) {
+        obj[key] = obj[headerKey];
+        delete obj[headerKey];
+        return true;
+      }
+      return false;
+    });
+  });
+  return obj;
+}
+exports.normalizeHeaders = normalizeHeaders;
+function checkIsApplyDataToURL(headers) {
+  if (!headers || !headers['Content-Type']) {
+    return false;
+  }
+  return String(headers['Content-Type']).toLowerCase().indexOf('application/x-www-form-urlencoded') > -1;
+}
+exports.checkIsApplyDataToURL = checkIsApplyDataToURL;
+var EMPTY_OBJECT = {};
+function isPlainObject(obj) {
+  return EMPTY_OBJECT.toString.call(obj) === '[object Object]';
+}
+exports.isPlainObject = isPlainObject;

package/lib/request/uniRquest/web/index.d.ts

@@ -0,0 +1,2 @@
+import { InnerRequestOptions, ResponseData } from '../types';
+export default function requestXHR(options: InnerRequestOptions): Promise<ResponseData>;

package/lib/request/uniRquest/web/index.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+function requestXHR(options) {
+  options.headers = Object.assign({
+    'Accept': 'application/json, text/plain, */*'
+  }, options.headers);
+  var _a = Object.assign({
+      withCredentials: true,
+      method: 'GET',
+      validateStatus: function validateStatus(status) {
+        return status >= 200 && status < 300 || status === 304;
+      }
+    }, options),
+    validateStatus = _a.validateStatus,
+    url = _a.url,
+    method = _a.method,
+    withCredentials = _a.withCredentials,
+    headers = _a.headers,
+    data = _a.data,
+    timeout = _a.timeout,
+    dataType = _a.dataType;
+  return new Promise(function (resolve, reject) {
+    var timer;
+    var requestData;
+    var xhr = new XMLHttpRequest();
+    var clean = function clean() {
+      clearTimeout(timer);
+    };
+    timer = window.setTimeout(function () {
+      clean();
+      reject(types_1.ERROR_REQUEST_TIMEOUT);
+      xhr.abort();
+    }, timeout);
+    xhr.onreadystatechange = function () {
+      if (!xhr || xhr.readyState !== 4) {
+        return;
+      }
+      clean();
+      if (!validateStatus(xhr.status)) {
+        // TODO Detailed error message
+        return reject({
+          code: types_1.ERROR_REQUEST_ABORT.code,
+          message: "".concat(JSON.stringify({
+            status: xhr.status
+          }))
+        });
+      }
+      var headers = xhr.getAllResponseHeaders();
+      var arr = headers.trim().split(/[\r\n]+/);
+      var headerMap = {};
+      arr.forEach(function (line) {
+        var parts = line.split(': ');
+        var header = parts.shift();
+        var value = parts.join(': ');
+        headerMap[header] = value;
+      });
+      resolve({
+        data: xhr.response,
+        status: xhr.status,
+        headers: headerMap
+      });
+    };
+    xhr.responseType = dataType || '';
+    if (method === 'GET' || (0, utils_1.checkIsApplyDataToURL)(headers)) {
+      xhr.open(method, (0, utils_1.applyParamToURL)(data, url), true);
+    } else {
+      xhr.open(method, url, true);
+    }
+    xhr.withCredentials = withCredentials;
+    if (headers) {
+      Object.keys(headers || []).forEach(function (key) {
+        xhr.setRequestHeader(key, String(headers[key]));
+      });
+    }
+    if (method === 'GET') {
+      requestData = null;
+    } else {
+      requestData = data;
+    }
+    if ((0, utils_1.isObject)(requestData) && (0, utils_1.isPlainObject)(requestData)) {
+      requestData = (0, utils_1.object2json)(requestData);
+    }
+    xhr.send(requestData);
+  });
+}
+exports.default = requestXHR;

package/lib/request/uniRquest/wechat-miniprogram/index.d.ts

@@ -0,0 +1,2 @@
+import { RequestOptions, ResponseData } from '../types';
+export default function (options: RequestOptions): Promise<ResponseData>;

package/lib/request/uniRquest/wechat-miniprogram/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+function default_1(options) {
+  return new Promise(function (resolve, reject) {
+    var url = options.url,
+      method = options.method,
+      data = options.data,
+      dataType = options.dataType,
+      headers = options.headers,
+      timeout = options.timeout;
+    var timeoutTimer;
+    var requestTask = wx.request({
+      url: url,
+      header: headers,
+      method: method,
+      data: data,
+      timeout: timeout,
+      dataType: dataType,
+      success: function success(res) {
+        resolve(res);
+      },
+      fail: function fail(res) {
+        reject({
+          code: types_1.ERROR_REQUEST_ABORT.code,
+          message: (0, utils_1.object2json)(res)
+        });
+      },
+      complete: function complete() {
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+        }
+      }
+    });
+    if (timeout) {
+      timeoutTimer = setTimeout(function () {
+        requestTask.abort();
+        reject(types_1.ERROR_REQUEST_TIMEOUT);
+      }, timeout);
+    }
+  });
+}
+exports.default = default_1;

package/lib/request/uniRquest/weex/index.d.ts

@@ -0,0 +1,14 @@
+import { RequestOptions, AsObject, ResponseData } from '../types';
+export interface WeexRequestOptions extends RequestOptions {
+    body?: string;
+    type?: 'json' | 'text' | 'jsonp';
+    isJSONP?: boolean;
+}
+export interface WeexResponse {
+    status: number;
+    ok: boolean;
+    statusText: string;
+    data: string;
+    headers: AsObject;
+}
+export default function weexRequest(options: WeexRequestOptions): Promise<ResponseData>;

package/lib/request/uniRquest/weex/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+function weexRequest(options) {
+  var Stream = __weex_require__('@weex-module/stream');
+  return new Promise(function (resolve, reject) {
+    var requestOptions = Object.assign({}, options);
+    var url = requestOptions.url,
+      method = requestOptions.method,
+      data = requestOptions.data,
+      dataType = requestOptions.dataType,
+      headers = requestOptions.headers;
+    if (method === 'GET' && data || (0, utils_1.checkIsApplyDataToURL)(headers)) {
+      requestOptions.url = (0, utils_1.applyParamToURL)(data, url);
+    } else if (data) {
+      requestOptions.body = (0, utils_1.object2json)(data);
+    }
+    if (requestOptions.isJSONP) {
+      requestOptions.type = 'jsonp';
+      delete requestOptions.isJSONP;
+    } else if (dataType === types_1.DATA_TYPE.json) {
+      requestOptions.type = 'json';
+    } else {
+      requestOptions.type = 'text';
+    }
+    Stream.fetch(requestOptions, function (response) {
+      try {
+        if (typeof response === 'string') {
+          // parse the response（it is string in weex-android & obj in ios）
+          response = JSON.parse(response);
+          if (response.data && typeof response.data === 'string' && response.ok) {
+            try {
+              response.data = JSON.parse(response.data);
+            } catch (e) {
+              throw new Error('the response.data in not valid json');
+            }
+          }
+        }
+        if (response.ok !== true) {
+          throw response;
+        }
+        resolve({
+          headers: response.headers,
+          status: response.status,
+          data: response.data
+        });
+      } catch (error) {
+        reject({
+          code: types_1.ERROR_REQUEST_ABORT.code,
+          message: (0, utils_1.object2json)(error)
+        });
+      }
+    }, function (progress) {
+      if (progress.status === 'FAILED') reject({
+        code: types_1.ERROR_REQUEST_ABORT.code,
+        message: (0, utils_1.object2json)(progress)
+      });
+    });
+  });
+}
+exports.default = weexRequest;

package/lib/storage/StorageUtil.d.ts

@@ -0,0 +1,19 @@
+import { SessionOpts } from "../types";
+declare namespace StorageUtil {
+    function setItem<T>(name: string, data: T, opts?: SessionOpts): void;
+    function getItem<T>(name: string, opts?: SessionOpts): T;
+    function removeItem(name: string, opts?: SessionOpts): void;
+    function clear(opts?: SessionOpts): void;
+    function clearTitle(opts?: SessionOpts): void;
+    /**
+     * 设置全局缓存前缀
+     * @param str 缓存前缀
+     */
+    const setGlobalTitle: (str: string) => void;
+    /**
+     * 设置全局缓存类型
+     * @param type  "session" | "local"
+     */
+    const setGlobalCacheType: (type: SessionOpts["type"]) => void;
+}
+export default StorageUtil;