@inpageedit/core 0.9.2 → 0.9.3

package/dist/index.js

@@ -1,4 +1,4 @@
-import { B as s, b as g, I as r, m as c, $ as o, S as t, a as L, c as i } from "./index-Ek5d60jn.js";
+import { B as s, b as g, I as r, m as c, $ as o, S as t, a as L, c as i } from "./index-BKxuoVoX.js";
 export {
   s as BasePlugin,
   g as InPageEdit,

package/dist/services/storage/IDBStorage.d.ts

@@ -1,7 +1,21 @@
-export interface IDBStoreDefinition {
+export interface IDBIndexDef {
+    name: string;
+    keyPath: string | string[];
+    options?: IDBIndexParameters;
+}
+export interface EnsureStoreOptions {
+    /** keyPath for objectStore; default undefined (out-of-line keys) */
+    keyPath?: string | string[] | null;
+    /** autoIncrement for objectStore; default false */
+    autoIncrement?: boolean;
+    /** indexes to ensure exist on the store (missing ones will be created on upgrade) */
+    indexes?: IDBIndexDef[];
+}
+export interface IDBStoreHandle {
     dbName: string;
     storeName: string;
-    dbPromise: Promise<IDBDatabase>;
+    /** Always returns a *current* connection; no stale db caching leaks to callers. */
+    getDb(): Promise<IDBDatabase>;
 }
 export declare namespace IDBHelper {
     /** Promisify IDBRequest */
@@ -12,41 +26,65 @@ export declare namespace IDBHelper {
     function closeDatabase(dbName: string): Promise<void>;
     /** Close all cached database connections. */
     function closeAllDatabases(): Promise<void>;
+    /** Delete a database completely (closes cached connection first). */
+    function deleteDatabase(dbName: string): Promise<void>;
     /**
-     * Ensure an object store exists. If missing, bump IDB version to create it.
+     * Ensure an object store (and optional indexes) exist. If missing, bump version to create.
      * Concurrent calls are serialized per db to avoid racing upgrades.
      */
-    function createStore(dbName: string, storeName: string): Promise<IDBDatabase>;
-    /** Convenience: open & ensure store, return a store definition. */
-    function openStore(dbName: string, storeName: string): Promise<IDBStoreDefinition>;
-    function withObjectStore<T>(store: IDBStoreDefinition, mode: IDBTransactionMode, fn: (os: IDBObjectStore) => Promise<T> | T): Promise<T>;
-    function get<T = unknown>(store: IDBStoreDefinition, key: IDBValidKey): Promise<T | undefined>;
-    function set(store: IDBStoreDefinition, key: IDBValidKey, value: unknown): Promise<void>;
-    function del(store: IDBStoreDefinition, key: IDBValidKey): Promise<void>;
-    function clear(store: IDBStoreDefinition): Promise<void>;
-    function keys(store: IDBStoreDefinition): Promise<IDBValidKey[]>;
-    function entries(store: IDBStoreDefinition): Promise<[IDBValidKey, any][]>;
-    function entriesIter(store: IDBStoreDefinition, batchSize?: number): AsyncIterable<[IDBValidKey, any]>;
-    function keysIter(store: IDBStoreDefinition, batchSize?: number): AsyncIterable<IDBValidKey>;
+    function ensureStore(dbName: string, storeName: string, opts?: EnsureStoreOptions): Promise<IDBDatabase>;
+    /** Convenience: open & ensure store, return a store handle. */
+    function createStore(dbName: string, storeName: string, opts?: EnsureStoreOptions): Promise<IDBStoreHandle>;
+    /**
+     * Run a function inside a transaction on one object store.
+     * Auto-recovers from transient IDB failures by reopening/ensuring and retrying (limited attempts).
+     */
+    function withObjectStore<T>(handle: IDBStoreHandle, mode: IDBTransactionMode, fn: (os: IDBObjectStore) => Promise<T> | T, 
+    /** customize retry attempts/backoff if needed */
+    retry?: {
+        attempts?: number;
+        baseDelayMs?: number;
+    }): Promise<T>;
+    function get<T = unknown>(handle: IDBStoreHandle, key: IDBValidKey): Promise<T | undefined>;
+    function set(handle: IDBStoreHandle, key: IDBValidKey, value: unknown): Promise<void>;
+    function del(handle: IDBStoreHandle, key: IDBValidKey): Promise<void>;
+    function clear(handle: IDBStoreHandle): Promise<void>;
+    function entries(handle: IDBStoreHandle, batchSize?: number): AsyncIterable<[IDBValidKey, any]>;
+    function keys(handle: IDBStoreHandle, batchSize?: number): AsyncIterable<IDBValidKey>;
+}
+export interface IDBStoreOptions {
+    /** 每次迭代拉取的批大小；兼容 iterBtch/iterBatch 两种写法 */
+    iterBatch?: number;
+    /** 建库/建表定义（可选）。若设置了 keyPath，则视为“内联主键”模式 */
+    ensure?: EnsureStoreOptions;
+    /** 重试参数（可选） */
+    retry?: {
+        attempts?: number;
+        baseDelayMs?: number;
+    };
 }
-export declare class IDBStorage<K extends IDBValidKey, V> implements AsyncIterable<[K, V]> {
-    private readonly store;
+export declare class IDBStorage<K extends IDBValidKey = IDBValidKey, V = any> implements AsyncIterable<[K, V]> {
+    readonly dbName: string;
+    readonly storeName: string;
     private readonly iterBatch;
-    private constructor();
-    static open<K extends IDBValidKey, V>(dbName: string, storeName: string, iterBatch?: number): Promise<IDBStorage<K, V>>;
+    private readonly retry?;
+    private readonly inlineKey;
+    private readonly idbStoreHandle;
+    constructor(dbName: string, storeName: string, options?: IDBStoreOptions);
+    private handle;
     get(key: K): Promise<V | undefined>;
-    set(key: K, value: V): Promise<this>;
-    delete(key: K): Promise<boolean>;
-    has(key: K): Promise<boolean>;
+    set(key: K, value: V): Promise<void>;
+    delete(key: K): Promise<void>;
     clear(): Promise<void>;
-    /**
-     * @note expensive operation: iterates all keys to count them
-     */
-    size(): Promise<number>;
-    entries(batchSize?: number): AsyncIterable<[K, V]>;
-    keys(batchSize?: number): AsyncIterable<K>;
-    values(batchSize?: number): AsyncIterable<V>;
+    has(key: K): Promise<boolean>;
+    count(): Promise<number>;
+    entries(): AsyncIterable<[K, V]>;
+    keys(): AsyncIterable<K>;
+    values(): AsyncIterable<V>;
     [Symbol.asyncIterator](): AsyncIterator<[K, V]>;
-    forEach(callback: (value: V, key: K, map: IDBStorage<K, V>) => void | Promise<void>): Promise<void>;
-    toArray(limit?: number): Promise<Array<[K, V]>>;
+    forEach(cb: (value: V, key: K, store: IDBStorage<K, V>) => void | Promise<void>): Promise<void>;
+    setMany(entries: Iterable<[K, V]> | AsyncIterable<[K, V]>): Promise<void>;
+    deleteMany(keys: Iterable<K> | AsyncIterable<K>): Promise<void>;
+    tx<T>(mode: IDBTransactionMode, fn: (os: IDBObjectStore) => Promise<T> | T): Promise<T>;
+    close(): Promise<void>;
 }

package/dist/services/storage/index.d.ts

@@ -1,5 +1,5 @@
 import { InPageEdit, Service } from '../../InPageEdit.js';
-import { IDBStoreDefinition } from './IDBStorage.js';
+import { IDBStorage } from './IDBStorage.js';
 declare module '../../InPageEdit' {
     interface InPageEdit {
         storage: StorageService;
@@ -23,8 +23,9 @@ export interface AbstactIPEStorageManager<T = unknown> {
     set(key: string, value: T): Promise<IPEStorageRecord<T>>;
     has(key: string, ttl?: number): Promise<boolean>;
     delete(key: string): Promise<void>;
-    iterate(callback: (value: T, key: string) => void): Promise<void>;
-    keys(): Promise<string[]>;
+    keys(): AsyncIterable<string>;
+    values(): AsyncIterable<IPEStorageRecord<T>>;
+    entries(): AsyncIterable<[string, IPEStorageRecord<T>]>;
     clear(): Promise<this>;
 }
 export declare class IDBStorageManager<T = unknown> implements AbstactIPEStorageManager<T> {
@@ -32,17 +33,16 @@ export declare class IDBStorageManager<T = unknown> implements AbstactIPEStorage
     readonly storeName: string;
     ttl: number;
     version?: number | undefined;
-    readonly store: IDBStoreDefinition;
+    readonly db: IDBStorage<string, IPEStorageRecord<T>>;
+    keys: () => AsyncIterable<string>;
+    values: () => AsyncIterable<IPEStorageRecord<T>>;
+    entries: () => AsyncIterable<[string, IPEStorageRecord<T>]>;
     constructor(dbName: string, storeName: string, ttl?: number, version?: number | undefined);
-    private static _cached_stores;
-    private static createStore;
-    keys(): Promise<string[]>;
     get(key: string, ttl?: number, setter?: () => Promise<T> | T): Promise<T | null>;
     set(key: string, value: null | undefined): Promise<void>;
     set(key: string, value: T): Promise<IPEStorageRecord<T>>;
     has(key: string, ttl?: number): Promise<boolean>;
     delete(key: string): Promise<void>;
-    iterate(callback: (value: T, key: string) => void): Promise<void>;
     private loadFromDB;
     private checkIfExpired;
     /**