tools-min-ns 1.5.2

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

@@ -0,0 +1,29 @@
+import { ERROR_REQUEST_ABORT } from '../types';
+import { object2json } from '../utils';
+export default function (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: ERROR_REQUEST_ABORT.code,
+          message: object2json(res)
+        });
+      }
+    });
+  });
+}

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

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

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

@@ -0,0 +1,41 @@
+import { ERROR_REQUEST_TIMEOUT, ERROR_REQUEST_ABORT } from '../types';
+import { object2json } from '../utils';
+export default function (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: ERROR_REQUEST_ABORT.code,
+          message: object2json(res)
+        });
+      },
+      complete: function complete() {
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+        }
+      }
+    });
+    if (timeout) {
+      timeoutTimer = setTimeout(function () {
+        requestTask.abort();
+        reject(ERROR_REQUEST_TIMEOUT);
+      }, timeout);
+    }
+  });
+}

package/esm/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/esm/request/uniRquest/types.js

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

package/esm/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/esm/request/uniRquest/utils.js

@@ -0,0 +1,69 @@
+import { DATA_TYPE } from './types';
+export function getDataWithType(data, type) {
+  if (type === DATA_TYPE.json) {
+    try {
+      return JSON.parse(data);
+    } catch (e) {}
+  }
+  if (type === DATA_TYPE.text) {
+    try {
+      return JSON.stringify(data);
+    } catch (e) {}
+  }
+  return data;
+}
+export 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('&');
+}
+export function applyParamToURL(param, url) {
+  if (!param) {
+    return url;
+  }
+  return "".concat(url).concat(url.indexOf('?') === -1 ? '?' : '&').concat(stringifyQS(param));
+}
+export function object2json(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch (e) {
+    return obj || '';
+  }
+}
+export function isObject(obj) {
+  return typeof obj === 'object' && obj !== null;
+}
+export 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;
+}
+export function checkIsApplyDataToURL(headers) {
+  if (!headers || !headers['Content-Type']) {
+    return false;
+  }
+  return String(headers['Content-Type']).toLowerCase().indexOf('application/x-www-form-urlencoded') > -1;
+}
+var EMPTY_OBJECT = {};
+export function isPlainObject(obj) {
+  return EMPTY_OBJECT.toString.call(obj) === '[object Object]';
+}

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

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

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

@@ -0,0 +1,85 @@
+import { ERROR_REQUEST_TIMEOUT, ERROR_REQUEST_ABORT } from '../types';
+import { applyParamToURL, object2json, checkIsApplyDataToURL, isObject, isPlainObject } from '../utils';
+export default 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(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: 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' || checkIsApplyDataToURL(headers)) {
+      xhr.open(method, 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 (isObject(requestData) && isPlainObject(requestData)) {
+      requestData = object2json(requestData);
+    }
+    xhr.send(requestData);
+  });
+}

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

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

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

@@ -0,0 +1,41 @@
+import { ERROR_REQUEST_ABORT, ERROR_REQUEST_TIMEOUT } from '../types';
+import { object2json } from '../utils';
+export default function (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: ERROR_REQUEST_ABORT.code,
+          message: object2json(res)
+        });
+      },
+      complete: function complete() {
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+        }
+      }
+    });
+    if (timeout) {
+      timeoutTimer = setTimeout(function () {
+        requestTask.abort();
+        reject(ERROR_REQUEST_TIMEOUT);
+      }, timeout);
+    }
+  });
+}

package/esm/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/esm/request/uniRquest/weex/index.js

@@ -0,0 +1,59 @@
+import { DATA_TYPE, ERROR_REQUEST_ABORT } from '../types';
+import { applyParamToURL, object2json, checkIsApplyDataToURL } from '../utils';
+export default 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 || checkIsApplyDataToURL(headers)) {
+      requestOptions.url = applyParamToURL(data, url);
+    } else if (data) {
+      requestOptions.body = object2json(data);
+    }
+    if (requestOptions.isJSONP) {
+      requestOptions.type = 'jsonp';
+      delete requestOptions.isJSONP;
+    } else if (dataType === 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: ERROR_REQUEST_ABORT.code,
+          message: object2json(error)
+        });
+      }
+    }, function (progress) {
+      if (progress.status === 'FAILED') reject({
+        code: ERROR_REQUEST_ABORT.code,
+        message: object2json(progress)
+      });
+    });
+  });
+}

package/esm/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;

package/esm/storage/StorageUtil.js

@@ -0,0 +1,75 @@
+var __read = this && this.__read || function (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;
+};
+import config from "../config";
+var StorageUtil;
+(function (StorageUtil) {
+  function setItem(name, data, opts) {
+    var cacheType = (opts === null || opts === void 0 ? void 0 : opts.type) || config.cacheType;
+    if (name && data !== undefined) window["".concat(cacheType, "Storage")].setItem((opts === null || opts === void 0 ? void 0 : opts.itemName) || "".concat(config.title).concat(name), JSON.stringify(data));
+  }
+  StorageUtil.setItem = setItem;
+  function getItem(name, opts) {
+    var cacheType = (opts === null || opts === void 0 ? void 0 : opts.type) || config.cacheType;
+    var item = window["".concat(cacheType, "Storage")].getItem((opts === null || opts === void 0 ? void 0 : opts.itemName) || "".concat(config.title).concat(name));
+    try {
+      return JSON.parse(item);
+    } catch (error) {
+      return item;
+    }
+  }
+  StorageUtil.getItem = getItem;
+  function removeItem(name, opts) {
+    var cacheType = (opts === null || opts === void 0 ? void 0 : opts.type) || config.cacheType;
+    if (name) window["".concat(cacheType, "Storage")].removeItem((opts === null || opts === void 0 ? void 0 : opts.itemName) || "".concat(config.title).concat(name));
+  }
+  StorageUtil.removeItem = removeItem;
+  function clear(opts) {
+    var cacheType = (opts === null || opts === void 0 ? void 0 : opts.type) || config.cacheType;
+    window["".concat(cacheType, "Storage")].clear();
+  }
+  StorageUtil.clear = clear;
+  function clearTitle(opts) {
+    var cacheType = (opts === null || opts === void 0 ? void 0 : opts.type) || config.cacheType;
+    Object.entries(window["".concat(cacheType, "Storage")]).forEach(function (_a) {
+      var _b = __read(_a, 1),
+        k = _b[0];
+      if (k.includes(config.title)) window["".concat(cacheType, "Storage")].removeItem(k);
+    });
+  }
+  StorageUtil.clearTitle = clearTitle;
+  /**
+   * 设置全局缓存前缀
+   * @param str 缓存前缀
+   */
+  StorageUtil.setGlobalTitle = function (str) {
+    config.title = str;
+  };
+  /**
+   * 设置全局缓存类型
+   * @param type  "session" | "local"
+   */
+  StorageUtil.setGlobalCacheType = function (type) {
+    config.cacheType = type;
+  };
+})(StorageUtil || (StorageUtil = {}));
+export default StorageUtil;