vue2-client 1.11.1 → 1.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue2-client",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "private": false,
   "scripts": {
     "serve": "SET NODE_OPTIONS=--openssl-legacy-provider && vue-cli-service serve --no-eslint",

package/src/utils/indexedDB.js

@@ -1,214 +1,234 @@
-import { post } from '@vue2-client/services/api'
-
-const DB_CONFIG = {
-  NAME: window.__MICRO_APP_NAME__ ? `view_${window.__MICRO_APP_NAME__}` : 'view',
-  STORE_NAME: 'metaCache',
-  VERSION: 1,
-  CURRENT_VERSION: 1
-}
-
-class IndexedDBManager {
-  constructor () {
-    this.db = undefined
-    this.locks = {}
-    this.isInMicroApp = !!window.__MICRO_APP_NAME__
-    this.microAppName = window.__MICRO_APP_NAME__ || ''
-    this.indexedDB = window?.rawWindow?.indexedDB || window.indexedDB || window.webkitindexedDB
-    this.IDBKeyRange = window?.rawWindow?.IDBKeyRange || window.IDBKeyRange || window.webkitIDBKeyRange
-  }
-
-  async openDatabase () {
-    try {
-      return await new Promise((resolve, reject) => {
-        const checkRequest = this.indexedDB.open(DB_CONFIG.NAME)
-
-        checkRequest.onsuccess = (e) => {
-          const db = e.target.result
-          const currentVersion = db.version
-          db.close()
-
-          DB_CONFIG.CURRENT_VERSION = Math.max(currentVersion, DB_CONFIG.VERSION)
-          const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
-
-          request.onerror = (e) => reject(e.currentTarget.error)
-
-          request.onsuccess = (e) => {
-            const db = e.target.result
-            if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
-              db.close()
-              DB_CONFIG.CURRENT_VERSION++
-              this.upgradeDatabase(resolve, reject)
-            } else {
-              resolve(db)
-            }
-          }
-
-          request.onupgradeneeded = (e) => {
-            const db = e.target.result
-            if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
-              db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
-            }
-          }
-        }
-
-        checkRequest.onerror = (e) => reject(e.currentTarget.error)
-      })
-    } catch (error) {
-      console.error('打开数据库失败:', error)
-      throw error
-    }
-  }
-
-  async upgradeDatabase (resolve, reject) {
-    const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
-
-    request.onupgradeneeded = (e) => {
-      const db = e.target.result
-      if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
-        db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
-      }
-    }
-
-    request.onsuccess = (e) => resolve(e.target.result)
-    request.onerror = (e) => reject(e.currentTarget.error)
-  }
-
-  async openDB (callback) {
-    try {
-      if (this.db) {
-        const isAlive = await this.checkConnection()
-        if (isAlive) {
-          callback(this.db)
-          return
-        }
-      }
-
-      this.db = await this.openDatabase()
-      callback(this.db)
-    } catch (error) {
-      console.error('数据库操作失败:', error)
-      if (error.message?.includes('version')) {
-        await this.recreateDatabase()
-        callback(this.db)
-      }
-    }
-  }
-
-  async checkConnection () {
-    try {
-      const transaction = this.db.transaction([DB_CONFIG.STORE_NAME], 'readwrite')
-      const store = transaction.objectStore(DB_CONFIG.STORE_NAME)
-      await this.promisifyRequest(store.add({ key: 'alive', data: true }))
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  promisifyRequest (request) {
-    return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result)
-      request.onerror = () => reject(request.error)
-    })
-  }
-
-  async getByWeb (key, url, params, callback, processFun) {
-    if (this.locks[key]) {
-      await this.locks[key]
-      return this.getByWeb(key, url, params, callback, processFun)
-    }
-
-    this.locks[key] = (async () => {
-      try {
-        const data = await this.getData(key)
-        if (!data && url) {
-          const res = await post(url, params)
-          const processedData = processFun ? processFun(res) : res
-
-          if (process.env.NODE_ENV === 'production' || key !== 'webMobileConfig') {
-            await this.add(key, processedData)
-          }
-
-          callback(processedData)
-        } else {
-          callback(data)
-        }
-      } catch (error) {
-        console.error('获取数据失败:', error)
-        if (process.env.NODE_ENV === 'production' && key !== 'webMobileConfig') {
-          await this.add(key, null)
-        }
-        callback(null)
-      }
-    })()
-
-    try {
-      await this.locks[key]
-    } finally {
-      delete this.locks[key]
-    }
-  }
-
-  async getData (key) {
-    return new Promise((resolve) => {
-      this.openDB((db) => {
-        const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-        const request = store.get(key)
-        request.onsuccess = (e) => resolve(e.target.result?.data)
-        request.onerror = () => resolve(null)
-      })
-    })
-  }
-
-  async add (key, data) {
-    this.openDB((db) => {
-      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-      const request = store.add({ key, data })
-      request.onerror = () => this.update(key, data)
-    })
-  }
-
-  async update (key, data) {
-    this.openDB((db) => {
-      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-      const request = store.put({ key, data })
-      request.onerror = () => console.error('数据更新失败')
-    })
-  }
-
-  async delete (key) {
-    this.openDB((db) => {
-      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-      const request = store.delete(key)
-      request.onerror = () => console.error('数据删除失败')
-    })
-  }
-
-  async clear (callback) {
-    this.openDB((db) => {
-      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-      const request = store.clear()
-      request.onerror = () => {
-        console.error('数据删除失败')
-        callback()
-      }
-      request.onsuccess = () => {
-        if (typeof callback === 'function') {
-          callback()
-        }
-      }
-    })
-  }
-
-  clearCache () {
-    if (this.indexedDB) {
-      this.clear(() => {
-        location.reload()
-      })
-    } else {
-      location.reload()
-    }
-  }
-}
-
-export const indexedDB = new IndexedDBManager()
+import { post } from '@vue2-client/services/api'
+
+const DB_CONFIG = {
+  NAME: window.__MICRO_APP_NAME__ ? `view_${window.__MICRO_APP_NAME__}` : 'view',
+  STORE_NAME: 'metaCache',
+  VERSION: 1,
+  CURRENT_VERSION: 1
+}
+
+export class IndexedDBManager {
+  constructor () {
+    this.db = undefined
+    this.locks = {}
+    this.isInMicroApp = !!window.__MICRO_APP_NAME__
+    this.microAppName = window.__MICRO_APP_NAME__ || ''
+    this.indexedDB = window?.rawWindow?.indexedDB || window.indexedDB || window.webkitindexedDB
+    this.IDBKeyRange = window?.rawWindow?.IDBKeyRange || window.IDBKeyRange || window.webkitIDBKeyRange
+  }
+
+  async openDatabase () {
+    try {
+      return await new Promise((resolve, reject) => {
+        const checkRequest = this.indexedDB.open(DB_CONFIG.NAME)
+
+        checkRequest.onsuccess = (e) => {
+          const db = e.target.result
+          const currentVersion = db.version
+          db.close()
+
+          DB_CONFIG.CURRENT_VERSION = Math.max(currentVersion, DB_CONFIG.VERSION)
+          const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
+
+          request.onerror = (e) => reject(e.currentTarget.error)
+
+          request.onsuccess = (e) => {
+            const db = e.target.result
+            if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
+              db.close()
+              DB_CONFIG.CURRENT_VERSION++
+              this.upgradeDatabase(resolve, reject)
+            } else {
+              resolve(db)
+            }
+          }
+
+          request.onupgradeneeded = (e) => {
+            const db = e.target.result
+            if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
+              db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
+            }
+          }
+        }
+
+        checkRequest.onerror = (e) => reject(e.currentTarget.error)
+      })
+    } catch (error) {
+      console.error('打开数据库失败:', error)
+      throw error
+    }
+  }
+
+  async upgradeDatabase (resolve, reject) {
+    const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
+
+    request.onupgradeneeded = (e) => {
+      const db = e.target.result
+      if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
+        db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
+      }
+    }
+
+    request.onsuccess = (e) => resolve(e.target.result)
+    request.onerror = (e) => reject(e.currentTarget.error)
+  }
+
+  async openDB (callback) {
+    try {
+      if (this.db) {
+        const isAlive = await this.checkConnection()
+        if (isAlive) {
+          callback(this.db)
+          return
+        }
+      }
+
+      this.db = await this.openDatabase()
+      callback(this.db)
+    } catch (error) {
+      console.error('数据库操作失败:', error)
+      if (error.message?.includes('version')) {
+        await this.recreateDatabase()
+        callback(this.db)
+      }
+    }
+  }
+
+  async checkConnection () {
+    try {
+      const transaction = this.db.transaction([DB_CONFIG.STORE_NAME], 'readwrite')
+      const store = transaction.objectStore(DB_CONFIG.STORE_NAME)
+      await this.promisifyRequest(store.add({ key: 'alive', data: true }))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  promisifyRequest (request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result)
+      request.onerror = () => reject(request.error)
+    })
+  }
+
+  async getByWeb (key, url, params, callback, processFun) {
+    if (this.locks[key]) {
+      await this.locks[key]
+      return this.getByWeb(key, url, params, callback, processFun)
+    }
+
+    this.locks[key] = (async () => {
+      try {
+        const data = await this.getData(key)
+        if (!data && url) {
+          const res = await post(url, params)
+          const processedData = processFun ? processFun(res) : res
+
+          if (process.env.NODE_ENV === 'production' || key !== 'webMobileConfig') {
+            await this.add(key, processedData)
+          }
+
+          callback(processedData)
+        } else {
+          callback(data)
+        }
+      } catch (error) {
+        console.error('获取数据失败:', error)
+        if (process.env.NODE_ENV === 'production' && key !== 'webMobileConfig') {
+          await this.add(key, null)
+        }
+        callback(null)
+      }
+    })()
+
+    try {
+      await this.locks[key]
+    } finally {
+      delete this.locks[key]
+    }
+  }
+
+  async getData (key) {
+    return new Promise((resolve) => {
+      this.openDB((db) => {
+        const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+        const request = store.get(key)
+        request.onsuccess = (e) => resolve(e.target.result?.data)
+        request.onerror = () => resolve(null)
+      })
+    })
+  }
+
+  async add (key, data) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.add({ key, data })
+      request.onerror = () => this.update(key, data)
+    })
+  }
+
+  async update (key, data) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.put({ key, data })
+      request.onerror = () => console.error('数据更新失败')
+    })
+  }
+
+  async delete (key) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.delete(key)
+      request.onerror = () => console.error('数据删除失败')
+    })
+  }
+
+  async clear (callback) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.clear()
+      request.onerror = () => {
+        console.error('数据删除失败')
+        callback()
+      }
+      request.onsuccess = () => {
+        if (typeof callback === 'function') {
+          callback()
+        }
+      }
+    })
+  }
+
+  clearCache () {
+    if (this.indexedDB) {
+      this.clear(() => {
+        location.reload()
+      })
+    } else {
+      location.reload()
+    }
+  }
+
+  async getAll () {
+    return new Promise((resolve, reject) => {
+      this.openDB((db) => {
+        const store = db.transaction(DB_CONFIG.STORE_NAME, 'readonly').objectStore(DB_CONFIG.STORE_NAME)
+        const request = store.getAll()
+        request.onsuccess = (e) => resolve(e.target.result)
+        request.onerror = (e) => reject(e.target.error)
+      })
+    })
+  }
+
+  getAllLegacy (callback) {
+    this.openDB((res) => {
+      const store = res.transaction(DB_CONFIG.STORE_NAME, 'readonly').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.getAll()
+      request.onerror = (e) => callback(null, e.target.error)
+      request.onsuccess = (e) => callback(e.target.result)
+    })
+  }
+}
+
+export const indexedDB = new IndexedDBManager()