@10yun/cv-mobile-ui 0.5.27 → 0.5.30

package/plugins/luch-request/utils/clone.js

@@ -0,0 +1,264 @@
+/* eslint-disable */
+var clone = (function() {
+  'use strict';
+
+  function _instanceof(obj, type) {
+    return type != null && obj instanceof type;
+  }
+
+  var nativeMap;
+  try {
+    nativeMap = Map;
+  } catch(_) {
+    // maybe a reference error because no `Map`. Give it a dummy value that no
+    // value will ever be an instanceof.
+    nativeMap = function() {};
+  }
+
+  var nativeSet;
+  try {
+    nativeSet = Set;
+  } catch(_) {
+    nativeSet = function() {};
+  }
+
+  var nativePromise;
+  try {
+    nativePromise = Promise;
+  } catch(_) {
+    nativePromise = function() {};
+  }
+
+  /**
+   * Clones (copies) an Object using deep copying.
+   *
+   * This function supports circular references by default, but if you are certain
+   * there are no circular references in your object, you can save some CPU time
+   * by calling clone(obj, false).
+   *
+   * Caution: if `circular` is false and `parent` contains circular references,
+   * your program may enter an infinite loop and crash.
+   *
+   * @param `parent` - the object to be cloned
+   * @param `circular` - set to true if the object to be cloned may contain
+   *    circular references. (optional - true by default)
+   * @param `depth` - set to a number if the object is only to be cloned to
+   *    a particular depth. (optional - defaults to Infinity)
+   * @param `prototype` - sets the prototype to be used when cloning an object.
+   *    (optional - defaults to parent prototype).
+   * @param `includeNonEnumerable` - set to true if the non-enumerable properties
+   *    should be cloned as well. Non-enumerable properties on the prototype
+   *    chain will be ignored. (optional - false by default)
+   */
+  function clone(parent, circular, depth, prototype, includeNonEnumerable) {
+    if (typeof circular === 'object') {
+      depth = circular.depth;
+      prototype = circular.prototype;
+      includeNonEnumerable = circular.includeNonEnumerable;
+      circular = circular.circular;
+    }
+    // maintain two arrays for circular references, where corresponding parents
+    // and children have the same index
+    var allParents = [];
+    var allChildren = [];
+
+    var useBuffer = typeof Buffer != 'undefined';
+
+    if (typeof circular == 'undefined')
+      circular = true;
+
+    if (typeof depth == 'undefined')
+      depth = Infinity;
+
+    // recurse this function so we don't reset allParents and allChildren
+    function _clone(parent, depth) {
+      // cloning null always returns null
+      if (parent === null)
+        return null;
+
+      if (depth === 0)
+        return parent;
+
+      var child;
+      var proto;
+      if (typeof parent != 'object') {
+        return parent;
+      }
+
+      if (_instanceof(parent, nativeMap)) {
+        child = new nativeMap();
+      } else if (_instanceof(parent, nativeSet)) {
+        child = new nativeSet();
+      } else if (_instanceof(parent, nativePromise)) {
+        child = new nativePromise(function (resolve, reject) {
+          parent.then(function(value) {
+            resolve(_clone(value, depth - 1));
+          }, function(err) {
+            reject(_clone(err, depth - 1));
+          });
+        });
+      } else if (clone.__isArray(parent)) {
+        child = [];
+      } else if (clone.__isRegExp(parent)) {
+        child = new RegExp(parent.source, __getRegExpFlags(parent));
+        if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+      } else if (clone.__isDate(parent)) {
+        child = new Date(parent.getTime());
+      } else if (useBuffer && Buffer.isBuffer(parent)) {
+        if (Buffer.from) {
+          // Node.js >= 5.10.0
+          child = Buffer.from(parent);
+        } else {
+          // Older Node.js versions
+          child = new Buffer(parent.length);
+          parent.copy(child);
+        }
+        return child;
+      } else if (_instanceof(parent, Error)) {
+        child = Object.create(parent);
+      } else {
+        if (typeof prototype == 'undefined') {
+          proto = Object.getPrototypeOf(parent);
+          child = Object.create(proto);
+        }
+        else {
+          child = Object.create(prototype);
+          proto = prototype;
+        }
+      }
+
+      if (circular) {
+        var index = allParents.indexOf(parent);
+
+        if (index != -1) {
+          return allChildren[index];
+        }
+        allParents.push(parent);
+        allChildren.push(child);
+      }
+
+      if (_instanceof(parent, nativeMap)) {
+        parent.forEach(function(value, key) {
+          var keyChild = _clone(key, depth - 1);
+          var valueChild = _clone(value, depth - 1);
+          child.set(keyChild, valueChild);
+        });
+      }
+      if (_instanceof(parent, nativeSet)) {
+        parent.forEach(function(value) {
+          var entryChild = _clone(value, depth - 1);
+          child.add(entryChild);
+        });
+      }
+
+      for (var i in parent) {
+        var attrs = Object.getOwnPropertyDescriptor(parent, i);
+        if (attrs) {
+          child[i] = _clone(parent[i], depth - 1);
+        }
+
+        try {
+          var objProperty = Object.getOwnPropertyDescriptor(parent, i);
+          if (objProperty.set === 'undefined') {
+            // no setter defined. Skip cloning this property
+            continue;
+          }
+          child[i] = _clone(parent[i], depth - 1);
+        } catch(e){
+          if (e instanceof TypeError) {
+            // when in strict mode, TypeError will be thrown if child[i] property only has a getter
+            // we can't do anything about this, other than inform the user that this property cannot be set.
+            continue
+          } else if (e instanceof ReferenceError) {
+            //this may happen in non strict mode
+            continue
+          }
+        }
+
+      }
+
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(parent);
+        for (var i = 0; i < symbols.length; i++) {
+          // Don't need to worry about cloning a symbol because it is a primitive,
+          // like a number or string.
+          var symbol = symbols[i];
+          var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+          if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+            continue;
+          }
+          child[symbol] = _clone(parent[symbol], depth - 1);
+          Object.defineProperty(child, symbol, descriptor);
+        }
+      }
+
+      if (includeNonEnumerable) {
+        var allPropertyNames = Object.getOwnPropertyNames(parent);
+        for (var i = 0; i < allPropertyNames.length; i++) {
+          var propertyName = allPropertyNames[i];
+          var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
+          if (descriptor && descriptor.enumerable) {
+            continue;
+          }
+          child[propertyName] = _clone(parent[propertyName], depth - 1);
+          Object.defineProperty(child, propertyName, descriptor);
+        }
+      }
+
+      return child;
+    }
+
+    return _clone(parent, depth);
+  }
+
+  /**
+   * Simple flat clone using prototype, accepts only objects, usefull for property
+   * override on FLAT configuration object (no nested props).
+   *
+   * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+   * works.
+   */
+  clone.clonePrototype = function clonePrototype(parent) {
+    if (parent === null)
+      return null;
+
+    var c = function () {};
+    c.prototype = parent;
+    return new c();
+  };
+
+// private utility functions
+
+  function __objToStr(o) {
+    return Object.prototype.toString.call(o);
+  }
+  clone.__objToStr = __objToStr;
+
+  function __isDate(o) {
+    return typeof o === 'object' && __objToStr(o) === '[object Date]';
+  }
+  clone.__isDate = __isDate;
+
+  function __isArray(o) {
+    return typeof o === 'object' && __objToStr(o) === '[object Array]';
+  }
+  clone.__isArray = __isArray;
+
+  function __isRegExp(o) {
+    return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
+  }
+  clone.__isRegExp = __isRegExp;
+
+  function __getRegExpFlags(re) {
+    var flags = '';
+    if (re.global) flags += 'g';
+    if (re.ignoreCase) flags += 'i';
+    if (re.multiline) flags += 'm';
+    return flags;
+  }
+  clone.__getRegExpFlags = __getRegExpFlags;
+
+  return clone;
+})();
+
+export default clone

package/plugins/luch-request/utils.js

@@ -0,0 +1,131 @@
+'use strict';
+
+// utils is a library of generic helper functions non-specific to axios
+
+var toString = Object.prototype.toString;
+
+/**
+ * Determine if a value is an Array
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+export function isArray(val) {
+  return toString.call(val) === '[object Array]';
+}
+
+/**
+ * Determine if a value is an Object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+export function isObject(val) {
+  return val !== null && typeof val === 'object';
+}
+
+/**
+ * Determine if a value is a Date
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Date, otherwise false
+ */
+export function isDate(val) {
+  return toString.call(val) === '[object Date]';
+}
+
+/**
+ * Determine if a value is a URLSearchParams object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+ */
+export function isURLSearchParams(val) {
+  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
+}
+
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ */
+export function forEach(obj, fn) {
+  // Don't bother if no value provided
+  if (obj === null || typeof obj === 'undefined') {
+    return;
+  }
+
+  // Force an array if not already something iterable
+  if (typeof obj !== 'object') {
+    /*eslint no-param-reassign:0*/
+    obj = [obj];
+  }
+
+  if (isArray(obj)) {
+    // Iterate over array values
+    for (var i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    // Iterate over object keys
+    for (var key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        fn.call(null, obj[key], key, obj);
+      }
+    }
+  }
+}
+
+/**
+ * 是否为boolean 值
+ * @param val
+ * @returns {boolean}
+ */
+export function isBoolean(val) {
+  return typeof val === 'boolean';
+}
+
+/**
+ * 是否为真正的对象{} new Object
+ * @param {any} obj - 检测的对象
+ * @returns {boolean}
+ */
+export function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]';
+}
+
+/**
+ * Function equal to merge with the difference being that no reference
+ * to original objects is kept.
+ *
+ * @see merge
+ * @param {Object} obj1 Object to merge
+ * @returns {Object} Result of all merge properties
+ */
+export function deepMerge(/* obj1, obj2, obj3, ... */) {
+  let result = {};
+  function assignValue(val, key) {
+    if (typeof result[key] === 'object' && typeof val === 'object') {
+      result[key] = deepMerge(result[key], val);
+    } else if (typeof val === 'object') {
+      result[key] = deepMerge({}, val);
+    } else {
+      result[key] = val;
+    }
+  }
+  for (let i = 0, l = arguments.length; i < l; i++) {
+    forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+
+export function isUndefined(val) {
+  return typeof val === 'undefined';
+}

package/plugins/request.js

@@ -57,6 +57,7 @@ const EnumStatusToMsg = {
 class RequestClass {
   constructor(options = {}) {
     this.flagMap = options.flagMap || {};
+    this.flagAuth = options.flagAuth || {};
     this.flagFunc = options.flagFunc;
     this.baseURL = options.baseURL || '';
     this.requests = Object.assign({}, options.requests || {});
@@ -118,23 +119,23 @@ class RequestClass {
   }
 
   /**
-   * 设置flag参数
+   * 设置API
    */
-  setFlag(newFlagMap) {
-    this.flagMap = Object.assign({}, this.flagMap, newFlagMap || {});
+  setApiFlag(options) {
+    this.flagMap = options || {};
     return this;
   }
-  parseFlag(oldFlag) {
-    // 类型对
-    // 不存在
-    // 重新获取flag方法存在
-    if (typeof oldFlag == 'string' && !this.flagMap[oldFlag] && typeof this.flagFunc == 'function') {
-      // 重新加载flag
-      let newFlagArr = this.flagFunc();
-      // console.log(newFlagArr);
-      this.setFlag(newFlagArr);
-    }
-    return oldFlag;
+  appendApiFlag(options) {
+    this.flagMap = Object.assign({}, this.flagMap, options || {});
+    return this;
+  }
+  setApiAuth(options) {
+    this.flagAuth = options || {};
+    return this;
+  }
+  appendApiAuth(options) {
+    this.flagAuth = Object.assign({}, this.flagAuth, options || {});
+    return this;
   }
   /**
    * 设置header参数
@@ -143,7 +144,7 @@ class RequestClass {
    */
   setDefHeaders(options) {
     this.headers = Object.assign({}, this.headers, options || {});
-    // this.reqObj.defaults.headers = this.headers;
+    // this.requestHandle.defaults.headers = this.headers;
     return this;
   }
   setHeaders(options) {
@@ -157,7 +158,7 @@ class RequestClass {
    */
   setDefRequests(options) {
     this.requests = Object.assign({}, this.requests, options || {});
-    // this.reqObj.defaults.requests = this.requests;
+    // this.requestHandle.defaults.requests = this.requests;
     return this;
   }
   setRequests(options) {
@@ -284,7 +285,6 @@ class RequestClass {
         return apiResData;
         break;
     }
-    console.log('---');
   }
   /**
    * 调用 API 统一 请求 方法
@@ -316,64 +316,56 @@ class RequestClass {
 
     reqData = reqData || {};
     reqData = Object.assign({}, this.requests, reqData);
-    type = type || 'request';
-    type = type.toLowerCase();
     /*
      * 全局 uni.request 配置过滤不需要登录的页面
      */
-
     // uni.showNavigationBarLoading(); // 顶部加载动画
 
     // 初始化句柄
     let $requestHandle = null;
-    let request_setttings = {
-      url: request_url,
-      header: this.headers
-    };
-    if (type == 'upload') {
+    /**
+     * 判断是否加密
+     */
+    let encryptFlag = this.__encryp_parse(apiUrl);
+    /**
+     * 最后 type
+     */
+    let last_type = this.__parse_method_type(type);
+
+    // if (last_type == 'POST') {
+    // } else
+    if (last_type == 'UPLOAD') {
       /* 文件上传 */
       // 一定要删除这个，让uni.uploadFile自己携带
-      delete request_setttings.header['Content-Type'];
-      request_setttings = Object.assign({}, request_setttings, reqData);
-      $requestHandle = uni.uploadFile(request_setttings);
-    } else if (type == 'download') {
+      delete this.headers['Content-Type'];
+      $requestHandle = uni.uploadFile({
+        url: request_url,
+        header: this.headers,
+        // data: reqData,
+        ...reqData
+      });
+    } else if (last_type == 'DOWNLOAD') {
       /* 文件下载 */
     } else {
       /* request */
 
-      request_setttings.header['Content-Type'] = 'application/json';
-      // request_setttings.header['Content-Type'] = 'application/x-www-form-urlencoded';
-      // request_setttings.header['connection'] = 'close';
-
-      let MetSupport = this.needMethods || [];
-
-      if (MetSupport.length > 0) {
-        // 转大写
-        let typeDaxie = type.toUpperCase();
-        // console.log(MetSupport, type, MetSupport.indexOf(typeDaxie));
-        if (MetSupport.indexOf(typeDaxie) !== -1) {
-          type = 'POST';
-          request_setttings.header['X-HTTP-Method-Override'] = typeDaxie;
-        } else {
-          delete request_setttings.header['X-HTTP-Method-Override'];
-        }
-      }
+      this.headers['Content-Type'] = 'application/json';
+      // this.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+      // this.headers['connection'] = 'close';
 
-      // 全部默认加上 login_type
-      Object.assign(request_setttings, {
-        data: reqData,
-        method: type
+      $requestHandle = uni.request({
+        //   header: {
+        //     ...this.headers
+        //   },
+        //   data: {
+        //     ...this.requests,
+        //     reqData,
+        //   },
+        url: request_url,
+        header: this.headers,
+        method: last_type,
+        data: reqData
       });
-      // xxx = {
-      //   header: {
-      //     ...this.headers
-      //   },
-      //   data: {
-      //     ...this.requests,
-      //     reqData,
-      //   },
-      // }
-      $requestHandle = uni.request(request_setttings);
     }
     return $requestHandle.then((uniRes) => {
       _hideUniapp();
@@ -386,8 +378,8 @@ class RequestClass {
         // apiResData 为 接口返回 拼接的数据，一般 success 成功，开发者只需要 apiResData
         // let apiResData = JSON.parse(uniRes.data, true);
 
-        // upload需要json转数组
-        if (type == 'upload') {
+        // upload 需要json转数组
+        if (type == 'UPLOAD') {
           apiResData = JSON.parse(apiResData, true);
         }
         return _this.resetNetResponse(apiResData);
@@ -401,6 +393,25 @@ class RequestClass {
     //   return Promise.reject(uniRes);
     // });
   }
+  __encryp_parse(url) {
+    //
+  }
+  __parse_method_type(type) {
+    let last_type = type;
+    let MetSupport = this.needMethods || [];
+    if (MetSupport.length > 0) {
+      // 转大写
+      let typeDaxie = last_type.toUpperCase();
+      // console.log(MetSupport, last_type, MetSupport.indexOf(typeDaxie));
+      if (MetSupport.indexOf(typeDaxie) !== -1) {
+        last_type = 'POST';
+        this.headers['X-HTTP-Method-Override'] = typeDaxie;
+      } else {
+        delete this.headers['X-HTTP-Method-Override'];
+      }
+    }
+    return last_type;
+  }
   /**
    * GET 请求
    */
@@ -490,7 +501,7 @@ class RequestClass {
     let apiUrl = '';
     let apiUrlNoMsg = '';
     if (flagOrUrl == 'flag') {
-      let apiFlag = this.parseFlag(argumentsArr[0]);
+      let apiFlag = argumentsArr[0];
       if (typeof apiFlag === 'string') {
         apiFlag = apiFlag || '';
         apiUrl = apiFlag == '' ? '' : this.flagMap[apiFlag] || '';
@@ -522,12 +533,14 @@ class RequestClass {
       let arg2Type = Object.prototype.toString.call(arg2Val);
       // let argType2_2 = typeof argumentsArr[1] === 'object';
       if (arg2Type === '[object String]' || arg2Type === '[object Number]') {
-        // console.log('----转换-----', BigInt(arg2Val), Number(arg2Val)); 超过17位
-        if (!isNaN(arg2Val)) {
-          // console.log('---数字');
-          let bigIntNum = BigInt(`${arg2Val}`);
-          let isEndId = bigIntNum.toString();
-          if (!confirmEnding(apiUrl, '/')) {
+        // console.log('----转换-----', parseInt(arg2Val), BigInt(arg2Val), Number(arg2Val)); // 超过17位;
+        let isEndId = Number(arg2Val);
+        if (!isNaN(isEndId)) {
+          // 检查是否精度丢失（当原始值有超过17位或转换后不等时）
+          if (isEndId.toString() !== String(arg2Val).trim()) {
+            isEndId = BigInt(`${arg2Val}`).toString(); // 回退到BigInt
+          }
+          if (!apiUrl.endsWith('/')) {
             apiUrl = apiUrl + '/';
           }
           apiUrl = apiUrl + isEndId;
@@ -543,6 +556,8 @@ class RequestClass {
         }
       } else if (arg2Type === '[object Object]') {
         reqData = arg2Val || {};
+      } else if (arg2Type === '[object FormData]') {
+        reqData = arg2Val || new FormData();
       }
       return _this.apiAll(methodType, apiUrl, reqData);
     } else {