@midscene/shared 0.28.10-beta-20250922071252.0 → 0.28.10

package/dist/es/baseDB.mjs

@@ -0,0 +1,109 @@
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class IndexedDBManager {
+    initDB() {
+        return new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, this.version);
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve(request.result);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                this.storeConfigs.forEach(({ name, keyPath })=>{
+                    if (!db.objectStoreNames.contains(name)) {
+                        const store = db.createObjectStore(name, {
+                            keyPath
+                        });
+                        store.createIndex('timestamp', 'timestamp', {
+                            unique: false
+                        });
+                    }
+                });
+            };
+        });
+    }
+    async withTransaction(storeNames, mode, operation) {
+        const db = await this.dbPromise;
+        const transaction = db.transaction(storeNames, mode);
+        const stores = Array.isArray(storeNames) ? storeNames.map((name)=>transaction.objectStore(name)) : transaction.objectStore(storeNames);
+        return operation(stores);
+    }
+    promisifyRequest(request) {
+        return new Promise((resolve, reject)=>{
+            request.onsuccess = ()=>resolve(request.result);
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async put(storeName, data) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.put(data));
+        });
+    }
+    async get(storeName, key) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.get(key)));
+    }
+    async getAll(storeName, sortByTimestamp = true) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>{
+            const objectStore = store;
+            const results = sortByTimestamp ? await this.promisifyRequest(objectStore.index('timestamp').getAll()) : await this.promisifyRequest(objectStore.getAll());
+            return sortByTimestamp ? results.sort((a, b)=>a.timestamp - b.timestamp) : results;
+        });
+    }
+    async clear(storeName) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.clear());
+        });
+    }
+    async delete(storeName, key) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.delete(key));
+        });
+    }
+    async count(storeName) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.count()));
+    }
+    getDBPromise() {
+        return this.dbPromise;
+    }
+    constructor(dbName, version, storeConfigs){
+        _define_property(this, "dbPromise", void 0);
+        _define_property(this, "dbName", void 0);
+        _define_property(this, "version", void 0);
+        _define_property(this, "storeConfigs", void 0);
+        this.dbName = dbName;
+        this.version = version;
+        this.storeConfigs = storeConfigs;
+        this.dbPromise = this.initDB();
+    }
+}
+const withErrorHandling = async (operation, errorMessage, defaultValue, onQuotaExceeded)=>{
+    try {
+        return await operation();
+    } catch (e) {
+        console.error(errorMessage, e);
+        if (e instanceof Error && 'QuotaExceededError' === e.name && onQuotaExceeded) {
+            console.log('Storage quota exceeded, running cleanup...');
+            await onQuotaExceeded();
+        }
+        return defaultValue;
+    }
+};
+const createCleanupFunction = (dbManager, storeName, maxItems)=>async ()=>{
+        try {
+            const results = await dbManager.getAll(storeName);
+            if (results.length > maxItems) {
+                const toDelete = results.sort((a, b)=>a.timestamp - b.timestamp).slice(0, results.length - maxItems);
+                await Promise.all(toDelete.map((item)=>dbManager.delete(storeName, item.id)));
+            }
+        } catch (e) {
+            console.error(`Failed to cleanup ${storeName}:`, e);
+        }
+    };
+export { IndexedDBManager, createCleanupFunction, withErrorHandling };

package/dist/lib/baseDB.js

@@ -0,0 +1,149 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    IndexedDBManager: ()=>IndexedDBManager,
+    createCleanupFunction: ()=>createCleanupFunction,
+    withErrorHandling: ()=>withErrorHandling
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class IndexedDBManager {
+    initDB() {
+        return new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, this.version);
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve(request.result);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                this.storeConfigs.forEach(({ name, keyPath })=>{
+                    if (!db.objectStoreNames.contains(name)) {
+                        const store = db.createObjectStore(name, {
+                            keyPath
+                        });
+                        store.createIndex('timestamp', 'timestamp', {
+                            unique: false
+                        });
+                    }
+                });
+            };
+        });
+    }
+    async withTransaction(storeNames, mode, operation) {
+        const db = await this.dbPromise;
+        const transaction = db.transaction(storeNames, mode);
+        const stores = Array.isArray(storeNames) ? storeNames.map((name)=>transaction.objectStore(name)) : transaction.objectStore(storeNames);
+        return operation(stores);
+    }
+    promisifyRequest(request) {
+        return new Promise((resolve, reject)=>{
+            request.onsuccess = ()=>resolve(request.result);
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async put(storeName, data) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.put(data));
+        });
+    }
+    async get(storeName, key) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.get(key)));
+    }
+    async getAll(storeName, sortByTimestamp = true) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>{
+            const objectStore = store;
+            const results = sortByTimestamp ? await this.promisifyRequest(objectStore.index('timestamp').getAll()) : await this.promisifyRequest(objectStore.getAll());
+            return sortByTimestamp ? results.sort((a, b)=>a.timestamp - b.timestamp) : results;
+        });
+    }
+    async clear(storeName) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.clear());
+        });
+    }
+    async delete(storeName, key) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.delete(key));
+        });
+    }
+    async count(storeName) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.count()));
+    }
+    getDBPromise() {
+        return this.dbPromise;
+    }
+    constructor(dbName, version, storeConfigs){
+        _define_property(this, "dbPromise", void 0);
+        _define_property(this, "dbName", void 0);
+        _define_property(this, "version", void 0);
+        _define_property(this, "storeConfigs", void 0);
+        this.dbName = dbName;
+        this.version = version;
+        this.storeConfigs = storeConfigs;
+        this.dbPromise = this.initDB();
+    }
+}
+const withErrorHandling = async (operation, errorMessage, defaultValue, onQuotaExceeded)=>{
+    try {
+        return await operation();
+    } catch (e) {
+        console.error(errorMessage, e);
+        if (e instanceof Error && 'QuotaExceededError' === e.name && onQuotaExceeded) {
+            console.log('Storage quota exceeded, running cleanup...');
+            await onQuotaExceeded();
+        }
+        return defaultValue;
+    }
+};
+const createCleanupFunction = (dbManager, storeName, maxItems)=>async ()=>{
+        try {
+            const results = await dbManager.getAll(storeName);
+            if (results.length > maxItems) {
+                const toDelete = results.sort((a, b)=>a.timestamp - b.timestamp).slice(0, results.length - maxItems);
+                await Promise.all(toDelete.map((item)=>dbManager.delete(storeName, item.id)));
+            }
+        } catch (e) {
+            console.error(`Failed to cleanup ${storeName}:`, e);
+        }
+    };
+exports.IndexedDBManager = __webpack_exports__.IndexedDBManager;
+exports.createCleanupFunction = __webpack_exports__.createCleanupFunction;
+exports.withErrorHandling = __webpack_exports__.withErrorHandling;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "IndexedDBManager",
+    "createCleanupFunction",
+    "withErrorHandling"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/baseDB.d.ts

@@ -0,0 +1,25 @@
+export declare class IndexedDBManager {
+    private dbPromise;
+    private dbName;
+    private version;
+    private storeConfigs;
+    constructor(dbName: string, version: number, storeConfigs: Array<{
+        name: string;
+        keyPath: string;
+    }>);
+    private initDB;
+    private withTransaction;
+    private promisifyRequest;
+    put<T>(storeName: string, data: T): Promise<void>;
+    get<T>(storeName: string, key: string): Promise<T | undefined>;
+    getAll<T>(storeName: string, sortByTimestamp?: boolean): Promise<T[]>;
+    clear(storeName: string): Promise<void>;
+    delete(storeName: string, key: string): Promise<void>;
+    count(storeName: string): Promise<number>;
+    getDBPromise(): Promise<IDBDatabase>;
+}
+export declare const withErrorHandling: <T>(operation: () => Promise<T>, errorMessage: string, defaultValue?: T, onQuotaExceeded?: () => Promise<void>) => Promise<T | undefined>;
+export declare const createCleanupFunction: <T extends {
+    id: string;
+    timestamp: number;
+}>(dbManager: IndexedDBManager, storeName: string, maxItems: number) => () => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midscene/shared",
-  "version": "0.28.10-beta-20250922071252.0",
+  "version": "0.28.10",
   "repository": "https://github.com/web-infra-dev/midscene",
   "homepage": "https://midscenejs.com/",
   "types": "./dist/types/index.d.ts",

package/src/baseDB.ts

@@ -0,0 +1,158 @@
+// Generic database operations class
+export class IndexedDBManager {
+  private dbPromise: Promise<IDBDatabase>;
+  private dbName: string;
+  private version: number;
+  private storeConfigs: Array<{ name: string; keyPath: string }>;
+
+  constructor(
+    dbName: string,
+    version: number,
+    storeConfigs: Array<{ name: string; keyPath: string }>,
+  ) {
+    this.dbName = dbName;
+    this.version = version;
+    this.storeConfigs = storeConfigs;
+    this.dbPromise = this.initDB();
+  }
+
+  private initDB(): Promise<IDBDatabase> {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result;
+
+        // Create stores if they don't exist
+        this.storeConfigs.forEach(({ name, keyPath }) => {
+          if (!db.objectStoreNames.contains(name)) {
+            const store = db.createObjectStore(name, { keyPath });
+            store.createIndex('timestamp', 'timestamp', { unique: false });
+          }
+        });
+      };
+    });
+  }
+
+  private async withTransaction<T>(
+    storeNames: string | string[],
+    mode: IDBTransactionMode,
+    operation: (stores: IDBObjectStore | IDBObjectStore[]) => Promise<T>,
+  ): Promise<T> {
+    const db = await this.dbPromise;
+    const transaction = db.transaction(storeNames, mode);
+
+    const stores = Array.isArray(storeNames)
+      ? storeNames.map((name) => transaction.objectStore(name))
+      : transaction.objectStore(storeNames);
+
+    return operation(stores);
+  }
+
+  private promisifyRequest<T>(request: IDBRequest<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async put<T>(storeName: string, data: T): Promise<void> {
+    await this.withTransaction(storeName, 'readwrite', async (store) => {
+      await this.promisifyRequest((store as IDBObjectStore).put(data));
+    });
+  }
+
+  async get<T>(storeName: string, key: string): Promise<T | undefined> {
+    return this.withTransaction(storeName, 'readonly', async (store) => {
+      return this.promisifyRequest((store as IDBObjectStore).get(key));
+    });
+  }
+
+  async getAll<T>(storeName: string, sortByTimestamp = true): Promise<T[]> {
+    return this.withTransaction(storeName, 'readonly', async (store) => {
+      const objectStore = store as IDBObjectStore;
+      const results = sortByTimestamp
+        ? await this.promisifyRequest(objectStore.index('timestamp').getAll())
+        : await this.promisifyRequest(objectStore.getAll());
+
+      return sortByTimestamp
+        ? results.sort((a: any, b: any) => a.timestamp - b.timestamp)
+        : results;
+    });
+  }
+
+  async clear(storeName: string): Promise<void> {
+    await this.withTransaction(storeName, 'readwrite', async (store) => {
+      await this.promisifyRequest((store as IDBObjectStore).clear());
+    });
+  }
+
+  async delete(storeName: string, key: string): Promise<void> {
+    await this.withTransaction(storeName, 'readwrite', async (store) => {
+      await this.promisifyRequest((store as IDBObjectStore).delete(key));
+    });
+  }
+
+  async count(storeName: string): Promise<number> {
+    return this.withTransaction(storeName, 'readonly', async (store) => {
+      return this.promisifyRequest((store as IDBObjectStore).count());
+    });
+  }
+
+  getDBPromise(): Promise<IDBDatabase> {
+    return this.dbPromise;
+  }
+}
+
+// Generic error handler wrapper
+export const withErrorHandling = async <T>(
+  operation: () => Promise<T>,
+  errorMessage: string,
+  defaultValue?: T,
+  onQuotaExceeded?: () => Promise<void>,
+): Promise<T | undefined> => {
+  try {
+    return await operation();
+  } catch (e) {
+    console.error(errorMessage, e);
+    if (
+      e instanceof Error &&
+      e.name === 'QuotaExceededError' &&
+      onQuotaExceeded
+    ) {
+      console.log('Storage quota exceeded, running cleanup...');
+      await onQuotaExceeded();
+    }
+    return defaultValue;
+  }
+};
+
+// Base cleanup function for managing storage space
+export const createCleanupFunction = <
+  T extends { id: string; timestamp: number },
+>(
+  dbManager: IndexedDBManager,
+  storeName: string,
+  maxItems: number,
+) => {
+  return async (): Promise<void> => {
+    try {
+      const results = await dbManager.getAll<T>(storeName);
+
+      if (results.length > maxItems) {
+        const toDelete = results
+          .sort((a, b) => a.timestamp - b.timestamp)
+          .slice(0, results.length - maxItems);
+
+        await Promise.all(
+          toDelete.map((item) => dbManager.delete(storeName, item.id)),
+        );
+      }
+    } catch (e) {
+      console.error(`Failed to cleanup ${storeName}:`, e);
+    }
+  };
+};