@10yun/cv-mobile-ui 0.5.59 → 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.59",
+  "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/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;