项目初始化

gaoluyang

2026-06-24 c0cb161bb52ce0fbdce5c66ec391d107c75e2452

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import type { IStorageDriver } from './types';
 
interface IndexedDBDriverOptions {
  /** 数据库名称 */
  dbName?: string;
  /** 数据库版本 */
  dbVersion?: number;
  /** 对象存储名称 */
  storeName?: string;
}
 
/**
 * IndexedDB 驱动
 * 采用懒初始化模式，首次操作时自动打开数据库
 */
class IndexedDBDriver implements IStorageDriver {
  private dbName: string;
  private dbPromise: null | Promise<IDBDatabase> = null;
  private dbVersion: number;
  private storeName: string;
 
  constructor({
    dbName = 'vben-storage',
    dbVersion = 1,
    storeName = 'kv-store',
  }: IndexedDBDriverOptions = {}) {
    this.dbName = dbName;
    this.dbVersion = dbVersion;
    this.storeName = storeName;
  }
 
  async clear(): Promise<void> {
    const db = await this.getDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(this.storeName, 'readwrite');
      const store = tx.objectStore(this.storeName);
      store.clear();
 
      tx.addEventListener('complete', () => resolve());
      tx.addEventListener('error', () => reject(tx.error));
      tx.addEventListener('abort', () =>
        reject(tx.error ?? new Error('Transaction aborted')),
      );
    });
  }
 
  async getItem<T>(key: string): Promise<null | T> {
    const db = await this.getDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(this.storeName, 'readonly');
      const store = tx.objectStore(this.storeName);
      const request = store.get(key);
 
      request.addEventListener('success', () =>
        resolve(request.result ?? null),
      );
      request.addEventListener('error', () => reject(request.error));
    });
  }
 
  async keys(): Promise<string[]> {
    const db = await this.getDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(this.storeName, 'readonly');
      const store = tx.objectStore(this.storeName);
      const request = store.getAllKeys();
 
      request.addEventListener('success', () =>
        resolve(request.result.map(String)),
      );
      request.addEventListener('error', () => reject(request.error));
    });
  }
 
  async removeItem(key: string): Promise<void> {
    const db = await this.getDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(this.storeName, 'readwrite');
      const store = tx.objectStore(this.storeName);
      store.delete(key);
 
      tx.addEventListener('complete', () => resolve());
      tx.addEventListener('error', () => reject(tx.error));
      tx.addEventListener('abort', () =>
        reject(tx.error ?? new Error('Transaction aborted')),
      );
    });
  }
 
  async setItem(key: string, value: unknown): Promise<void> {
    const db = await this.getDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(this.storeName, 'readwrite');
      const store = tx.objectStore(this.storeName);
      store.put(value, key);
 
      tx.addEventListener('complete', () => resolve());
      tx.addEventListener('error', () => reject(tx.error));
      tx.addEventListener('abort', () =>
        reject(tx.error ?? new Error('Transaction aborted')),
      );
    });
  }
 
  /**
   * 懒初始化：首次调用时打开数据库，后续复用同一个 Promise
   */
  private getDB(): Promise<IDBDatabase> {
    if (!this.dbPromise) {
      this.dbPromise = this.openDB().catch((error) => {
        // allow retry on next call
        this.dbPromise = null;
        throw error;
      });
    }
    return this.dbPromise;
  }
 
  private openDB(): Promise<IDBDatabase> {
    return new Promise((resolve, reject) => {
      const request = indexedDB.open(this.dbName, this.dbVersion);
 
      request.addEventListener('upgradeneeded', () => {
        const db = request.result;
        if (!db.objectStoreNames.contains(this.storeName)) {
          db.createObjectStore(this.storeName);
        }
      });
 
      request.addEventListener('success', () => resolve(request.result));
      request.addEventListener('error', () => reject(request.error));
    });
  }
}
 
export { IndexedDBDriver };
export type { IndexedDBDriverOptions };