vue2-client 1.13.30 → 1.14.2

package/package.json

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

package/src/base-client/components/common/XFormTable/XFormTable.vue

@@ -81,7 +81,8 @@
             @gotoUserDetail="gotoUserDetail"
             @editButtonStateDataClick="editButtonStateDataClick"
             @importExcelOk="importExcelOk"
-            @rowClick="handleRowClick">
+            @rowClick="handleRowClick"
+            @expand="onExpand">
             <template slot="leftButton" slot-scope="{selectedRowKeys, selectedRows}">
               <slot name="leftButton" :selectedRowKeys="selectedRowKeys" :selectedRows="selectedRows"></slot>
             </template>
@@ -217,6 +218,7 @@ export default {
       table_selectedRows: [],
       // 数据只有一页时是否展示分页，true：展示，auto：隐藏
       showPagination: true,
+      isMounted: false
     }
   },
   computed: {
@@ -821,6 +823,9 @@ export default {
     // 添加处理 rowClick 的方法
     handleRowClick (record) {
       this.$emit('rowClick', record)
+    },
+    onExpand (expanded, record) {
+      this.$emit('expand', expanded, record)
     }
   },
   action: {
@@ -840,7 +845,12 @@ export default {
     }
   },
   mounted () {
-    this.initConfig()
+    if (!this.isMounted) {
+      // 防止多次调用
+      // 不知道为啥他会执行两次 mounted 暂时处理方式
+      this.initConfig()
+      this.isMounted = true
+    }
     if (this.getSelectedData && typeof this.getSelectedData === 'function') {
       const selectedId = this.getSelectedData()
       if (!selectedId) {

package/src/base-client/components/common/XFormTable/demo.vue

@@ -26,7 +26,7 @@ export default {
   data () {
     return {
       // 查询配置文件名
-      queryParamsName: 'crud_dictionary_manage',
+      queryParamsName: 'ChargeQueryCRUD',
       // 查询配置左侧tree
       // xTreeConfigName: 'addressType',
       // 新增表单固定值

package/src/base-client/components/common/XReportGrid/XReportTrGroup.vue

@@ -35,6 +35,7 @@
                 v-on="getEventHandlers(cell)"
                 @hook:mounted="(h)=>onComponentMounted(h,cell,cellIndex)"
                 @rowClick="handleRowClick"
+                @onExpand="onExpand"
                 :queryParamsName="cell.slotConfig"
                 :configName="cell.slotConfig"
                 :countVisible="false"
@@ -71,6 +72,7 @@
                 v-on="getEventHandlers(cell)"
                 @hook:mounted="(h)=>onComponentMounted(h,cell,cellIndex)"
                 @rowClick="handleRowClick"
+                @onExpand="onExpand"
                 :queryParamsName="cell.slotConfig"
                 :configName="cell.slotConfig"
                 :countVisible="false"
@@ -218,6 +220,9 @@ export default {
     handleRowClick (record) {
       this.$emit('rowClick', record)
     },
+    onExpand (expanded, record) {
+      this.$emit('expand', expanded, record)
+    },
     listClick (data) {
       this.$emit('listClick', data)
     },

package/src/base-client/components/common/XTable/XTable.vue

@@ -149,7 +149,10 @@
     </a-row>
     <!--  如果当前是表格模式  -->
     <template v-if="isTableMode">
-      <x-table-wrapper ref="table" @rowClick="handleRowClick">
+      <x-table-wrapper
+        ref="table"
+        @rowClick="handleRowClick"
+        @expand="onExpand">
         <template slot="expandedRowRender">
           <!-- 列扩展栅格 -->
           <x-report
@@ -250,7 +253,11 @@
       ref="exportExcel"
     />
     <a-modal @cancel="$refs.table.refresh()" v-model="selectedRowModalVisible" width="80vw" title="已选中数据" :footer="null">
-      <x-table-wrapper ref="selectedDataTable" :load-selected-data="true" @rowClick="handleRowClick"></x-table-wrapper>
+      <x-table-wrapper
+        ref="selectedDataTable"
+        :load-selected-data="true"
+        @rowClick="handleRowClick">
+      </x-table-wrapper>
     </a-modal>
   </div>
 </template>
@@ -1323,6 +1330,9 @@ export default {
     },
     handleRowClick (record) {
       this.$emit('rowClick', record)
+    },
+    onExpand (expanded, record) {
+      this.$emit('expand', expanded, record)
     }
   }
 }

package/src/base-client/components/common/XTable/XTableWrapper.vue

@@ -18,6 +18,7 @@
     :setScrollYHeight="tableContext.setScrollYHeight"
     :selectRowMode="tableContext.selectRowMode"
     :size="tableContext.tableSize"
+    @expand="onExpand"
     @rowClick="handleRowClick"
   >
     <template
@@ -296,6 +297,9 @@ export default {
     handleRowClick (record) {
       this.$emit('rowClick', record)
     },
+    onExpand (expanded, record) {
+      this.$emit('expand', expanded, record)
+    },
     setLocalDataSource (data) {
       this.activeTable?.setLocalDataSource(data)
     },

package/src/base-client/components/his/XHDescriptions/XHDescriptions.vue

@@ -325,7 +325,7 @@ export default {
   white-space: nowrap !important;
   min-width: v-bind('config?.style?.labelWidth || "80px"');
   justify-content: flex-start;
-  padding-right: 8px !important;
+  padding-right: 2px !important;
 }
 
 :deep(.ant-descriptions-item-content) {
@@ -334,7 +334,7 @@ export default {
   align-items: center !important;
   padding: 0 !important;
   margin: 0 !important;
-  margin-left: 2px !important;
+  margin-left: 0px !important;
 }
 
 :deep(.ant-descriptions-item-colon) {
@@ -343,6 +343,7 @@ export default {
   align-items: center !important;
   margin: 0 !important;
   padding: 0 !important;
+  margin-right: 2px !important;
 }
 
 :deep(.ant-descriptions-item-container:hover) {

package/src/bootstrap.js

@@ -5,6 +5,7 @@ import guards from '@vue2-client/router/guards'
 import interceptors from '@vue2-client/utils/axios-interceptors'
 import { getConfigByName } from '@vue2-client/services/api/common'
 import { hiPrintPlugin } from '@vue2-client/plugins/HiPrintPlugin'
+import { isMicroAppEnv } from '@vue2-client/utils/microAppUtils'
 
 /**
  * 启动引导方法
@@ -18,12 +19,15 @@ async function bootstrap ({ router, store, i18n, message }) {
   Vue.$store = store
   // 获取系统配置
   if (store) {
-    await getConfigByName('webConfig', undefined, res => {
-      localStorage.setItem(process.env.VUE_APP_WEB_CONFIG_KEY, JSON.stringify(res))
-      if (res?.setting) {
-        Vue.$store.commit('setting/setSetting', res?.setting)
-      }
-    })
+    // microApp 环境下作为子应用不获取webConfig
+    if (!isMicroAppEnv) {
+      await getConfigByName('webConfig', undefined, res => {
+        localStorage.setItem(process.env.VUE_APP_WEB_CONFIG_KEY, JSON.stringify(res))
+        if (res?.setting) {
+          Vue.$store.commit('setting/setSetting', res?.setting)
+        }
+      })
+    }
     await getConfigByName('componentStyles', undefined, res => {
       localStorage.setItem(process.env.VUE_APP_WEB_STYLES_KEY, JSON.stringify(res))
     })

package/src/router/async/router.map.js

@@ -18,7 +18,10 @@ routerResource.blank = view.blank
 routerResource.singlePage = view.blank
 // 栅格配置视图
 routerResource.gridView = view.gridView
-
+// 测试
+routerResource.businessQuery = view.blank
+// 业务查询 - 收费查询
+routerResource.chargeQuery = () => import('@vue2-client/base-client/components/common/XFormTable/demo.vue')
 // --------------------------------------仪表盘--------------------------------------
 routerResource.dashboard = view.blank
 // 工作台

package/src/utils/indexedDB.js

@@ -1,5 +1,9 @@
 import { post } from '@vue2-client/services/api'
 
+// 内存缓存作为IndexedDB的备用方案，防止数据库损坏时应用崩溃
+const MEMORY_CACHE = new Map()
+const USE_MEMORY_CACHE = true // 是否启用内存缓存
+
 const DB_CONFIG = {
   NAME: window.__MICRO_APP_NAME__ ? `view_${window.__MICRO_APP_NAME__}` : 'view',
   STORE_NAME: 'metaCache',
@@ -7,12 +11,16 @@ const DB_CONFIG = {
   CURRENT_VERSION: 1
 }
 
+// 数据库健康状态标记，用于在数据库异常时切换到备用方案
+let IS_DB_HEALTHY = true
+
 const LIULI_WEB_DB_NAME = 'view_liuli_web'
 
 export class IndexedDBManager {
   constructor () {
     this.db = undefined
-    this.locks = {}
+    this.locks = new Map()
+    this.requestTimeout = 10000
     this.isInMicroApp = !!window.__MICRO_APP_NAME__
     this.microAppName = window.__MICRO_APP_NAME__ || ''
     this.indexedDB = window?.rawWindow?.indexedDB || window.indexedDB || window.webkitindexedDB
@@ -22,9 +30,16 @@ export class IndexedDBManager {
   async openDatabase () {
     try {
       return await new Promise((resolve, reject) => {
+        // 添加超时机制，防止请求永久挂起
+        const timeout = setTimeout(() => {
+          console.error('[openDatabase] 请求超时，将尝试重建数据库')
+          reject(new Error('IndexedDB open timeout'))
+        }, 5000) // 5秒超时
+
         const checkRequest = this.indexedDB.open(DB_CONFIG.NAME)
 
         checkRequest.onsuccess = (e) => {
+          clearTimeout(timeout) // 清除超时
           const db = e.target.result
           const currentVersion = db.version
           db.close()
@@ -32,9 +47,19 @@ export class IndexedDBManager {
           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)
+          // 为第二次打开也添加超时
+          const openTimeout = setTimeout(() => {
+            console.error('[openDatabase] 二次打开请求超时')
+            reject(new Error('IndexedDB second open timeout'))
+          }, 5000)
+
+          request.onerror = (e) => {
+            clearTimeout(openTimeout)
+            reject(e.currentTarget.error)
+          }
 
           request.onsuccess = (e) => {
+            clearTimeout(openTimeout)
             const db = e.target.result
             if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
               db.close()
@@ -46,6 +71,7 @@ export class IndexedDBManager {
           }
 
           request.onupgradeneeded = (e) => {
+            clearTimeout(openTimeout)
             const db = e.target.result
             if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
               db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
@@ -53,15 +79,26 @@ export class IndexedDBManager {
           }
         }
 
-        checkRequest.onerror = (e) => reject(e.currentTarget.error)
+        checkRequest.onerror = (e) => {
+          clearTimeout(timeout)
+          reject(e.currentTarget.error)
+        }
       })
     } catch (error) {
-      console.error('打开数据库失败:', error)
+      console.error('[openDatabase] 打开数据库失败:', error)
+
+      // 如果是超时错误或版本错误，尝试自动重建数据库
+      if (error.message?.includes('timeout') || error.message?.includes('version')) {
+        await this.forceRecreateDatabase()
+        return this.openDatabase() // 递归调用，重新尝试打开
+      }
+
       throw error
     }
   }
 
   async upgradeDatabase (resolve, reject) {
+    console.warn('[upgradeDatabase] 升级数据库到版本:', DB_CONFIG.CURRENT_VERSION)
     const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
 
     request.onupgradeneeded = (e) => {
@@ -71,11 +108,28 @@ export class IndexedDBManager {
       }
     }
 
-    request.onsuccess = (e) => resolve(e.target.result)
-    request.onerror = (e) => reject(e.currentTarget.error)
+    request.onsuccess = (e) => {
+      resolve(e.target.result)
+    }
+    request.onerror = (e) => {
+      reject(e.currentTarget.error)
+    }
   }
 
   async openDB (callback) {
+    // 如果数据库不健康，直接调用回调并返回
+    if (!IS_DB_HEALTHY) {
+      console.warn('[openDB] 数据库不健康，跳过数据库操作')
+      setTimeout(() => {
+        try {
+          callback(null)
+        } catch (e) {
+          console.error('[openDB] 回调执行错误:', e)
+        }
+      }, 0)
+      return
+    }
+
     try {
       if (this.db) {
         const isAlive = await this.checkConnection()
@@ -85,13 +139,51 @@ export class IndexedDBManager {
         }
       }
 
-      this.db = await this.openDatabase()
-      callback(this.db)
+      // 添加超时机制，防止卡死
+      const openDbPromise = this.openDatabase()
+      const timeoutPromise = new Promise((resolve, reject) => {
+        setTimeout(() => reject(new Error('openDB timeout')), 5000)
+      })
+
+      try {
+        this.db = await Promise.race([openDbPromise, timeoutPromise])
+        callback(this.db)
+      } catch (error) {
+        console.error('[openDB] 打开数据库连接超时或失败', error)
+        // 标记数据库为不健康状态，后续操作使用备用方案
+        IS_DB_HEALTHY = false
+        try {
+          callback(null)
+        } catch (callbackError) {
+          console.error('[openDB] 回调执行错误:', callbackError)
+        }
+      }
     } catch (error) {
-      console.error('数据库操作失败:', error)
+      console.error('[openDB] 数据库操作失败:', error)
+
+      // 版本错误时尝试重建数据库
       if (error.message?.includes('version')) {
-        await this.recreateDatabase()
-        callback(this.db)
+        try {
+          await this.recreateDatabase()
+          callback(this.db)
+        } catch (rebuildError) {
+          console.error('[openDB] 重建失败，标记数据库为不健康状态', rebuildError)
+          IS_DB_HEALTHY = false
+          try {
+            callback(null)
+          } catch (callbackError) {
+            console.error('[openDB] 回调执行错误:', callbackError)
+          }
+        }
+      } else {
+        // 其他错误，标记为不健康并使用备用方案
+        IS_DB_HEALTHY = false
+        console.error('[openDB] 不可恢复的错误，标记数据库为不健康状态')
+        try {
+          callback(null)
+        } catch (callbackError) {
+          console.error('[openDB] 回调执行错误:', callbackError)
+        }
       }
     }
   }
@@ -102,41 +194,93 @@ export class IndexedDBManager {
       const store = transaction.objectStore(DB_CONFIG.STORE_NAME)
       await this.promisifyRequest(store.add({ key: 'alive', data: true }))
       return true
-    } catch {
+    } catch (error) {
       return false
     }
   }
 
   promisifyRequest (request) {
     return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result)
-      request.onerror = () => reject(request.error)
+      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)
+    // 数据库不健康时使用备用方案
+    if (!IS_DB_HEALTHY) {
+      console.warn(`[getByWeb] 数据库不健康，使用内存缓存或直接API调用`)
+      return this.getByWebWithoutDB(key, url, params, callback, processFun)
     }
 
-    this.locks[key] = (async () => {
+    // 锁机制：防止同一键的并发请求
+    if (this.locks.has(key)) {
+      const timeoutPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error(`请求超时: ${key}`))
+        }, this.requestTimeout)
+      })
+
+      try {
+        await Promise.race([this.locks.get(key), timeoutPromise])
+        return this.getByWeb(key, url, params, callback, processFun)
+      } catch (error) {
+        console.error(`[getByWeb] 等待锁期间出错或超时: ${error.message}`)
+        this.locks.delete(key)
+      }
+    }
+
+    const lockPromise = (async () => {
       try {
+        // 首先检查内存缓存
+        if (USE_MEMORY_CACHE && MEMORY_CACHE.has(key)) {
+          const cachedData = MEMORY_CACHE.get(key)
+          callback(cachedData)
+          return
+        }
+
+        // 再检查IndexedDB缓存
         const data = DB_CONFIG.NAME === LIULI_WEB_DB_NAME ? undefined : await this.getData(key)
+
         if (!data && url) {
+          // 缓存未命中，请求网络数据
           const res = await post(url, params)
           const processedData = processFun ? processFun(res) : res
 
+          // 同时保存到内存缓存
+          if (USE_MEMORY_CACHE) {
+            MEMORY_CACHE.set(key, processedData)
+          }
+
+          // 生产环境或非移动配置时保存到IndexedDB
           if (process.env.NODE_ENV === 'production' || key !== 'webMobileConfig') {
             await this.add(key, processedData)
           }
 
           callback(processedData)
         } else {
+          // 使用缓存数据
+          if (USE_MEMORY_CACHE && data) {
+            MEMORY_CACHE.set(key, data)
+          }
           callback(data)
         }
       } catch (error) {
-        console.error('获取数据失败:', error)
+        console.error(`[getByWeb] 获取数据失败: ${error.message}`)
+
+        // IndexedDB操作失败时切换到备用方案
+        if (error.name === 'InvalidStateError' || error.message?.includes('database') || error.message?.includes('transaction')) {
+          console.error(`[getByWeb] 数据库操作失败，标记为不健康`)
+          IS_DB_HEALTHY = false
+
+          // 使用备用方案获取数据
+          return this.getByWebWithoutDB(key, url, params, callback, processFun)
+        }
+
         if (process.env.NODE_ENV === 'production' && key !== 'webMobileConfig') {
           await this.add(key, null)
         }
@@ -144,65 +288,130 @@ export class IndexedDBManager {
       }
     })()
 
+    this.locks.set(key, lockPromise)
+
     try {
-      await this.locks[key]
+      const timeoutPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error(`操作超时: ${key}`))
+        }, this.requestTimeout)
+      })
+
+      await Promise.race([this.locks.get(key), timeoutPromise])
+    } catch (error) {
+      console.error(`[getByWeb] 执行期间出错或超时: ${error.message}`)
     } finally {
-      delete this.locks[key]
+      this.locks.delete(key)
+    }
+  }
+
+  // 备用方法：不使用IndexedDB，直接使用内存缓存和API
+  async getByWebWithoutDB (key, url, params, callback, processFun) {
+    // 首先检查内存缓存
+    if (USE_MEMORY_CACHE && MEMORY_CACHE.has(key)) {
+      const cachedData = MEMORY_CACHE.get(key)
+      callback(cachedData)
+      return
+    }
+
+    // 无URL则无法获取数据
+    if (!url) {
+      callback(null)
+      return
+    }
+
+    // 直接通过API获取数据
+    try {
+      const res = await post(url, params)
+      const processedData = processFun ? processFun(res) : res
+
+      // 保存到内存缓存
+      if (USE_MEMORY_CACHE) {
+        MEMORY_CACHE.set(key, processedData)
+      }
+
+      callback(processedData)
+    } catch (error) {
+      console.error(`[getByWebWithoutDB] 获取数据失败: ${error.message}`)
+      callback(null)
     }
   }
 
   async getData (key) {
     return new Promise((resolve) => {
       this.openDB((db) => {
+        if (!db) {
+          resolve(null)
+          return
+        }
         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)
+
+        request.onsuccess = (e) => {
+          resolve(e.target.result?.data)
+        }
+
+        request.onerror = () => {
+          resolve(null)
+        }
       })
     })
   }
 
   async add (key, data) {
     this.openDB((db) => {
+      if (!db) return
+
       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)
+
+      request.onerror = () => {
+        // 添加失败时尝试更新
+        this.update(key, data)
+      }
     })
   }
 
   async update (key, data) {
     this.openDB((db) => {
+      if (!db) return
+
       const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-      const request = store.put({ key, data })
-      request.onerror = () => console.error('数据更新失败')
+      store.put({ key, data })
     })
   }
 
   async delete (key) {
     this.openDB((db) => {
+      if (!db) return
+
       const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
-      const request = store.delete(key)
-      request.onerror = () => console.error('数据删除失败')
+      store.delete(key)
     })
   }
 
   async clear (callback) {
     this.openDB((db) => {
+      if (!db) {
+        if (typeof callback === 'function') callback()
+        return
+      }
+
       const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
       const request = store.clear()
+
       request.onerror = () => {
-        console.error('数据删除失败')
-        callback()
+        if (typeof callback === 'function') callback()
       }
+
       request.onsuccess = () => {
-        if (typeof callback === 'function') {
-          callback()
-        }
+        if (typeof callback === 'function') callback()
       }
     })
   }
 
   clearCache () {
+    // 清除缓存并刷新页面
     if (this.indexedDB) {
       this.clear(() => {
         location.reload()
@@ -215,22 +424,115 @@ export class IndexedDBManager {
   async getAll () {
     return new Promise((resolve, reject) => {
       this.openDB((db) => {
+        if (!db) {
+          resolve([])
+          return
+        }
+
         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)
+
+        request.onsuccess = (e) => {
+          resolve(e.target.result)
+        }
+
+        request.onerror = (e) => {
+          reject(e.target.error)
+        }
       })
     })
   }
 
   getAllLegacy (callback) {
     this.openDB((res) => {
+      if (!res) {
+        callback(null, new Error('打开数据库失败'))
+        return
+      }
+
       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)
+
+      request.onerror = (e) => {
+        callback(null, e.target.error)
+      }
+
+      request.onsuccess = (e) => {
+        callback(e.target.result)
+      }
     })
   }
+
+  async recreateDatabase () {
+    try {
+      if (this.db) {
+        this.db.close()
+        this.db = undefined
+      }
+
+      await new Promise((resolve, reject) => {
+        const deleteRequest = this.indexedDB.deleteDatabase(DB_CONFIG.NAME)
+
+        deleteRequest.onsuccess = () => {
+          resolve()
+        }
+
+        deleteRequest.onerror = (e) => {
+          reject(e.target.error)
+        }
+      })
+
+      DB_CONFIG.CURRENT_VERSION = DB_CONFIG.VERSION
+      this.db = await this.openDatabase()
+      return this.db
+    } catch (error) {
+      console.error('重新创建数据库失败:', error)
+      throw error
+    }
+  }
+
+  // 强制重建数据库的方法，带有超时保护
+  async forceRecreateDatabase () {
+    console.warn('[forceRecreateDatabase] 开始强制重建数据库')
+    try {
+      // 确保关闭所有连接
+      if (this.db) {
+        try {
+          this.db.close()
+        } catch (e) {
+          console.warn('[forceRecreateDatabase] 关闭现有连接出错')
+        }
+        this.db = undefined
+      }
+
+      // 清空锁防止死锁
+      this.locks.clear()
+
+      // 强制删除数据库，带超时保护
+      await new Promise((resolve) => {
+        const deleteRequest = this.indexedDB.deleteDatabase(DB_CONFIG.NAME)
+
+        const timeout = setTimeout(() => {
+          resolve() // 即使超时也继续执行
+        }, 3000)
+
+        deleteRequest.onsuccess = () => {
+          clearTimeout(timeout)
+          resolve()
+        }
+
+        deleteRequest.onerror = () => {
+          clearTimeout(timeout)
+          resolve() // 即使出错也继续执行
+        }
+      })
+
+      // 重置版本
+      DB_CONFIG.CURRENT_VERSION = DB_CONFIG.VERSION
+    } catch (error) {
+      console.error('[forceRecreateDatabase] 强制重建过程中出错:', error)
+    }
+  }
 }
 
 export const indexedDB = new IndexedDBManager()