@10yun/cv-mobile-ui 0.5.58 → 0.5.60

package/libs/storage2.js

@@ -1,14 +1,4 @@
-/***
- * title: storage.js
- * Author: Gaby
- * Email: xxx@126.com
- * Time: 2022/6/1 17:30
- * last: 2022/6/2 17:30
- * Desc: 对存储的简单封装
- */
-
 import CryptoJS from 'crypto-js';
-
 // 十六位十六进制数作为密钥
 const SECRET_KEY = CryptoJS.enc.Utf8.parse('3333e6e143439161');
 // 十六位十六进制数作为密钥偏移量

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10yun/cv-mobile-ui",
-  "version": "0.5.58",
+  "version": "0.5.60",
   "description": "十云cvjs移动端ui，适用uniapp",
   "homepage": "http://cvjs.cn/cv-mobile-ui/",
   "license": "Apache-2.0",

package/plugins/storage.js

@@ -1,279 +1,266 @@
 /**
- * 缓存数据优化
- * 使用方法
+ * StorageClass
+ * ✔ local = 持久化缓存（内存 + storage）
+ * ✔ memory = 纯内存缓存
+ * ✔ 自动过期清理
+ * ✔ 内存加速（Map）
+ * ✔ 懒清理 + 启动清理
+ * ✔ 防止 KEYS_CACHE_FLAG 污染
  */
-
-function get_data1(key, def) {
-  uni.getStorage({
-    key: key,
-    success: function (res) {
-      param.success(res.data || def);
-    }
-  });
-}
-function get_data2(key, def) {
-  const value = uni.getStorageSync(key);
-  return value || def;
-}
 class StorageClass {
-  //实例化类时默认会执行构造函数
   constructor(options = {}) {
     this.config = Object.assign(
       {
         cache_keys: 'syCacheKeys',
+        expiration: 7 * 86400, // 60 * 60 * 24 * 7,// 默认7天
         prefix: '',
         suffix: ''
       },
       options
     );
-    this.KEYS_CACHE_FLAG = this.config.cache_keys;
-  }
-  _getAllCache() {
-    let fullKey = this._getFullKey('___') || {};
-    let fullCache = uni.getStorageSync(fullKey);
-    return fullCache;
-  }
-  _setAllCache(appendKey) {
-    let fullKey = this._getFullKey('___');
-    let fullCache = uni.getStorageSync(fullKey) || {};
-    fullCache[appendKey] = 1;
-    uni.setStorageSync(fullKey, fullCache);
+
+    this.KEYS_CACHE_FLAG = this.__getFullKeyName(this.config.cache_keys) || '___';
+
+    // 内存缓存层
+    this.cacheMap = new Map();
+    // 初始化加载持久化缓存
+    this.__initPersistentCache();
+    // 启动时先清一波
+    this.__autoExpiredTimeKey();
   }
-  _removeAllCache(removeKey) {
-    let fullKey = this._getFullKey('___');
-    let fullCache = uni.getStorageSync(fullKey) || {};
-    delete fullCache[removeKey];
-    uni.setStorageSync(fullKey, fullCache);
+
+  /* ================= 初始化 ================= */
+
+  __initPersistentCache() {
+    try {
+      const { keys } = uni.getStorageInfoSync();
+      keys.forEach((key) => {
+        // 过滤：只加载当前前缀 & 排除 key表
+        if (key.startsWith(this.config.prefix) && key !== this.KEYS_CACHE_FLAG) {
+          const val = uni.getStorageSync(key);
+          if (val !== '') {
+            this.cacheMap.set(key, val);
+          }
+        }
+      });
+    } catch (e) {}
   }
-  _getFullKey(key) {
+  /* ================= 基础 ================= */
+
+  // 获取带前缀后缀的真实key
+  __getFullKeyName(key) {
     key = key || '';
-    const config = this.config;
-    if (config.prefix) {
-      key = config.prefix + key;
-    }
-    if (config.suffix) {
-      key += config.suffix;
-    }
+    const { prefix, suffix } = this.config;
+    if (prefix) key = prefix + key;
+    if (suffix) key += suffix;
     return key;
   }
-  localGet(key) {
-    return this.getSync(key) || '';
-  }
-  localSet(key, value) {
-    this.updateKey(key);
-    this.setAsync(key, value);
-    this.setSync(key, value);
-  }
-  localDel(key) {
-    this.removeAsync(key);
-    this.removeSync(key);
-  }
-  updateKey(key) {
-    let allCacheKeys = this.getSync(this.KEYS_CACHE_FLAG) || {};
-    // 当前时间
-    let currTime = parseInt(new Date().getTime() / 1000);
-    allCacheKeys[key] = currTime + 60 * 60 * 24 * 7; // 7天
-    this.setSync(this.KEYS_CACHE_FLAG, allCacheKeys);
-  }
-  checkKey(key) {
-    // 所有缓存keys
-    let allCacheKeys = this.getSync(this.KEYS_CACHE_FLAG) || {};
-    // 缓存时间
-    let currCacheExpires = allCacheKeys[key] || 0;
-    if (currCacheExpires > 0) {
-      return true;
-    }
-    // 当前时间
-    let currTime = parseInt(new Date().getTime() / 1000);
-    // 当前缓存
-    let currCache = this.getSync(key) || null;
-    if (!currCache) {
-      return false;
-    }
-    console.log(currCache);
-    if (currCache.length == 0 || currTime > currCacheExpires) {
-      return false;
-    }
-    return true;
+  // 判断key是否【未过期】
+  __getKeyTime(key) {
+    const allCacheKeys = uni.getStorageSync(this.KEYS_CACHE_FLAG) || {};
+    const deadTime = allCacheKeys[key] ? parseInt(allCacheKeys[key]) : 0;
+    if (deadTime === -1) return true; // 永久有效
+    const currTime = Math.floor(Date.now() / 1000); // 当前时间
+    return deadTime > currTime; // 未过期 = true
   }
-  /**
-   * 设置缓存 - 异步
-   * @param  {[type]} key [键名]
-   * @param  {[type]} data [键值]
-   * @param  {[type]} t [时间、单位秒]
-   * @使用方式 ==== 【设置缓存】
-   *     string    cache.put('k', 'string你好啊');
-   *     json      cache.put('k', { "b": "3" }, 2);
-   *     array     cache.put('k', [1, 2, 3]);
-   *     boolean   cache.put('k', true);
-   */
 
-  setAsync(key = '', data = '', t = 0) {
-    let fullKey = this._getFullKey(key);
-    uni.setStorage({
-      key: fullKey,
-      data: data,
-      success: () => {}
-    });
-    /* 设置过期时间 */
-    if (t) {
-      let timestamp = parseInt(new Date().getTime());
-      uni.setStorage({
-        key: fullKey + '_time',
-        data: timestamp + t * 1000,
-        success: () => {}
-      });
+  // 更新key过期时间
+  __updateKeyTime(key, timeStamp = -1) {
+    const allCacheKeys = uni.getStorageSync(this.KEYS_CACHE_FLAG) || {};
+    const currTime = Math.floor(Date.now() / 1000); // 当前时间
+    const defaultExpire = Math.floor(this.config.expiration) || 7 * 86400;
+    if (timeStamp === -1) {
+      allCacheKeys[key] = -1; // 永久有效
+    } else if (timeStamp > 0) {
+      allCacheKeys[key] = currTime + Math.floor(timeStamp);
+    } else {
+      allCacheKeys[key] = currTime + defaultExpire; // 默认7天
     }
-    this._setAllCache(fullKey);
+    uni.setStorageSync(this.KEYS_CACHE_FLAG, allCacheKeys);
   }
-  setSync(key = '', data = null, t = 0) {
-    let fullKey = this._getFullKey(key);
+  // 删除key的过期记录
+  __delKeyTime(key) {
+    const allCacheKeys = uni.getStorageSync(this.KEYS_CACHE_FLAG) || {};
+    delete allCacheKeys[key];
+    uni.setStorageSync(this.KEYS_CACHE_FLAG, allCacheKeys);
+  }
+  // 自动清理所有过期key（含内存）
+  __autoExpiredTimeKey() {
     try {
-      uni.setStorageSync(fullKey, data);
-      /* 设置过期时间 */
-      if (t) {
-        let timestamp = parseInt(new Date().getTime());
-        uni.setStorageSync(fullKey + '_time', timestamp + t * 1000);
+      const allCacheKeys = uni.getStorageSync(this.KEYS_CACHE_FLAG) || {};
+      const currTime = Math.floor(Date.now() / 1000);
+      let hasExpired = false;
+
+      // 遍历所有key，检查过期
+      for (const key in allCacheKeys) {
+        const deadTime = allCacheKeys[key];
+        if (deadTime === -1) continue; // 永久不过期
+
+        // 过期了
+        if (deadTime < currTime) {
+          const fullKey = this.__getFullKeyName(key);
+          uni.removeStorageSync(fullKey); // 删除缓存
+          this.cacheMap.delete(fullKey);
+          delete allCacheKeys[key]; // 删除过期记录
+          hasExpired = true;
+        }
+      }
+
+      // 有过期才更新，避免无意义写入
+      if (hasExpired) {
+        uni.setStorageSync(this.KEYS_CACHE_FLAG, allCacheKeys);
       }
-      this._setAllCache(fullKey);
     } catch (e) {
-      console.error(e);
+      console.error('__autoExpiredTimeKey error:', e);
     }
   }
-  /**
-   * 获取缓存
-   * @param  {[type]} key   [键名]
-   * @param  {[type]} def [获取为空时默认]
-   *
-   * @使用方式 ==== 【读取缓存】
-   *    默认值     cache.get('key')
-   *    string    cache.get('key', '你好')
-   *    json      cache.get('key', { "a": "1" })
-   */
-  /**
-   * 根据key获取数据缓存 -  异步
-   * @param {String} key
-   */
-  getAsync(param) {
-    param = Object.assign({ def: '' }, param);
 
-    let fullKey = this._getFullKey(param.key);
+  /* ================= 持久化缓存 ================= */
 
-    //先获取时间
-    var deadtime = 0;
-    uni.getStorage({
-      key: fullKey + '_time',
-      success: function (res) {
-        if (!res.data) {
-          get_data1(fullKey, param.success);
-        } else {
-          deadtime = parseInt(res.data);
-          let timestamp = parseInt(new Date().getTime());
-          if (deadtime > 0 && deadtime < timestamp) {
-            //过期了
-            param.success(def);
-          }
-          get_data1(fullKey, def);
-        }
-      }
-    });
-  }
   /**
-   * 根据key获取数据缓存 -  同步
-   * @param {String} key
+   * 获取缓存（内存优先，超快）
+   * @param {String} key 键名
+   * @param {String|Object|Array|Json|Boolean|Number} defValue 为空时默认值
+   * @使用方式 ==== 【读取缓存】
+   *    默认值     cache.localGet('key')
+   *    string    cache.localGet('key', '你好')
+   *    json      cache.localGet('key', { "a": "1" })
    */
-  getSync(key, def = '') {
-    let fullKey = this._getFullKey(key);
+  localGet(key, defValue = '') {
     try {
-      let deadtime = uni.getStorageSync(fullKey + '_time');
-      if (!deadtime) {
-        return get_data2(fullKey, def);
-      } else {
-        deadtime = parseInt(deadtime);
-        let timestamp = parseInt(new Date().getTime());
-        if (deadtime > 0 && deadtime < timestamp) {
-          //过期了
-          return def;
-        }
-        return get_data2(fullKey, def);
+      this.__autoExpiredTimeKey();
+      const fullKey = this.__getFullKeyName(key);
+      // 先查内存优先
+      if (this.cacheMap.has(fullKey)) {
+        return this.cacheMap.get(fullKey);
       }
+      // 过期判断
+      if (!this.__getKeyTime(key)) {
+        this.localDel(key);
+        return defValue;
+      }
+      // 查 storage
+      // JSON.parse(decodeURIComponent());
+      const data = uni.getStorageSync(fullKey);
+      // 回填内存
+      if (data !== '') {
+        this.cacheMap.set(fullKey, data);
+        return data;
+      }
+      return defValue;
     } catch (e) {
-      console.error(e);
+      console.error('localGet error:', e);
+      return defValue;
     }
   }
   /**
-   * 根据key删除一条缓存 - 异步
-   * @param {String|Object} pararm 支持传入字符串、对象
+   * 设置缓存（一定持久化）
+   * @param  {String} key 键名
+   * @param  {String|Object|Array|Json|Boolean|Number} value 键值
+   * @param  {Number} timeStamp 时间（单位秒）
+   * @使用方式 ==== 【设置缓存】
+   *     string    cache.localSet('k', 'string你好啊');
+   *     json      cache.localSet('k', { "b": "3" }, 2);
+   *     array     cache.localSet('k', [1, 2, 3]);
+   *     boolean   cache.localSet('k', true);
    */
-  removeAsync(param) {
-    let fullKey = '';
-    if (Object.prototype.toString.call(param) === '[object Object]') {
-      fullKey = this._getFullKey(param.key);
-      param.key = fullKey;
-      uni.removeStorage(param);
-    } else if (Object.prototype.toString.call(param) === '[object String]') {
-      fullKey = this._getFullKey(param);
-      uni.removeStorage({
-        key: fullKey
-      });
-    }
-    this._removeAllCache(fullKey);
+  localSet(key, value = null, timeStamp = -1) {
+    try {
+      this.__autoExpiredTimeKey();
+      const fullKey = this.__getFullKeyName(key);
+      // encodeURIComponent(JSON.stringify())
+      // 写 storage
+      uni.setStorageSync(fullKey, value);
+      // 写入内存
+      this.cacheMap.set(fullKey, value);
 
-    uni.removeStorage({
-      key: fullKey + '_time',
-      success: (res) => {}
-    });
+      // 设置过期
+      this.__updateKeyTime(key, timeStamp);
+    } catch (e) {
+      console.error('localSet error:', e);
+    }
   }
   /**
-   * 根据key删除一条缓存 - 同步
+   * 删除缓存
    * @param {String} key
    */
-  removeSync(key) {
-    let fullKey = this._getFullKey(key);
+  localDel(key) {
     try {
+      this.__autoExpiredTimeKey();
+      const fullKey = this.__getFullKeyName(key);
       uni.removeStorageSync(fullKey);
-      uni.removeStorageSync(fullKey + '_time');
-      this._removeAllCache(fullKey);
+
+      // 删除内存
+      this.cacheMap.delete(fullKey);
+
+      this.__delKeyTime(key);
     } catch (e) {
-      console.error(e);
+      console.error('localDel error:', e);
     }
   }
   /**
-   * 清除用户端所用缓存
-   */
-  clearAsync() {
-    uni.clearStorage();
-  }
-  /**
-   * 清除用户端所用缓存 - 同步
+   * 清空所有缓存
    */
-  clearSync() {
+  localClear() {
     try {
       uni.clearStorageSync();
+      // 清空内存
+      this.cacheMap.clear();
     } catch (e) {
-      console.error(e);
+      console.error('localClear error:', e);
     }
   }
   /**
-   * 同步获取当前 storage 的相关信息。 - 异步
+   * 检查key是否有效（存在+未过期）
+   * @param {*} key
+   * @returns
    */
-  info(success) {
-    uni.getStorageInfo({
-      success: function (res) {
-        success(res);
-      }
-    });
+  localHas(key) {
+    this.__autoExpiredTimeKey();
+    if (!this.__getKeyTime(key)) return false;
+    const fullKey = this.__getFullKeyName(key);
+
+    if (this.cacheMap.has(fullKey)) return true;
+    return !!this.localGet(key);
   }
   /**
-   * 同步获取当前 storage 的相关信息。 - 同步
+   * 获取storage信息
    */
-  infoSync() {
+  localInfo() {
     try {
+      this.__autoExpiredTimeKey();
       return uni.getStorageInfoSync();
     } catch (e) {
-      console.log(e);
+      console.error('localInfo error:', e);
+      return null;
     }
   }
+
+  /* ================= 纯内存缓存 ================= */
+
+  memorySet(key, value) {
+    const fullKey = this.__getFullKeyName(key);
+    this.cacheMap.set(fullKey, value);
+  }
+
+  memoryGet(key, defValue = '') {
+    const fullKey = this.__getFullKeyName(key);
+    return this.cacheMap.has(fullKey) ? this.cacheMap.get(fullKey) : defValue;
+  }
+
+  memoryDel(key) {
+    const fullKey = this.__getFullKeyName(key);
+    this.cacheMap.delete(fullKey);
+  }
+
+  memoryClear() {
+    this.cacheMap.clear();
+  }
+
+  memoryHas(key) {
+    const fullKey = this.__getFullKeyName(key);
+    return this.cacheMap.has(fullKey);
+  }
 }
+
 export default StorageClass;
-// export default

package/plugins/uniMap.js

@@ -34,8 +34,8 @@ export default class uniMap {
   static openLocation(lat, lng) {
     return new Promise((resolve, reject) => {
       uni.openLocation({
-        latitude: latitude,
-        longitude: longitude,
+        latitude: lat,
+        longitude: lng,
         success: function () {
           resolve();
         },

package/ui-cv/components/cv-geo-local/cv-geo-local.vue

@@ -11,14 +11,14 @@
         auto-height
       />
       <view @tap="chooseLocation" class="cv-geo-local-button">
-        <cv-icons type="actionSearch" size="20" color="#999999" />
+        <cv-icons type="geoLocateoutline" size="20" color="#999999" />
       </view>
     </view>
     <view class="cv-geo-local-map" v-if="isShowMap">
       <map
         style="width: 100%; height: 170px"
-        :longitude="map_location.longitude"
-        :latitude="map_location.latitude"
+        :longitude="localLongitude"
+        :latitude="localLatitude"
         :scale="localScale"
         show-location
         :markers="markers"
@@ -32,7 +32,7 @@ import mixin from '../../libs/mixin/mixin.js';
 export default {
   mixins: [mpMixin, mixin],
   name: 'cvGeoLocal',
-  emits: ['input', 'update:modelValue', 'location'],
+  emits: ['input', 'update:modelValue', 'update:longitude', 'update:latitude'],
   props: {
     value: {
       type: [Number, String],
@@ -42,6 +42,16 @@ export default {
       type: [Number, String],
       default: ''
     },
+    // 经度
+    longitude: {
+      type: [Number, String],
+      default: ''
+    },
+    // 纬度
+    latitude: {
+      type: [Number, String],
+      default: ''
+    },
     placeholder: {
       type: [String],
       default: '请输入定位地址'
@@ -83,7 +93,13 @@ export default {
         }
       }
     },
-    location(n) {
+    longitude(n) {
+      if (this.isShowMap) {
+        console.log('change:location');
+        this.initLocation();
+      }
+    },
+    latitude(n) {
       if (this.isShowMap) {
         console.log('change:location');
         this.initLocation();
@@ -111,10 +127,8 @@ export default {
       markers: [],
       //当前选择的位置
       localScale: 14,
-      map_location: {
-        longitude: 119.296411,
-        latitude: 26.074286
-      },
+      localLongitude: 119.296411,
+      localLatitude: 26.074286,
       parentObj: null
     };
   },
@@ -173,12 +187,12 @@ export default {
       this.funcOnInput();
     },
     initLocation() {
-      if (this.location.longitude && this.location.latitude) {
-        this.map_location = this.location;
+      if (this.longitude && this.latitude) {
+        this.localLongitude = this.longitude;
+        this.localLatitude = this.latitude;
       }
-      console.log('--', this.map_location);
       if (this.localVal) {
-        this.map_location['address'] = this.localVal;
+        this.localVal = this.localVal;
       }
     },
     chooseLocation() {
@@ -188,9 +202,11 @@ export default {
           console.log(res);
           if (res.errMsg == 'chooseLocation:ok') {
             this.localVal = res.address || '';
-            this.map_location = { ...res };
+            this.localLongitude = res.longitude || '';
+            this.localLatitude = res.latitude || '';
             this.localScale = 16;
-            this.$emit('location', { ...res });
+            this.$emit('update:longitude', this.localLongitude);
+            this.$emit('update:latitude', this.localLatitude);
             this.funcOnInput();
           }
         }
@@ -198,12 +214,11 @@ export default {
     },
     initMarkers() {
       let markers = [];
-      let map_location = this.map_location;
       markers.push({
-        latitude: map_location.latitude,
-        longitude: map_location.longitude,
+        latitude: this.localLatitude,
+        longitude: this.localLongitude,
         callout: {
-          content: map_location.address,
+          content: this.localVal,
           color: '#333333',
           borderRadius: 5,
           bgColor: '#ffffff',
@@ -224,6 +239,7 @@ export default {
   display: flex;
   flex-direction: column;
   width: 100%;
+  position: relative;
 }
 .cv-geo-local-info {
   display: flex;

package/ui-cv/components/cv-geo-region/cv-geo-region.vue

@@ -28,9 +28,21 @@ import mpMixin from '../../libs/mixin/mpMixin.js';
 import mixin from '../../libs/mixin/mixin.js';
 export default {
   mixins: [mpMixin, mixin],
-  name: 'cvPickerRegion',
-  emits: ['input', 'update:modelValue', 'onChoose'],
+  name: 'cvGeoRegion',
+  emits: ['input', 'update:modelValue', 'update:province', 'update:city', 'update:district', 'onChoose'],
   props: {
+    province: {
+      type: [String, Number],
+      default: ''
+    },
+    city: {
+      type: [String, Number],
+      default: ''
+    },
+    district: {
+      type: [String, Number],
+      default: ''
+    },
     value: {
       type: [Array, Object],
       default: () => []
@@ -54,6 +66,18 @@ export default {
     }
   },
   watch: {
+    province(newVal) {
+      this.localVal[0] = newVal;
+      this.itemsSortOut();
+    },
+    city(newVal) {
+      this.localVal[1] = newVal;
+      this.itemsSortOut();
+    },
+    district(newVal) {
+      this.localVal[2] = newVal;
+      this.itemsSortOut();
+    },
     value(newVal) {
       this.localVal = newVal;
       this.itemsSortOut();
@@ -71,7 +95,7 @@ export default {
       last_range_data: [], //最终显示页面数组
       items_index: [0, 0, 0], //当前下标
       lastRetDataIndex: [0, 0, 0], // 最终确定选中的下标
-      localDataType: 'text',
+      localValField: 'text',
       localDataValue: 'value',
       localDataText: 'label',
       localProvince: {},
@@ -81,7 +105,7 @@ export default {
   },
   created() {
     this.localVal = this.doValueGet();
-    this.localDataType = this.dataType != 'value' ? 'text' : 'value';
+    this.localValField = this.dataType != 'value' ? 'text' : 'value';
     this.itemsSortOut();
   },
   methods: {
@@ -146,7 +170,7 @@ export default {
       if (localValue) {
         /* 便利省级列表 找出省级的位置 */
         for (const key in data) {
-          if (localValue == data[key][this.localDataType]) {
+          if (localValue == data[key][this.localValField]) {
             localKey = parseInt(key);
           }
         }
@@ -203,18 +227,18 @@ export default {
       this.lastRetDataIndex = [...items_index];
       let value = [];
       let items = this.items;
-      if (this.localDataType == 'text') {
-        value[0] = this.range_data[0][items_index[0]].text;
-        value[1] = this.range_data[1][items_index[1]].text;
-        value[2] = this.range_data[2][items_index[2]].text;
-      } else {
-        value[0] = this.range_data[0][items_index[0]].value;
-        value[1] = this.range_data[1][items_index[1]].value;
-        value[2] = this.range_data[2][items_index[2]].value;
-      }
+      let item_key = this.localValField == 'text' ? 'text' : 'value';
+      value[0] = this.range_data[0][items_index[0]][item_key];
+      value[1] = this.range_data[1][items_index[1]][item_key];
+      value[2] = this.range_data[2][items_index[2]][item_key];
+
       this.$emit('input', value);
       this.$emit('update:modelValue', value);
 
+      this.$emit('update:province', value[0]);
+      this.$emit('update:city', value[1]);
+      this.$emit('update:district', value[2]);
+
       // 把选中的3个数组传递出去
 
       let selectAllArr = {

package/uview-plus/components/u-upload/file.js

@@ -145,7 +145,7 @@ export function parseFormData(data) {
   // formData['file']= file; // file 必须为最后一个表单域
   return formData;
 }
-function getFileInfo(imgStr) {
+export function getFileInfo(imgStr) {
   let index = imgStr.lastIndexOf('/');
   let strName = imgStr.substring(index + 1, imgStr.length);
   let strType = '';

package/uview-plus/components/u-upload/u-upload.vue

@@ -165,7 +165,8 @@ import {
   generateUniqidName,
   parseJsonSafe,
   parseFormData,
-  content_to_array
+  content_to_array,
+  getFileInfo
 } from './file.js';
 /**
  * upload 上传
@@ -257,6 +258,7 @@ export default {
     'delete',
     'clickPreview',
     'update:modelValue',
+    'update:initValue',
     'update:fileList',
     'afterAutoUpload'
   ],
@@ -542,6 +544,8 @@ export default {
                       let res2 = res1?.data || res1 || {};
                       // TODO 判断是否多图，
                       this.$emit('update:modelValue', res2.filelog_id || '');
+                      this.localList.push(getFileInfo(res2.cdn_full_path));
+                      this.formatFileList();
                       that.$emit(
                         'afterAutoUpload',
                         Object.assign(res2, {
@@ -666,6 +670,9 @@ export default {
     },
     deleteItem(index) {
       if (this.autoDelete) {
+        this.localList.splice(index, 1);
+        this.$emit('update:initValue', this.localList);
+
         this.fileList.splice(index, 1);
         this.$emit('update:fileList', this.fileList);
       } else {

package/libs/storage3.js

@@ -1,104 +0,0 @@
-let cacheMap = new Map();
-let timeoutDefault = 86400; // 设置默认超时时间，单位秒 60 * 60 * 24 (1天)
-
-function isTimeout(name) {
-  const data = cacheMap.get(name);
-  if (!data) return true;
-  if (data.timeout === 0) return false;
-  const currentTime = Date.now();
-  const overTime = (currentTime - data.createTime) / 1000;
-  if (overTime > data.timeout) {
-    cacheMap.delete(name);
-    if (name.startsWith('_')) {
-      try {
-        uni.removeStorageSync(name);
-      } catch (e) {
-        console.log(e);
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-class CacheCell {
-  constructor(data, timeout) {
-    this.data = data;
-    this.timeout = timeout; // 设置超时时间，单位秒
-    this.createTime = Date.now(); // 对象创建时候的时间
-  }
-}
-
-class CacheClass {
-  constructor(timeout) {
-    try {
-      const res = uni.getStorageInfoSync();
-      res.keys.forEach((name) => {
-        try {
-          const value = uni.getStorageSync(name);
-          cacheMap.set(name, value);
-        } catch (e) {
-          console.log(e);
-        }
-      });
-    } catch (e) {
-      console.log(e);
-    }
-    timeoutDefault = timeout;
-  }
-
-  /**
-   * 设置缓存数据
-   * @param {Any} name 缓存的key, 以下划线命名表示永久缓存到Storage
-   * @param {Any} data 缓存的数据
-   * @param {Number} timeout 缓存时间（秒），默认86400秒即一天，0表示永久缓存
-   */
-  set(name, data, timeout = timeoutDefault) {
-    const cachecell = new CacheCell(data, timeout);
-    let cache = null;
-    if (name.startsWith('_')) {
-      try {
-        uni.setStorageSync(name, cachecell);
-        cache = cacheMap.set(name, cachecell);
-      } catch (e) {
-        console.log(e);
-      }
-    } else {
-      cache = cacheMap.set(name, cachecell);
-    }
-    return cache;
-  }
-  get(name) {
-    return isTimeout(name) ? null : cacheMap.get(name).data;
-  }
-  delete(name) {
-    let value = false;
-    if (name.startsWith('_')) {
-      try {
-        uni.removeStorageSync(name);
-        value = cacheMap.delete(name);
-      } catch (e) {
-        console.log(e);
-      }
-    } else {
-      value = cacheMap.delete(name);
-    }
-    return value;
-  }
-  has(name) {
-    return !isTimeout(name);
-  }
-  clear() {
-    let value = false;
-    try {
-      uni.clearStorageSync();
-      cacheMap.clear();
-      value = true;
-    } catch (e) {
-      console.log(e);
-    }
-    return value;
-  }
-}
-
-export default CacheClass;

package/other/tui-clipboard/tui-clipboard.js

@@ -1,53 +0,0 @@
-/**
- * 复制文本 兼容H5
- * 来自 ThorUI  www.thorui.cn | 文档地址： www.donarui.com
- * @author echo.
- * @version 1.0.0
- **/
-// #ifdef H5
-import ClipboardJS from '../js-sdk/clipboard.min.js';
-// #endif
-const thorui = {
-  /**
-   * data 需要复制的数据
-   * callback 回调
-   * e 当用户点击后需要先请求接口再进行复制时，需要传入此参数，或者将异步请求转为同步 （H5端）
-   * **/
-  getClipboardData: function (data, callback, e) {
-    // #ifdef APP-PLUS || MP
-    uni.setClipboardData({
-      data: data,
-      success(res) {
-        'function' == typeof callback && callback(true);
-      },
-      fail(res) {
-        'function' == typeof callback && callback(false);
-      }
-    });
-    // #endif
-
-    // #ifdef H5
-    let event = window.event || e || {};
-    let clipboard = new ClipboardJS('', {
-      text: () => data
-    });
-    clipboard.on('success', (e) => {
-      'function' == typeof callback && callback(true);
-      clipboard.off('success');
-      clipboard.off('error');
-      clipboard.destroy();
-    });
-    clipboard.on('error', (e) => {
-      'function' == typeof callback && callback(false);
-      clipboard.off('success');
-      clipboard.off('error');
-      clipboard.destroy();
-    });
-    clipboard.onClick(event);
-    // #endif
-  }
-};
-
-export default {
-  getClipboardData: thorui.getClipboardData
-};