indexeddb-keyvalue 1.0.7

package/README.md

@@ -0,0 +1,219 @@
+# indexeddb-keyvalue
+
+轻量级 IndexedDB 封装库，提供表管理、CRUD 操作和 HTTP 请求缓存功能。
+
+## 特性
+
+- **双层缓存架构** - **内存 + IndexedDB**，重复读取直接从内存返回，性能提升 100-500 倍
+- 自动版本管理 - 无需手动处理数据库升级
+- 自动表创建 - 使用不存在的表时自动创建
+- 工厂模式 - 全局缓存实例，避免重复创建连接
+- Promise API - 全异步操作，支持 async/await
+- HTTP 缓存 - 自动缓存 fetch 请求结果
+- TypeScript 支持 - 完整的类型定义文件
+- 零依赖 - 轻量级，无外部依赖
+
+## 性能对比
+
+| 操作 | 纯 IndexedDB | indexeddb-keyvalue (内存缓存) | 性能提升 |
+|------|-------------|------------------------------|---------|
+| 首次读取 | ~1-5ms | ~1-5ms | 持平 |
+| 重复读取 | ~1-5ms | **~0.01ms** | **100-500 倍** |
+| 写入 | ~2-8ms | ~2-8ms (内存+持久化) | 可靠持久化 |
+
+> 基于 Chrome/Edge 浏览器测试，实际性能因数据大小和设备而异。SimpleIndexDBStorage 会自动将读取过的数据缓存到内存，后续访问几乎无延迟。
+
+## 安装
+
+```bash
+npm install indexeddb-keyvalue
+```
+
+## 使用方式
+
+### 方式一：SimpleIndexDBStorage（推荐）
+
+最简单的使用方式，**自带内存缓存**，一行代码搞定高性能数据存储：
+
+```javascript
+import { SimpleIndexDBStorage } from 'indexeddb-keyvalue';
+
+// 创建存储实例（自带内存缓存 + IndexedDB 双层存储）
+const storage = new SimpleIndexDBStorage('myDB', 'myTable');
+
+// 保存数据（同时写入内存和 IndexedDB）
+await storage.saveItem('user1', { name: '张三', age: 25 });
+
+// 第一次读取 - 从 IndexedDB 加载并缓存到内存
+const user1 = await storage.getItem('user1');
+
+// 第二次读取 - 直接从内存返回，性能提升 10 倍以上！
+const user2 = await storage.getItem('user1'); // ⚡ 超快，几乎无延迟
+
+// 查看内存缓存状态
+console.log('内存缓存条目数:', storage.getMemoryCacheSize());
+
+// 删除数据（同时删除内存和 IndexedDB）
+await storage.deleteItem('user1');
+
+// 清空表（同时清空内存和 IndexedDB）
+await storage.clear();
+
+// 仅清空内存缓存（保留 IndexedDB 数据）
+storage.clearMemoryCache();
+```
+
+**性能优势：**
+- 首次读取：从 IndexedDB 加载 → 约 1-5ms
+- 后续读取：直接从内存返回 → **约 0.01ms，快 100-500 倍**
+
+### 方式二：IndexedDBCachedFetch（HTTP 请求缓存）
+
+自动缓存网络请求结果：
+
+```javascript
+import { IndexedDBCachedFetch } from 'indexeddb-keyvalue';
+
+const cachedFetch = new IndexedDBCachedFetch('cacheDB', 'apiCache');  // 版本号不传则自动获取
+
+// 第一次请求会访问网络并缓存结果
+const data = await cachedFetch.fetchJson('https://api.example.com/data');
+
+// 后续请求直接从 IndexedDB 读取，不访问网络
+const cachedData = await cachedFetch.fetchJson('https://api.example.com/data');
+
+// 支持其他响应类型
+const text = await cachedFetch.fetchText('https://api.example.com/text');
+const blob = await cachedFetch.fetchBlob('https://api.example.com/image.png');
+const buffer = await cachedFetch.fetchArrayBuffer('https://api.example.com/binary');
+
+// 使用转换函数处理数据
+const users = await cachedFetch.fetchJson('https://api.example.com/users', (data) => {
+  return data.map(user => ({ ...user, fullName: `${user.firstName} ${user.lastName}` }));
+});
+```
+
+### 方式三：工厂模式（多表共享连接）
+
+多表场景下共享数据库连接，更节省资源：
+
+```javascript
+import { IndexDBStorageFactory } from 'indexeddb-keyvalue';
+
+// 获取存储实例（全局缓存，版本号不传则自动获取）
+const userStorage = IndexDBStorageFactory.getStorage('appDB', 'users');
+const orderStorage = IndexDBStorageFactory.getStorage('appDB', 'orders');
+const productStorage = IndexDBStorageFactory.getStorage('appDB', 'products');
+
+// 使用方式与 SimpleIndexDBStorage 相同
+await userStorage.saveItem('user1', { name: '张三' });
+await orderStorage.saveItem('order1', { total: 100 });
+await productStorage.saveItem('product1', { name: '商品A' });
+
+// 获取数据
+const user = await userStorage.getItem('user1');
+const order = await orderStorage.getItem('order1');
+const product = await productStorage.getItem('product1');
+
+// 清除缓存（如需重新创建实例）
+IndexDBStorageFactory.clearCache('appDB', 'users');     // 清除指定表
+IndexDBStorageFactory.clearCache('appDB');               // 清除整个数据库
+IndexDBStorageFactory.clearAllCache();                   // 清除所有缓存
+```
+
+### 方式四：底层 API（TinyIndexDB）
+
+需要更多控制时使用：
+
+```javascript
+import { TinyIndexDB } from 'indexeddb-keyvalue';
+
+// 创建实例（版本号不传则自动获取）
+const db = new TinyIndexDB('myDatabase', 'id');
+
+// 初始化数据库（创建多个表）
+await db.initDB({
+  users: [['name', true], ['email', false]],     // [索引名, 是否唯一]
+  orders: [['userId', false], ['status', false]]
+});
+
+// 批量保存数据
+await db.saveOrUpdate('users', [
+  { id: 'user1', name: '张三', email: 'zhangsan@example.com' },
+  { id: 'user2', name: '李四', email: 'lisi@example.com' }
+]);
+
+// 批量读取数据
+const users = await db.readData('users', ['user1', 'user2']);
+
+// 批量删除
+await db.delData('users', ['user1']);
+
+// 清空表
+await db.clearTable('users');
+
+// 自定义事务
+await db.withTable('users', async (database) => {
+  const tx = database.transaction('users', 'readwrite');
+  const store = tx.objectStore('users');
+  // 执行自定义操作...
+});
+```
+
+## API 参考
+
+### SimpleIndexDBStorage
+
+| 方法 | 参数 | 返回值 | 说明 |
+|------|------|--------|------|
+| `saveItem(name, data)` | `name: string`, `data: any` | `Promise<void>` | 保存或更新数据（内存+IndexedDB） |
+| `getItem(name)` | `name: string` | `Promise<any>` | 获取数据（优先从内存读取） |
+| `deleteItem(name)` | `name: string` | `Promise<void>` | 删除数据（内存+IndexedDB） |
+| `clear()` | - | `Promise<void>` | 清空表（内存+IndexedDB） |
+| `clearMemoryCache()` | - | `void` | 仅清空内存缓存 |
+| `getMemoryCacheSize()` | - | `number` | 获取内存缓存条目数 |
+
+### IndexedDBCachedFetch
+
+| 方法 | 参数 | 返回值 | 说明 |
+|------|------|--------|------|
+| `fetchJson(url, converter?)` | `url: string`, `converter?: (data) => any` | `Promise<T>` | 获取 JSON 数据 |
+| `fetchText(url, converter?)` | `url: string`, `converter?: (data) => string` | `Promise<string>` | 获取文本数据 |
+| `fetchBlob(url, converter?)` | `url: string`, `converter?: (data) => Blob` | `Promise<Blob>` | 获取 Blob 数据 |
+| `fetchArrayBuffer(url, converter?)` | `url: string`, `converter?: (data) => ArrayBuffer` | `Promise<ArrayBuffer>` | 获取二进制数据 |
+
+### IndexDBStorageFactory
+
+| 方法 | 参数 | 返回值 | 说明 |
+|------|------|--------|------|
+| `getStorage(dbName, tableName)` | `dbName: string`, `tableName: string` | `IndexDBStorage` | 获取/创建存储实例 |
+| `clearCache(dbName, tableName?)` | `dbName: string`, `tableName?: string` | `void` | 清除指定缓存 |
+| `clearAllCache()` | - | `void` | 清除所有缓存 |
+
+## 开发
+
+```bash
+# 安装依赖
+npm install
+
+# 开发模式（启动本地服务器）
+npm run dev
+
+# 构建生产版本
+npm run build
+
+# 构建开发版本
+npm run build:dev
+```
+
+## 浏览器兼容性
+
+- Chrome/Edge 24+
+- Firefox 16+
+- Safari 10+
+- iOS Safari 10+
+- Android Chrome 25+
+
+## 许可证
+
+MIT

package/dist/index.js

@@ -0,0 +1,2 @@
+(()=>{"use strict";var e={d:(t,a)=>{for(var n in a)e.o(a,n)&&!e.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:a[n]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},t={};function a(e,t){return function(...a){return new Promise(function(n,r){let i=e[t];i=i.bind(e);let s=i(...a);s.onsuccess=function(){n(s)},s.onerror=function(e){r(e)}})}}e.r(t),e.d(t,{IndexDBStorage:()=>r,IndexDBStorageFactory:()=>i,IndexedDBCachedFetch:()=>o,SimpleIndexDBStorage:()=>s,TinyIndexDB:()=>n,default:()=>s});class n{constructor(e,t){const a=window.indexedDB||window.webkitIndexedDB||window.msIndexedDB||window.mozIndexedDB;this.dbName=e,this.dbV=null,this.indexDbApi=a,this.keyPath=t,this.tablesConfig=null,this._db=null}async _ensureDbVersion(){void 0!==this.dbV&&null!==this.dbV||(this.dbV=await this._getCurrentVersion())}async initDB(e){this.tablesConfig={...this.tablesConfig,...e};let t=Object.keys(e);await this._ensureDbVersion();let a=await this._openDBInternal(),n=t.filter(e=>!a.objectStoreNames.contains(e));if(n.length>0){console.log("Missing tables:",n.join(", ")),a.close(),this._db&&this._db.close(),this._db=null,this.dbV+=1;try{a=await this._openDBAndCreateTables(e)}catch(n){if(!n||"VersionError"!==n.name)throw n;{console.log("Version conflict during table creation, retrying...");const n=await this._getCurrentVersion();this.dbV=n,a=await this._openDBInternal(),t.filter(e=>!a.objectStoreNames.contains(e)).length>0&&(this.dbV+=1,a.close(),a=await this._openDBAndCreateTables(e))}}}return this._db=a,a}async _openDBInternal(){let e=this;try{return await this._doOpenRaw()}catch(t){if(t&&"VersionError"===t.name){console.log(`VersionError: requested ${e.dbV}, getting actual version...`);const t=await e._getCurrentVersion();return e.dbV=t,this._doOpenRaw()}throw t}}_doOpenRaw(){let e=this;return new Promise((t,a)=>{let n=e.indexDbApi.open(e.dbName,e.dbV);n.onerror=function(e){a(e.target.error)},n.onsuccess=function(e){t(e.target.result)},n.onblocked=function(e){console.warn("Database open blocked, waiting for other connections to close...")}})}_getCurrentVersion(){let e=this;return new Promise((t,a)=>{let n=e.indexDbApi.open(e.dbName);n.onsuccess=function(e){let a=e.target.result,n=a.version;a.close(),console.log(`Current database version: ${n}`),t(n)},n.onerror=function(e){a(n.error)}})}async _openDBAndCreateTables(e){let t=this;try{return await this._doOpenAndCreate(e)}catch(a){if(a&&"VersionError"===a.name){console.log(`VersionError in _openDBAndCreateTables: requested ${t.dbV}, getting actual version...`);const a=await t._getCurrentVersion();return t.dbV=a,this._doOpenAndCreate(e)}throw a}}_doOpenAndCreate(e){let t=this,a=Object.keys(e),n=Object.values(e);return new Promise((e,r)=>{let i=t.indexDbApi.open(t.dbName,t.dbV);i.onerror=function(e){r(e.target.error)},i.onsuccess=function(t){e(t.target.result)},i.onupgradeneeded=function(e){let r,i=e.target.result;for(let e=0;e<a.length;e++)if(!i.objectStoreNames.contains(a[e])){r=i.createObjectStore(a[e],{keyPath:t.keyPath,autoIncrement:!1}),console.log("TABLE "+a[e]+" created Success");for(let t=0;t<n[e].length;t++)r.createIndex(n[e][t][0],n[e][t][0],{unique:n[e][t][1]})}}})}async openDB(){let e=this;if(this._db&&!this._db.closed)return this._db;await this._ensureDbVersion();try{return await this._doOpenDB()}catch(t){if("VersionError"===t.name){console.log(`VersionError in openDB: requested ${e.dbV}, getting actual version...`);const t=await e._getCurrentVersion();return e.dbV=t,this._doOpenDB()}throw t}}_doOpenDB(){let e=this;return new Promise((t,a)=>{let n=e.indexDbApi.open(e.dbName,e.dbV);n.onerror=function(e){a(e.target.error)},n.onsuccess=function(a){let n=a.target.result;n.onclose=function(){e._db=null},n.onversionchange=function(t){console.log("Database version changed, closing connection..."),n.close(),e._db=null},e._db=n,t(n)}})}async withTable(e,t){let a=await this.openDB();return await t(a)}async delData(e,t){return this.withTable(e,async n=>{const r=a(n.transaction(e,"readwrite").objectStore(e),"delete");for(let e=0;e<t.length;e++)await r(t[e])})}async readData(e,t){return this.withTable(e,async n=>{let r=a(n.transaction(e).objectStore(e),"get"),i=[];for(let e=0;e<t.length;e++){let a=await r(t[e]);i.push(a.result)}return i})}async saveOrUpdate(e,t){return this.withTable(e,async n=>{const r=a(n.transaction(e,"readwrite").objectStore(e),"put");for(let e=0;e<t.length;e++)await r(t[e])})}async addData(e,t){return this.withTable(e,async n=>{const r=a(n.transaction(e,"readwrite").objectStore(e),"add");for(let e=0;e<t.length;e++)await r(t[e])})}async updateData(e,t){return this.withTable(e,async n=>{const r=a(n.transaction(e,"readwrite").objectStore(e),"put");for(let e=0;e<t.length;e++)await r(t[e])})}async clearTable(e){return this.withTable(e,async t=>{const n=a(t.transaction(e,"readwrite").objectStore(e),"clear");await n()})}}class r{constructor(e,t){this.dbName=e,this.tableName=t,this.isInited=!1,this.tinyIndexDB=new n(e,"name")}async init(){if(this.isInited)return;const e={[this.tableName]:[["name",!0],["data",!1]]};await this.tinyIndexDB.initDB(e),this.isInited=!0}async saveItem(e,t){await this.init(),await this.tinyIndexDB.saveOrUpdate(this.tableName,[{name:e,data:t}])}async addItem(e,t){await this.init(),await this.tinyIndexDB.addData(this.tableName,[{name:e,data:t}])}async updateItem(e,t){await this.init(),await this.tinyIndexDB.updateData(this.tableName,[{name:e,data:t}])}async deleteItem(e){await this.init(),await this.tinyIndexDB.delData(this.tableName,[e])}async clear(){await this.init(),await this.tinyIndexDB.clearTable(this.tableName)}async getItem(e){await this.init();try{let t=(await this.tinyIndexDB.readData(this.tableName,[e]))[0];return t&&t.data}catch(e){return console.log(e),null}}}class i{static _storageCache=new Map;static _tinyIndexDBCache=new Map;static getStorage(e,t){const a=`${e}:${t}`;if(this._storageCache.has(a))return this._storageCache.get(a);const n=new r(e,t);return this._storageCache.set(a,n),n}static getTinyIndexDB(e){if(this._tinyIndexDBCache.has(e))return this._tinyIndexDBCache.get(e);const t=new n(e,"name");return this._tinyIndexDBCache.set(e,t),t}static clearCache(e,t){if(t)this._storageCache.delete(`${e}:${t}`);else{for(const t of this._storageCache.keys())t.startsWith(`${e}:`)&&this._storageCache.delete(t);this._tinyIndexDBCache.delete(e)}}static clearAllCache(){this._storageCache.clear(),this._tinyIndexDBCache.clear()}}class s{constructor(e,t){this.dbName=e||"linushp_default",this.tableName=t||"linushp_t",this._memoryCache=new Map,this._storage=null}_getStorage(){return this._storage||(this._storage=i.getStorage(this.dbName,this.tableName)),this._storage}async saveItem(e,t){return this._memoryCache.set(e,t),this._getStorage().saveItem(e,t)}async getItem(e){if(this._memoryCache.has(e))return this._memoryCache.get(e);const t=await this._getStorage().getItem(e);return null!=t&&this._memoryCache.set(e,t),t}async deleteItem(e){return this._memoryCache.delete(e),this._getStorage().deleteItem(e)}async clear(){return this._memoryCache.clear(),this._getStorage().clear()}getMemoryCacheSize(){return this._memoryCache.size}clearMemoryCache(){this._memoryCache.clear()}}class o{constructor(e,t){this.indexDbStorage=new s(e,t)}fetchJson(e,t){return this.fetch(e,"json",t)}fetchArrayBuffer(e,t){return this.fetch(e,"arrayBuffer",t)}fetchBlob(e,t){return this.fetch(e,"blob",t)}fetchText(e,t){return this.fetch(e,"text",t)}async fetch(e,t,a){let n=await this.indexDbStorage.getItem(e);if(!n){let r=await fetch(e);"arrayBuffer"===t?n=await r.arrayBuffer():"json"===t?n=await r.json():"blob"===t?n=await r.blob():"text"===t?n=await r.text():(n=null,console.error("responseType error")),a&&(n=await a(n)),await this.indexDbStorage.saveItem(e,n)}return n}}module.exports=t})();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","mappings":"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","sources":["webpack://indexdb-cached-xhr/webpack/bootstrap","webpack://indexdb-cached-xhr/webpack/runtime/define property getters","webpack://indexdb-cached-xhr/webpack/runtime/hasOwnProperty shorthand","webpack://indexdb-cached-xhr/webpack/runtime/make namespace object","webpack://indexdb-cached-xhr/./src/utils/promisifyStore.js","webpack://indexdb-cached-xhr/./src/TinyIndexDB.js","webpack://indexdb-cached-xhr/./src/IndexDBStorage.js","webpack://indexdb-cached-xhr/./src/IndexDBStorageFactory.js","webpack://indexdb-cached-xhr/./src/SimpleIndexDBStorage.js","webpack://indexdb-cached-xhr/./src/IndexedDBCachedFetch.js"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * 将 IndexedDB object store 方法 Promise 化\n * @param {IDBObjectStore} store - IndexedDB object store\n * @param {string} method - 方法名 (get, put, add, delete, clear 等)\n * @returns {Function} 返回一个 Promise 化的函数\n */\nfunction promisifyStore(store, method) {\n    return function (...args) {\n        return new Promise(function (resolve, reject) {\n            let func = store[method];\n            func = func.bind(store);\n            let req = func(...args);\n            req.onsuccess = function () {\n                resolve(req);\n            };\n            req.onerror = function (e) {\n                reject(e);\n            };\n        });\n    };\n}\n\nexport { promisifyStore };\n","import { promisifyStore } from './utils/promisifyStore.js';\n\n/**\n * TinyIndexDB - IndexedDB 的轻量级封装\n * 提供数据库初始化、连接缓存、CRUD 操作\n */\nclass TinyIndexDB {\n\n    constructor(dbName, keyPath) {\n        const indexDbApi = window.indexedDB || window.webkitIndexedDB || window.msIndexedDB || window.mozIndexedDB;\n        this.dbName = dbName;\n        this.dbV = null;  // dbV不需要外面传，内部自动获取\n        this.indexDbApi = indexDbApi;\n        this.keyPath = keyPath;\n        this.tablesConfig = null;\n        this._db = null;  // 缓存的数据库连接\n    }\n\n    /**\n     * 确保 dbV 已设置，未设置时自动获取当前版本\n     */\n    async _ensureDbVersion() {\n        if (this.dbV === undefined || this.dbV === null) {\n            this.dbV = await this._getCurrentVersion();\n        }\n    }\n\n    /**\n     * 初始化数据库，创建缺失的表\n     * @param {Object} tables - 表配置 { tableName: [['indexName', unique], ...] }\n     */\n    async initDB(tables) {\n        this.tablesConfig = { ...this.tablesConfig, ...tables };\n        let tableNames = Object.keys(tables);\n\n        // 确保版本号已设置\n        await this._ensureDbVersion();\n\n        // 先打开数据库检查表是否存在\n        let db = await this._openDBInternal();\n\n        // 检查是否所有表都存在\n        let missingTables = tableNames.filter(name => !db.objectStoreNames.contains(name));\n\n        if (missingTables.length > 0) {\n            // 有表不存在，需要升级版本号创建\n            console.log('Missing tables:', missingTables.join(', '));\n            db.close();\n\n            // 关闭缓存的连接，否则升级版本时会被阻塞\n            if (this._db) {\n                this._db.close();\n            }\n            this._db = null;\n\n            // 升级版本号并重新打开\n            this.dbV += 1;\n            try {\n                db = await this._openDBAndCreateTables(tables);\n            } catch (err) {\n                // 如果版本已被其他实例升级，重新获取当前版本\n                if (err && err.name === 'VersionError') {\n                    console.log('Version conflict during table creation, retrying...');\n                    const actualVersion = await this._getCurrentVersion();\n                    this.dbV = actualVersion;\n                    // 重新检查表是否存在\n                    db = await this._openDBInternal();\n                    let stillMissing = tableNames.filter(name => !db.objectStoreNames.contains(name));\n                    if (stillMissing.length > 0) {\n                        // 还是需要创建表，再升级一次版本\n                        this.dbV += 1;\n                        db.close();\n                        db = await this._openDBAndCreateTables(tables);\n                    }\n                } else {\n                    throw err;\n                }\n            }\n        }\n\n        this._db = db;\n        return db;\n    }\n\n    async _openDBInternal() {\n        let self = this;\n\n        try {\n            return await this._doOpenRaw();\n        } catch (err) {\n            // 如果版本号过低，获取当前版本并重试\n            if (err && err.name === 'VersionError') {\n                console.log(`VersionError: requested ${self.dbV}, getting actual version...`);\n                const actualVersion = await self._getCurrentVersion();\n                self.dbV = actualVersion;\n                return this._doOpenRaw();\n            }\n            throw err;\n        }\n    }\n\n    _doOpenRaw() {\n        let self = this;\n        return new Promise((resolve, reject) => {\n            let req = self.indexDbApi.open(self.dbName, self.dbV);\n            req.onerror = function (e) {\n                reject(e.target.error);\n            };\n            req.onsuccess = function (e) {\n                resolve(e.target.result);\n            };\n            req.onblocked = function (e) {\n                console.warn('Database open blocked, waiting for other connections to close...');\n            };\n        });\n    }\n\n    /**\n     * 获取数据库当前版本（不传版本号打开）\n     */\n    _getCurrentVersion() {\n        let self = this;\n        return new Promise((resolve, reject) => {\n            // 不传版本号，获取当前版本\n            let req = self.indexDbApi.open(self.dbName);\n            req.onsuccess = function (e) {\n                let db = e.target.result;\n                let version = db.version;\n                db.close();\n                console.log(`Current database version: ${version}`);\n                resolve(version);\n            };\n            req.onerror = function (e) {\n                reject(req.error);\n            };\n        });\n    }\n\n    async _openDBAndCreateTables(tables) {\n        let self = this;\n\n        try {\n            return await this._doOpenAndCreate(tables);\n        } catch (err) {\n            // 如果版本号过低，获取当前版本并更新后再试\n            if (err && err.name === 'VersionError') {\n                console.log(`VersionError in _openDBAndCreateTables: requested ${self.dbV}, getting actual version...`);\n                const actualVersion = await self._getCurrentVersion();\n                self.dbV = actualVersion;\n                return this._doOpenAndCreate(tables);\n            }\n            throw err;\n        }\n    }\n\n    _doOpenAndCreate(tables) {\n        let self = this;\n        let tableNames = Object.keys(tables);\n        let tableIndexes = Object.values(tables);\n\n        return new Promise((resolve, reject) => {\n            let req = self.indexDbApi.open(self.dbName, self.dbV);\n            req.onerror = function (e) {\n                reject(e.target.error);\n            };\n            req.onsuccess = function (e) {\n                resolve(e.target.result);\n            };\n            req.onupgradeneeded = function (e) {\n                let db = e.target.result;\n                let store;\n                for (let i = 0; i < tableNames.length; i++) {\n                    if (!db.objectStoreNames.contains(tableNames[i])) {\n                        store = db.createObjectStore(tableNames[i], {keyPath: self.keyPath, autoIncrement: false});\n                        console.log('TABLE ' + tableNames[i] + ' created Success');\n                        for (let j = 0; j < tableIndexes[i].length; j++) {\n                            store.createIndex(tableIndexes[i][j][0], tableIndexes[i][j][0], {unique: tableIndexes[i][j][1]});\n                        }\n                    }\n                }\n            };\n        });\n    }\n\n    /**\n     * 打开数据库连接（带缓存）\n     */\n    async openDB() {\n        let self = this;\n\n        // 如果已有连接且未关闭，直接返回\n        if (this._db && !this._db.closed) {\n            return this._db;\n        }\n\n        // 确保版本号已设置\n        await this._ensureDbVersion();\n\n        try {\n            return await this._doOpenDB();\n        } catch (err) {\n            // 如果版本号过低，获取当前版本并重试\n            if (err.name === 'VersionError') {\n                console.log(`VersionError in openDB: requested ${self.dbV}, getting actual version...`);\n                const actualVersion = await self._getCurrentVersion();\n                self.dbV = actualVersion;\n                return this._doOpenDB();\n            }\n            throw err;\n        }\n    }\n\n    _doOpenDB() {\n        let self = this;\n        return new Promise((resolve, reject) => {\n            let req = self.indexDbApi.open(self.dbName, self.dbV);\n            req.onerror = function (e) {\n                reject(e.target.error);\n            };\n            req.onsuccess = function (e) {\n                let db = e.target.result;\n                // 监听连接意外关闭事件\n                db.onclose = function() {\n                    self._db = null;\n                };\n                // 监听版本变化事件（其他标签页升级了数据库）\n                db.onversionchange = function(event) {\n                    console.log('Database version changed, closing connection...');\n                    db.close();\n                    self._db = null;\n                };\n                self._db = db;\n                resolve(db);\n            };\n        });\n    }\n\n    /**\n     * 统一的 withTable 包装器 - 打开数据库执行操作\n     */\n    async withTable(tableName, callback) {\n        let db = await this.openDB();\n        return await callback(db);\n    }\n\n    async delData(tableName, keys) {\n        return this.withTable(tableName, async (db) => {\n            let tx = db.transaction(tableName, 'readwrite');\n            let store = tx.objectStore(tableName);\n            const store_delete = promisifyStore(store, 'delete');\n\n            for (let i = 0; i < keys.length; i++) {\n                await store_delete(keys[i]);\n            }\n        });\n    }\n\n    async readData(tableName, keys) {\n        return this.withTable(tableName, async (db) => {\n            let tx = db.transaction(tableName);\n            let store = tx.objectStore(tableName);\n            let store_get = promisifyStore(store, 'get');\n\n            let result = [];\n            for (let i = 0; i < keys.length; i++) {\n                let d = await store_get(keys[i]);\n                result.push(d.result);\n            }\n            return result;\n        });\n    }\n\n    async saveOrUpdate(tableName, dataList) {\n        return this.withTable(tableName, async (db) => {\n            let tx = db.transaction(tableName, 'readwrite');\n            let store = tx.objectStore(tableName);\n            const store_put = promisifyStore(store, 'put');\n            for (let i = 0; i < dataList.length; i++) {\n                await store_put(dataList[i]);\n            }\n        });\n    }\n\n    async addData(tableName, dataList) {\n        return this.withTable(tableName, async (db) => {\n            let tx = db.transaction(tableName, 'readwrite');\n            let store = tx.objectStore(tableName);\n            const store_add = promisifyStore(store, 'add');\n            for (let i = 0; i < dataList.length; i++) {\n                await store_add(dataList[i]);\n            }\n        });\n    }\n\n    async updateData(tableName, dataList) {\n        return this.withTable(tableName, async (db) => {\n            let tx = db.transaction(tableName, 'readwrite');\n            let store = tx.objectStore(tableName);\n            const store_put = promisifyStore(store, 'put');\n            for (let i = 0; i < dataList.length; i++) {\n                await store_put(dataList[i]);\n            }\n        });\n    }\n\n    async clearTable(tableName) {\n        return this.withTable(tableName, async (db) => {\n            let tx = db.transaction(tableName, 'readwrite');\n            let store = tx.objectStore(tableName);\n            const store_clear = promisifyStore(store, 'clear');\n            await store_clear();\n        });\n    }\n\n}\n\nexport { TinyIndexDB };\n","import { TinyIndexDB } from './TinyIndexDB.js';\n\n/**\n * IndexDBStorage - 单表存储封装\n * 自动初始化表，提供 CRUD 操作\n */\nclass IndexDBStorage {\n\n    constructor(dbName, tableName) {\n        this.dbName = dbName;\n        this.tableName = tableName;\n        this.isInited = false;\n\n        // 直接使用 TinyIndexDB，版本号自动获取\n        this.tinyIndexDB = new TinyIndexDB(dbName, 'name');\n    }\n\n    /**\n     * 初始化表（如果不存在会自动创建）\n     */\n    async init() {\n        if (this.isInited) {\n            return;\n        }\n\n        // 初始化表配置\n        const tablesConfig = {\n            [this.tableName]: [\n                ['name', true],\n                ['data', false]\n            ]\n        };\n\n        await this.tinyIndexDB.initDB(tablesConfig);\n        this.isInited = true;\n    }\n\n    async saveItem(name, data) {\n        await this.init();\n        await this.tinyIndexDB.saveOrUpdate(this.tableName, [{name: name, data: data}]);\n    }\n\n    async addItem(name, data) {\n        await this.init();\n        await this.tinyIndexDB.addData(this.tableName, [{name: name, data: data}]);\n    }\n\n    async updateItem(name, data) {\n        await this.init();\n        await this.tinyIndexDB.updateData(this.tableName, [{name: name, data: data}]);\n    }\n\n    async deleteItem(name) {\n        await this.init();\n        await this.tinyIndexDB.delData(this.tableName, [name]);\n    }\n\n    async clear() {\n        await this.init();\n        await this.tinyIndexDB.clearTable(this.tableName);\n    }\n\n    async getItem(name) {\n        await this.init();\n        try {\n            let values = await this.tinyIndexDB.readData(this.tableName, [name]);\n            let value0 = values[0];\n            return value0 && value0.data;\n        } catch (e) {\n            console.log(e);\n            return null;\n        }\n    }\n}\n\nexport { IndexDBStorage };\n","import { TinyIndexDB } from './TinyIndexDB.js';\nimport { IndexDBStorage } from './IndexDBStorage.js';\n\n/**\n * IndexDBStorageFactory - IndexedDB 存储工厂\n * 全局缓存 storage 实例，以 dbName + tableName 为维度\n */\nclass IndexDBStorageFactory {\n\n    // 全局缓存：{ 'dbName:tableName': IndexDBStorage }\n    static _storageCache = new Map();\n\n    // 全局缓存：{ 'dbName': TinyIndexDB }\n    static _tinyIndexDBCache = new Map();\n\n    /**\n     * 获取或创建 storage 实例\n     * @param {string} dbName - 数据库名\n     * @param {string} tableName - 表名\n     * @returns {IndexDBStorage}\n     */\n    static getStorage(dbName, tableName) {\n        const cacheKey = `${dbName}:${tableName}`;\n\n        // 从缓存获取\n        if (this._storageCache.has(cacheKey)) {\n            return this._storageCache.get(cacheKey);\n        }\n\n        // 创建新实例\n        const storage = new IndexDBStorage(dbName, tableName);\n        this._storageCache.set(cacheKey, storage);\n\n        return storage;\n    }\n\n    /**\n     * 获取或创建 TinyIndexDB 实例\n     * @param {string} dbName - 数据库名\n     * @returns {TinyIndexDB}\n     */\n    static getTinyIndexDB(dbName) {\n        if (this._tinyIndexDBCache.has(dbName)) {\n            return this._tinyIndexDBCache.get(dbName);\n        }\n\n        const tinyIndexDB = new TinyIndexDB(dbName, 'name');\n        this._tinyIndexDBCache.set(dbName, tinyIndexDB);\n\n        return tinyIndexDB;\n    }\n\n    /**\n     * 清除指定缓存\n     * @param {string} dbName - 数据库名\n     * @param {string} tableName - 表名（可选，不传则清除整个数据库缓存）\n     */\n    static clearCache(dbName, tableName) {\n        if (tableName) {\n            this._storageCache.delete(`${dbName}:${tableName}`);\n        } else {\n            // 清除该数据库的所有表缓存\n            for (const key of this._storageCache.keys()) {\n                if (key.startsWith(`${dbName}:`)) {\n                    this._storageCache.delete(key);\n                }\n            }\n            this._tinyIndexDBCache.delete(dbName);\n        }\n    }\n\n    /**\n     * 清除所有缓存\n     */\n    static clearAllCache() {\n        this._storageCache.clear();\n        this._tinyIndexDBCache.clear();\n    }\n\n}\n\nexport { IndexDBStorageFactory };\n","import { IndexDBStorageFactory } from './IndexDBStorageFactory.js';\n\n/**\n * SimpleIndexDBStorage - 带内存缓存的单表存储封装\n * 读取优先从内存获取，写入同时更新内存和 IndexedDB\n */\nclass SimpleIndexDBStorage {\n\n    constructor(dbName, tableName) {\n        this.dbName = dbName || 'linushp_default';\n        this.tableName = tableName || 'linushp_t';\n        // 内存缓存\n        this._memoryCache = new Map();\n        // 使用工厂获取缓存的 storage 实例\n        this._storage = null;\n    }\n\n    // 延迟获取 storage 实例\n    _getStorage() {\n        if (!this._storage) {\n            this._storage = IndexDBStorageFactory.getStorage(this.dbName, this.tableName);\n        }\n        return this._storage;\n    }\n\n    async saveItem(name, data) {\n        // 先更新内存\n        this._memoryCache.set(name, data);\n        // 再持久化到 IndexedDB\n        return this._getStorage().saveItem(name, data);\n    }\n\n    async getItem(name) {\n        // 先查内存缓存\n        if (this._memoryCache.has(name)) {\n            return this._memoryCache.get(name);\n        }\n        // 内存没有，查 IndexedDB\n        const data = await this._getStorage().getItem(name);\n        // 写入内存缓存\n        if (data !== null && data !== undefined) {\n            this._memoryCache.set(name, data);\n        }\n        return data;\n    }\n\n    async deleteItem(name) {\n        // 先删除内存\n        this._memoryCache.delete(name);\n        // 再删除 IndexedDB\n        return this._getStorage().deleteItem(name);\n    }\n\n    async clear() {\n        // 清空内存\n        this._memoryCache.clear();\n        // 清空 IndexedDB\n        return this._getStorage().clear();\n    }\n\n    /**\n     * 获取内存缓存统计\n     */\n    getMemoryCacheSize() {\n        return this._memoryCache.size;\n    }\n\n    /**\n     * 清空内存缓存（不影响 IndexedDB）\n     */\n    clearMemoryCache() {\n        this._memoryCache.clear();\n    }\n\n}\n\nexport { SimpleIndexDBStorage };\n","import { SimpleIndexDBStorage } from './SimpleIndexDBStorage.js';\n\n/**\n * IndexedDBCachedFetch - 基于 IndexedDB 的缓存 Fetch\n * 将网络请求结果缓存到 IndexedDB 中\n */\nclass IndexedDBCachedFetch {\n\n    constructor(dbName, tableName) {\n        this.indexDbStorage = new SimpleIndexDBStorage(dbName, tableName);\n    }\n\n    fetchJson(url, converter) {\n        return this.fetch(url, 'json', converter);\n    }\n\n    fetchArrayBuffer(url, converter) {\n        return this.fetch(url, 'arrayBuffer', converter);\n    }\n\n    fetchBlob(url, converter) {\n        return this.fetch(url, 'blob', converter);\n    }\n\n    fetchText(url, converter) {\n        return this.fetch(url, 'text', converter);\n    }\n\n    async fetch(url, responseType, converter) {\n        let cached = await this.indexDbStorage.getItem(url);\n        if (!cached) {\n            let fetchd = await fetch(url);\n            if (responseType === 'arrayBuffer') {\n                cached = await fetchd.arrayBuffer();\n            } else if (responseType === 'json') {\n                cached = await fetchd.json();\n            } else if (responseType === 'blob') {\n                cached = await fetchd.blob();\n            } else if (responseType === 'text') {\n                cached = await fetchd.text();\n            } else {\n                cached = null;\n                console.error(\"responseType error\");\n            }\n\n            if (converter) {\n                cached = await converter(cached);\n            }\n\n            await this.indexDbStorage.saveItem(url, cached);\n        }\n        return cached;\n    }\n}\n\nexport { IndexedDBCachedFetch };\n"],"names":["__webpack_require__","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","promisifyStore","store","method","args","Promise","resolve","reject","func","bind","req","onsuccess","onerror","e","TinyIndexDB","constructor","dbName","keyPath","indexDbApi","window","indexedDB","webkitIndexedDB","msIndexedDB","mozIndexedDB","this","dbV","tablesConfig","_db","_ensureDbVersion","undefined","_getCurrentVersion","initDB","tables","tableNames","keys","db","_openDBInternal","missingTables","filter","name","objectStoreNames","contains","length","console","log","join","close","_openDBAndCreateTables","err","actualVersion","self","_doOpenRaw","open","target","error","result","onblocked","warn","version","_doOpenAndCreate","tableIndexes","values","onupgradeneeded","i","createObjectStore","autoIncrement","j","createIndex","unique","openDB","closed","_doOpenDB","onclose","onversionchange","event","withTable","tableName","callback","delData","async","store_delete","transaction","objectStore","readData","store_get","d","push","saveOrUpdate","dataList","store_put","addData","store_add","updateData","clearTable","store_clear","IndexDBStorage","isInited","tinyIndexDB","init","saveItem","data","addItem","updateItem","deleteItem","clear","getItem","value0","IndexDBStorageFactory","static","Map","getStorage","cacheKey","_storageCache","has","storage","set","getTinyIndexDB","_tinyIndexDBCache","clearCache","delete","startsWith","clearAllCache","SimpleIndexDBStorage","_memoryCache","_storage","_getStorage","getMemoryCacheSize","size","clearMemoryCache","IndexedDBCachedFetch","indexDbStorage","fetchJson","url","converter","fetch","fetchArrayBuffer","fetchBlob","fetchText","responseType","cached","fetchd","arrayBuffer","json","blob","text"],"sourceRoot":""}

package/index.d.ts

@@ -0,0 +1,236 @@
+/**
+ * IndexedDB Cached XHR - TypeScript 定义文件
+ * 轻量级 IndexedDB 封装库，提供表管理、CRUD 操作和 HTTP 请求缓存功能
+ */
+
+// ============================================
+// TinyIndexDB - 底层 IndexedDB 封装
+// ============================================
+
+export interface TableConfig {
+  [tableName: string]: Array<[string, boolean]>;
+}
+
+export interface TableCallback<T> {
+  (db: IDBDatabase): Promise<T>;
+}
+
+export declare class TinyIndexDB {
+  dbName: string;
+  dbV: number | undefined;
+  keyPath: string;
+  tablesConfig: TableConfig | null;
+
+  constructor(dbName: string, keyPath: string, dbV?: number);
+
+  /**
+   * 初始化数据库，自动创建缺失的表
+   * @param tables - 表配置 { tableName: [['indexName', unique], ...] }
+   */
+  initDB(tables: TableConfig): Promise<IDBDatabase>;
+
+  /**
+   * 打开数据库连接（带缓存）
+   */
+  openDB(): Promise<IDBDatabase>;
+
+  /**
+   * 统一的 withTable 包装器 - 打开数据库执行操作
+   */
+  withTable<T>(tableName: string, callback: TableCallback<T>): Promise<T>;
+
+  /**
+   * 删除数据
+   */
+  delData(tableName: string, keys: string[]): Promise<void>;
+
+  /**
+   * 读取数据
+   */
+  readData(tableName: string, keys: string[]): Promise<{ data: any }[]>;
+
+  /**
+   * 保存或更新数据（不存在则新增，存在则更新）
+   */
+  saveOrUpdate(tableName: string, dataList: any[]): Promise<void>;
+
+  /**
+   * 新增数据
+   */
+  addData(tableName: string, dataList: any[]): Promise<void>;
+
+  /**
+   * 更新数据
+   */
+  updateData(tableName: string, dataList: any[]): Promise<void>;
+
+  /**
+   * 清空表
+   */
+  clearTable(tableName: string): Promise<void>;
+}
+
+// ============================================
+// IndexDBStorageFactory - 工厂模式
+// ============================================
+
+export declare class IndexDBStorageFactory {
+  /**
+   * 获取或创建 storage 实例（全局缓存）
+   * @param dbName - 数据库名
+   * @param tableName - 表名
+   */
+  static getStorage(dbName: string, tableName: string): IndexDBStorage;
+
+  /**
+   * 获取或创建 TinyIndexDB 实例（全局缓存）
+   * @param dbName - 数据库名
+   */
+  static getTinyIndexDB(dbName: string): TinyIndexDB;
+
+  /**
+   * 清除指定缓存
+   * @param dbName - 数据库名
+   * @param tableName - 表名（可选，不传则清除整个数据库缓存）
+   */
+  static clearCache(dbName: string, tableName?: string): void;
+
+  /**
+   * 清除所有缓存
+   */
+  static clearAllCache(): void;
+}
+
+// ============================================
+// IndexDBStorage - 单表存储封装
+// ============================================
+
+export declare class IndexDBStorage {
+  dbName: string;
+  tableName: string;
+  tinyIndexDB: TinyIndexDB;
+
+  constructor(dbName: string, tableName: string);
+
+  /**
+   * 初始化表（如果不存在会自动创建）
+   */
+  init(): Promise<void>;
+
+  /**
+   * 保存或更新条目
+   */
+  saveItem(name: string, data: any): Promise<void>;
+
+  /**
+   * 新增条目
+   */
+  addItem(name: string, data: any): Promise<void>;
+
+  /**
+   * 更新条目
+   */
+  updateItem(name: string, data: any): Promise<void>;
+
+  /**
+   * 删除条目
+   */
+  deleteItem(name: string): Promise<void>;
+
+  /**
+   * 清空表
+   */
+  clear(): Promise<void>;
+
+  /**
+   * 获取条目
+   */
+  getItem(name: string): Promise<any>;
+}
+
+// ============================================
+// SimpleIndexDBStorage - 简化版单表存储
+// ============================================
+
+export declare class SimpleIndexDBStorage {
+  dbName: string;
+  tableName: string;
+
+  constructor(dbName?: string, tableName?: string);
+
+  /**
+   * 保存条目
+   */
+  saveItem(name: string, data: any): Promise<void>;
+
+  /**
+   * 获取条目
+   */
+  getItem(name: string): Promise<any>;
+
+  /**
+   * 删除条目
+   */
+  deleteItem(name: string): Promise<void>;
+
+  /**
+   * 清空表
+   */
+  clear(): Promise<void>;
+}
+
+// ============================================
+// IndexedDBCachedFetch - 缓存 Fetch
+// ============================================
+
+export type ResponseType = 'json' | 'text' | 'arrayBuffer' | 'blob';
+
+export type Converter<T> = (data: any) => T | Promise<T>;
+
+export declare class IndexedDBCachedFetch {
+  indexDbStorage: SimpleIndexDBStorage;
+
+  constructor(dbName: string, tableName: string);
+
+  /**
+   * 获取 JSON 数据（带缓存）
+   * @param url - 请求地址
+   * @param converter - 可选的数据转换函数
+   */
+  fetchJson<T = any>(url: string, converter?: Converter<T>): Promise<T>;
+
+  /**
+   * 获取 ArrayBuffer 数据（带缓存）
+   * @param url - 请求地址
+   * @param converter - 可选的数据转换函数
+   */
+  fetchArrayBuffer<T = ArrayBuffer>(url: string, converter?: Converter<T>): Promise<T>;
+
+  /**
+   * 获取 Blob 数据（带缓存）
+   * @param url - 请求地址
+   * @param converter - 可选的数据转换函数
+   */
+  fetchBlob<T = Blob>(url: string, converter?: Converter<T>): Promise<T>;
+
+  /**
+   * 获取文本数据（带缓存）
+   * @param url - 请求地址
+   * @param converter - 可选的数据转换函数
+   */
+  fetchText<T = string>(url: string, converter?: Converter<T>): Promise<T>;
+
+  /**
+   * 通用的 fetch 方法（带缓存）
+   * @param url - 请求地址
+   * @param responseType - 响应类型
+   * @param converter - 可选的数据转换函数
+   */
+  fetch<T = any>(url: string, responseType: ResponseType, converter?: Converter<T>): Promise<T>;
+}
+
+// ============================================
+// 默认导出
+// ============================================
+
+export default SimpleIndexDBStorage;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "indexeddb-keyvalue",
+  "version": "1.0.7",
+  "description": "Lightweight IndexedDB wrapper with table management, CRUD operations, and HTTP request caching",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "files": [
+    "dist/",
+    "src/",
+    "index.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "webpack serve --mode development",
+    "build": "rm -rf dist/ && webpack --mode production",
+    "build:dev": "webpack --mode development"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/linushp/indexdb-cached-xhr.git"
+  },
+  "keywords": [
+    "indexeddb",
+    "cache",
+    "storage",
+    "browser",
+    "fetch",
+    "xhr",
+    "localstorage",
+    "database"
+  ],
+  "author": "linushp",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/linushp/indexdb-cached-xhr/issues"
+  },
+  "homepage": "https://github.com/linushp/indexdb-cached-xhr#readme",
+  "devDependencies": {
+    "webpack": "^5.90.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^5.0.4"
+  }
+}

package/src/IndexDBStorage.js

@@ -0,0 +1,76 @@
+import { TinyIndexDB } from './TinyIndexDB.js';
+
+/**
+ * IndexDBStorage - 单表存储封装
+ * 自动初始化表，提供 CRUD 操作
+ */
+class IndexDBStorage {
+
+    constructor(dbName, tableName) {
+        this.dbName = dbName;
+        this.tableName = tableName;
+        this.isInited = false;
+
+        // 直接使用 TinyIndexDB，版本号自动获取
+        this.tinyIndexDB = new TinyIndexDB(dbName, 'name');
+    }
+
+    /**
+     * 初始化表（如果不存在会自动创建）
+     */
+    async init() {
+        if (this.isInited) {
+            return;
+        }
+
+        // 初始化表配置
+        const tablesConfig = {
+            [this.tableName]: [
+                ['name', true],
+                ['data', false]
+            ]
+        };
+
+        await this.tinyIndexDB.initDB(tablesConfig);
+        this.isInited = true;
+    }
+
+    async saveItem(name, data) {
+        await this.init();
+        await this.tinyIndexDB.saveOrUpdate(this.tableName, [{name: name, data: data}]);
+    }
+
+    async addItem(name, data) {
+        await this.init();
+        await this.tinyIndexDB.addData(this.tableName, [{name: name, data: data}]);
+    }
+
+    async updateItem(name, data) {
+        await this.init();
+        await this.tinyIndexDB.updateData(this.tableName, [{name: name, data: data}]);
+    }
+
+    async deleteItem(name) {
+        await this.init();
+        await this.tinyIndexDB.delData(this.tableName, [name]);
+    }
+
+    async clear() {
+        await this.init();
+        await this.tinyIndexDB.clearTable(this.tableName);
+    }
+
+    async getItem(name) {
+        await this.init();
+        try {
+            let values = await this.tinyIndexDB.readData(this.tableName, [name]);
+            let value0 = values[0];
+            return value0 && value0.data;
+        } catch (e) {
+            console.log(e);
+            return null;
+        }
+    }
+}
+
+export { IndexDBStorage };

package/src/IndexDBStorageFactory.js

@@ -0,0 +1,82 @@
+import { TinyIndexDB } from './TinyIndexDB.js';
+import { IndexDBStorage } from './IndexDBStorage.js';
+
+/**
+ * IndexDBStorageFactory - IndexedDB 存储工厂
+ * 全局缓存 storage 实例，以 dbName + tableName 为维度
+ */
+class IndexDBStorageFactory {
+
+    // 全局缓存：{ 'dbName:tableName': IndexDBStorage }
+    static _storageCache = new Map();
+
+    // 全局缓存：{ 'dbName': TinyIndexDB }
+    static _tinyIndexDBCache = new Map();
+
+    /**
+     * 获取或创建 storage 实例
+     * @param {string} dbName - 数据库名
+     * @param {string} tableName - 表名
+     * @returns {IndexDBStorage}
+     */
+    static getStorage(dbName, tableName) {
+        const cacheKey = `${dbName}:${tableName}`;
+
+        // 从缓存获取
+        if (this._storageCache.has(cacheKey)) {
+            return this._storageCache.get(cacheKey);
+        }
+
+        // 创建新实例
+        const storage = new IndexDBStorage(dbName, tableName);
+        this._storageCache.set(cacheKey, storage);
+
+        return storage;
+    }
+
+    /**
+     * 获取或创建 TinyIndexDB 实例
+     * @param {string} dbName - 数据库名
+     * @returns {TinyIndexDB}
+     */
+    static getTinyIndexDB(dbName) {
+        if (this._tinyIndexDBCache.has(dbName)) {
+            return this._tinyIndexDBCache.get(dbName);
+        }
+
+        const tinyIndexDB = new TinyIndexDB(dbName, 'name');
+        this._tinyIndexDBCache.set(dbName, tinyIndexDB);
+
+        return tinyIndexDB;
+    }
+
+    /**
+     * 清除指定缓存
+     * @param {string} dbName - 数据库名
+     * @param {string} tableName - 表名（可选，不传则清除整个数据库缓存）
+     */
+    static clearCache(dbName, tableName) {
+        if (tableName) {
+            this._storageCache.delete(`${dbName}:${tableName}`);
+        } else {
+            // 清除该数据库的所有表缓存
+            for (const key of this._storageCache.keys()) {
+                if (key.startsWith(`${dbName}:`)) {
+                    this._storageCache.delete(key);
+                }
+            }
+            this._tinyIndexDBCache.delete(dbName);
+        }
+    }
+
+    /**
+     * 清除所有缓存
+     */
+    static clearAllCache() {
+        this._storageCache.clear();
+        this._tinyIndexDBCache.clear();
+    }
+
+}
+
+export { IndexDBStorageFactory };

package/src/IndexedDBCachedFetch.js

@@ -0,0 +1,56 @@
+import { SimpleIndexDBStorage } from './SimpleIndexDBStorage.js';
+
+/**
+ * IndexedDBCachedFetch - 基于 IndexedDB 的缓存 Fetch
+ * 将网络请求结果缓存到 IndexedDB 中
+ */
+class IndexedDBCachedFetch {
+
+    constructor(dbName, tableName) {
+        this.indexDbStorage = new SimpleIndexDBStorage(dbName, tableName);
+    }
+
+    fetchJson(url, converter) {
+        return this.fetch(url, 'json', converter);
+    }
+
+    fetchArrayBuffer(url, converter) {
+        return this.fetch(url, 'arrayBuffer', converter);
+    }
+
+    fetchBlob(url, converter) {
+        return this.fetch(url, 'blob', converter);
+    }
+
+    fetchText(url, converter) {
+        return this.fetch(url, 'text', converter);
+    }
+
+    async fetch(url, responseType, converter) {
+        let cached = await this.indexDbStorage.getItem(url);
+        if (!cached) {
+            let fetchd = await fetch(url);
+            if (responseType === 'arrayBuffer') {
+                cached = await fetchd.arrayBuffer();
+            } else if (responseType === 'json') {
+                cached = await fetchd.json();
+            } else if (responseType === 'blob') {
+                cached = await fetchd.blob();
+            } else if (responseType === 'text') {
+                cached = await fetchd.text();
+            } else {
+                cached = null;
+                console.error("responseType error");
+            }
+
+            if (converter) {
+                cached = await converter(cached);
+            }
+
+            await this.indexDbStorage.saveItem(url, cached);
+        }
+        return cached;
+    }
+}
+
+export { IndexedDBCachedFetch };

package/src/SimpleIndexDBStorage.js

@@ -0,0 +1,77 @@
+import { IndexDBStorageFactory } from './IndexDBStorageFactory.js';
+
+/**
+ * SimpleIndexDBStorage - 带内存缓存的单表存储封装
+ * 读取优先从内存获取，写入同时更新内存和 IndexedDB
+ */
+class SimpleIndexDBStorage {
+
+    constructor(dbName, tableName) {
+        this.dbName = dbName || 'linushp_default';
+        this.tableName = tableName || 'linushp_t';
+        // 内存缓存
+        this._memoryCache = new Map();
+        // 使用工厂获取缓存的 storage 实例
+        this._storage = null;
+    }
+
+    // 延迟获取 storage 实例
+    _getStorage() {
+        if (!this._storage) {
+            this._storage = IndexDBStorageFactory.getStorage(this.dbName, this.tableName);
+        }
+        return this._storage;
+    }
+
+    async saveItem(name, data) {
+        // 先更新内存
+        this._memoryCache.set(name, data);
+        // 再持久化到 IndexedDB
+        return this._getStorage().saveItem(name, data);
+    }
+
+    async getItem(name) {
+        // 先查内存缓存
+        if (this._memoryCache.has(name)) {
+            return this._memoryCache.get(name);
+        }
+        // 内存没有，查 IndexedDB
+        const data = await this._getStorage().getItem(name);
+        // 写入内存缓存
+        if (data !== null && data !== undefined) {
+            this._memoryCache.set(name, data);
+        }
+        return data;
+    }
+
+    async deleteItem(name) {
+        // 先删除内存
+        this._memoryCache.delete(name);
+        // 再删除 IndexedDB
+        return this._getStorage().deleteItem(name);
+    }
+
+    async clear() {
+        // 清空内存
+        this._memoryCache.clear();
+        // 清空 IndexedDB
+        return this._getStorage().clear();
+    }
+
+    /**
+     * 获取内存缓存统计
+     */
+    getMemoryCacheSize() {
+        return this._memoryCache.size;
+    }
+
+    /**
+     * 清空内存缓存（不影响 IndexedDB）
+     */
+    clearMemoryCache() {
+        this._memoryCache.clear();
+    }
+
+}
+
+export { SimpleIndexDBStorage };

package/src/TinyIndexDB.js

@@ -0,0 +1,317 @@
+import { promisifyStore } from './utils/promisifyStore.js';
+
+/**
+ * TinyIndexDB - IndexedDB 的轻量级封装
+ * 提供数据库初始化、连接缓存、CRUD 操作
+ */
+class TinyIndexDB {
+
+    constructor(dbName, keyPath) {
+        const indexDbApi = window.indexedDB || window.webkitIndexedDB || window.msIndexedDB || window.mozIndexedDB;
+        this.dbName = dbName;
+        this.dbV = null;  // dbV不需要外面传，内部自动获取
+        this.indexDbApi = indexDbApi;
+        this.keyPath = keyPath;
+        this.tablesConfig = null;
+        this._db = null;  // 缓存的数据库连接
+    }
+
+    /**
+     * 确保 dbV 已设置，未设置时自动获取当前版本
+     */
+    async _ensureDbVersion() {
+        if (this.dbV === undefined || this.dbV === null) {
+            this.dbV = await this._getCurrentVersion();
+        }
+    }
+
+    /**
+     * 初始化数据库，创建缺失的表
+     * @param {Object} tables - 表配置 { tableName: [['indexName', unique], ...] }
+     */
+    async initDB(tables) {
+        this.tablesConfig = { ...this.tablesConfig, ...tables };
+        let tableNames = Object.keys(tables);
+
+        // 确保版本号已设置
+        await this._ensureDbVersion();
+
+        // 先打开数据库检查表是否存在
+        let db = await this._openDBInternal();
+
+        // 检查是否所有表都存在
+        let missingTables = tableNames.filter(name => !db.objectStoreNames.contains(name));
+
+        if (missingTables.length > 0) {
+            // 有表不存在，需要升级版本号创建
+            console.log('Missing tables:', missingTables.join(', '));
+            db.close();
+
+            // 关闭缓存的连接，否则升级版本时会被阻塞
+            if (this._db) {
+                this._db.close();
+            }
+            this._db = null;
+
+            // 升级版本号并重新打开
+            this.dbV += 1;
+            try {
+                db = await this._openDBAndCreateTables(tables);
+            } catch (err) {
+                // 如果版本已被其他实例升级，重新获取当前版本
+                if (err && err.name === 'VersionError') {
+                    console.log('Version conflict during table creation, retrying...');
+                    const actualVersion = await this._getCurrentVersion();
+                    this.dbV = actualVersion;
+                    // 重新检查表是否存在
+                    db = await this._openDBInternal();
+                    let stillMissing = tableNames.filter(name => !db.objectStoreNames.contains(name));
+                    if (stillMissing.length > 0) {
+                        // 还是需要创建表，再升级一次版本
+                        this.dbV += 1;
+                        db.close();
+                        db = await this._openDBAndCreateTables(tables);
+                    }
+                } else {
+                    throw err;
+                }
+            }
+        }
+
+        this._db = db;
+        return db;
+    }
+
+    async _openDBInternal() {
+        let self = this;
+
+        try {
+            return await this._doOpenRaw();
+        } catch (err) {
+            // 如果版本号过低，获取当前版本并重试
+            if (err && err.name === 'VersionError') {
+                console.log(`VersionError: requested ${self.dbV}, getting actual version...`);
+                const actualVersion = await self._getCurrentVersion();
+                self.dbV = actualVersion;
+                return this._doOpenRaw();
+            }
+            throw err;
+        }
+    }
+
+    _doOpenRaw() {
+        let self = this;
+        return new Promise((resolve, reject) => {
+            let req = self.indexDbApi.open(self.dbName, self.dbV);
+            req.onerror = function (e) {
+                reject(e.target.error);
+            };
+            req.onsuccess = function (e) {
+                resolve(e.target.result);
+            };
+            req.onblocked = function (e) {
+                console.warn('Database open blocked, waiting for other connections to close...');
+            };
+        });
+    }
+
+    /**
+     * 获取数据库当前版本（不传版本号打开）
+     */
+    _getCurrentVersion() {
+        let self = this;
+        return new Promise((resolve, reject) => {
+            // 不传版本号，获取当前版本
+            let req = self.indexDbApi.open(self.dbName);
+            req.onsuccess = function (e) {
+                let db = e.target.result;
+                let version = db.version;
+                db.close();
+                console.log(`Current database version: ${version}`);
+                resolve(version);
+            };
+            req.onerror = function (e) {
+                reject(req.error);
+            };
+        });
+    }
+
+    async _openDBAndCreateTables(tables) {
+        let self = this;
+
+        try {
+            return await this._doOpenAndCreate(tables);
+        } catch (err) {
+            // 如果版本号过低，获取当前版本并更新后再试
+            if (err && err.name === 'VersionError') {
+                console.log(`VersionError in _openDBAndCreateTables: requested ${self.dbV}, getting actual version...`);
+                const actualVersion = await self._getCurrentVersion();
+                self.dbV = actualVersion;
+                return this._doOpenAndCreate(tables);
+            }
+            throw err;
+        }
+    }
+
+    _doOpenAndCreate(tables) {
+        let self = this;
+        let tableNames = Object.keys(tables);
+        let tableIndexes = Object.values(tables);
+
+        return new Promise((resolve, reject) => {
+            let req = self.indexDbApi.open(self.dbName, self.dbV);
+            req.onerror = function (e) {
+                reject(e.target.error);
+            };
+            req.onsuccess = function (e) {
+                resolve(e.target.result);
+            };
+            req.onupgradeneeded = function (e) {
+                let db = e.target.result;
+                let store;
+                for (let i = 0; i < tableNames.length; i++) {
+                    if (!db.objectStoreNames.contains(tableNames[i])) {
+                        store = db.createObjectStore(tableNames[i], {keyPath: self.keyPath, autoIncrement: false});
+                        console.log('TABLE ' + tableNames[i] + ' created Success');
+                        for (let j = 0; j < tableIndexes[i].length; j++) {
+                            store.createIndex(tableIndexes[i][j][0], tableIndexes[i][j][0], {unique: tableIndexes[i][j][1]});
+                        }
+                    }
+                }
+            };
+        });
+    }
+
+    /**
+     * 打开数据库连接（带缓存）
+     */
+    async openDB() {
+        let self = this;
+
+        // 如果已有连接且未关闭，直接返回
+        if (this._db && !this._db.closed) {
+            return this._db;
+        }
+
+        // 确保版本号已设置
+        await this._ensureDbVersion();
+
+        try {
+            return await this._doOpenDB();
+        } catch (err) {
+            // 如果版本号过低，获取当前版本并重试
+            if (err.name === 'VersionError') {
+                console.log(`VersionError in openDB: requested ${self.dbV}, getting actual version...`);
+                const actualVersion = await self._getCurrentVersion();
+                self.dbV = actualVersion;
+                return this._doOpenDB();
+            }
+            throw err;
+        }
+    }
+
+    _doOpenDB() {
+        let self = this;
+        return new Promise((resolve, reject) => {
+            let req = self.indexDbApi.open(self.dbName, self.dbV);
+            req.onerror = function (e) {
+                reject(e.target.error);
+            };
+            req.onsuccess = function (e) {
+                let db = e.target.result;
+                // 监听连接意外关闭事件
+                db.onclose = function() {
+                    self._db = null;
+                };
+                // 监听版本变化事件（其他标签页升级了数据库）
+                db.onversionchange = function(event) {
+                    console.log('Database version changed, closing connection...');
+                    db.close();
+                    self._db = null;
+                };
+                self._db = db;
+                resolve(db);
+            };
+        });
+    }
+
+    /**
+     * 统一的 withTable 包装器 - 打开数据库执行操作
+     */
+    async withTable(tableName, callback) {
+        let db = await this.openDB();
+        return await callback(db);
+    }
+
+    async delData(tableName, keys) {
+        return this.withTable(tableName, async (db) => {
+            let tx = db.transaction(tableName, 'readwrite');
+            let store = tx.objectStore(tableName);
+            const store_delete = promisifyStore(store, 'delete');
+
+            for (let i = 0; i < keys.length; i++) {
+                await store_delete(keys[i]);
+            }
+        });
+    }
+
+    async readData(tableName, keys) {
+        return this.withTable(tableName, async (db) => {
+            let tx = db.transaction(tableName);
+            let store = tx.objectStore(tableName);
+            let store_get = promisifyStore(store, 'get');
+
+            let result = [];
+            for (let i = 0; i < keys.length; i++) {
+                let d = await store_get(keys[i]);
+                result.push(d.result);
+            }
+            return result;
+        });
+    }
+
+    async saveOrUpdate(tableName, dataList) {
+        return this.withTable(tableName, async (db) => {
+            let tx = db.transaction(tableName, 'readwrite');
+            let store = tx.objectStore(tableName);
+            const store_put = promisifyStore(store, 'put');
+            for (let i = 0; i < dataList.length; i++) {
+                await store_put(dataList[i]);
+            }
+        });
+    }
+
+    async addData(tableName, dataList) {
+        return this.withTable(tableName, async (db) => {
+            let tx = db.transaction(tableName, 'readwrite');
+            let store = tx.objectStore(tableName);
+            const store_add = promisifyStore(store, 'add');
+            for (let i = 0; i < dataList.length; i++) {
+                await store_add(dataList[i]);
+            }
+        });
+    }
+
+    async updateData(tableName, dataList) {
+        return this.withTable(tableName, async (db) => {
+            let tx = db.transaction(tableName, 'readwrite');
+            let store = tx.objectStore(tableName);
+            const store_put = promisifyStore(store, 'put');
+            for (let i = 0; i < dataList.length; i++) {
+                await store_put(dataList[i]);
+            }
+        });
+    }
+
+    async clearTable(tableName) {
+        return this.withTable(tableName, async (db) => {
+            let tx = db.transaction(tableName, 'readwrite');
+            let store = tx.objectStore(tableName);
+            const store_clear = promisifyStore(store, 'clear');
+            await store_clear();
+        });
+    }
+
+}
+
+export { TinyIndexDB };

package/src/index.js

@@ -0,0 +1,14 @@
+import { TinyIndexDB } from './TinyIndexDB.js';
+import { IndexDBStorage } from './IndexDBStorage.js';
+import { IndexDBStorageFactory } from './IndexDBStorageFactory.js';
+import { SimpleIndexDBStorage } from './SimpleIndexDBStorage.js';
+import { IndexedDBCachedFetch } from './IndexedDBCachedFetch.js';
+
+export {
+    SimpleIndexDBStorage as default,
+    IndexedDBCachedFetch,
+    SimpleIndexDBStorage,
+    IndexDBStorage,
+    IndexDBStorageFactory,
+    TinyIndexDB
+};

package/src/utils/promisifyStore.js

@@ -0,0 +1,23 @@
+/**
+ * 将 IndexedDB object store 方法 Promise 化
+ * @param {IDBObjectStore} store - IndexedDB object store
+ * @param {string} method - 方法名 (get, put, add, delete, clear 等)
+ * @returns {Function} 返回一个 Promise 化的函数
+ */
+function promisifyStore(store, method) {
+    return function (...args) {
+        return new Promise(function (resolve, reject) {
+            let func = store[method];
+            func = func.bind(store);
+            let req = func(...args);
+            req.onsuccess = function () {
+                resolve(req);
+            };
+            req.onerror = function (e) {
+                reject(e);
+            };
+        });
+    };
+}
+
+export { promisifyStore };