From 8eff962cab608341a6f2fedc640a0e32d96f26e2 Mon Sep 17 00:00:00 2001 From: altaf-creator Date: Sun, 9 Nov 2025 11:15:19 +0800 Subject: pain --- frontend-old/node_modules/idb/build/entry.d.ts | 627 +++++++++++++++++++++++++ 1 file changed, 627 insertions(+) create mode 100644 frontend-old/node_modules/idb/build/entry.d.ts (limited to 'frontend-old/node_modules/idb/build/entry.d.ts') diff --git a/frontend-old/node_modules/idb/build/entry.d.ts b/frontend-old/node_modules/idb/build/entry.d.ts new file mode 100644 index 0000000..febdcf4 --- /dev/null +++ b/frontend-old/node_modules/idb/build/entry.d.ts @@ -0,0 +1,627 @@ +export interface OpenDBCallbacks { + /** + * Called if this version of the database has never been opened before. Use it to specify the + * schema for the database. + * + * @param database A database instance that you can use to add/remove stores and indexes. + * @param oldVersion Last version of the database opened by the user. + * @param newVersion Whatever new version you provided. + * @param transaction The transaction for this upgrade. + * This is useful if you need to get data from other stores as part of a migration. + * @param event The event object for the associated 'upgradeneeded' event. + */ + upgrade?(database: IDBPDatabase, oldVersion: number, newVersion: number | null, transaction: IDBPTransaction[], 'versionchange'>, event: IDBVersionChangeEvent): void; + /** + * Called if there are older versions of the database open on the origin, so this version cannot + * open. + * + * @param currentVersion Version of the database that's blocking this one. + * @param blockedVersion The version of the database being blocked (whatever version you provided to `openDB`). + * @param event The event object for the associated `blocked` event. + */ + blocked?(currentVersion: number, blockedVersion: number | null, event: IDBVersionChangeEvent): void; + /** + * Called if this connection is blocking a future version of the database from opening. + * + * @param currentVersion Version of the open database (whatever version you provided to `openDB`). + * @param blockedVersion The version of the database that's being blocked. + * @param event The event object for the associated `versionchange` event. + */ + blocking?(currentVersion: number, blockedVersion: number | null, event: IDBVersionChangeEvent): void; + /** + * Called if the browser abnormally terminates the connection. + * This is not called when `db.close()` is called. + */ + terminated?(): void; +} +/** + * Open a database. + * + * @param name Name of the database. + * @param version Schema version. + * @param callbacks Additional callbacks. + */ +export declare function openDB(name: string, version?: number, { blocked, upgrade, blocking, terminated }?: OpenDBCallbacks): Promise>; +export interface DeleteDBCallbacks { + /** + * Called if there are connections to this database open, so it cannot be deleted. + * + * @param currentVersion Version of the database that's blocking the delete operation. + * @param event The event object for the associated `blocked` event. + */ + blocked?(currentVersion: number, event: IDBVersionChangeEvent): void; +} +/** + * Delete a database. + * + * @param name Name of the database. + */ +export declare function deleteDB(name: string, { blocked }?: DeleteDBCallbacks): Promise; +export { unwrap, wrap } from './wrap-idb-value.js'; +declare type KeyToKeyNoIndex = { + [K in keyof T]: string extends K ? never : number extends K ? never : K; +}; +declare type ValuesOf = T extends { + [K in keyof T]: infer U; +} ? U : never; +declare type KnownKeys = ValuesOf>; +declare type Omit = Pick>; +export interface DBSchema { + [s: string]: DBSchemaValue; +} +interface IndexKeys { + [s: string]: IDBValidKey; +} +interface DBSchemaValue { + key: IDBValidKey; + value: any; + indexes?: IndexKeys; +} +/** + * Extract known object store names from the DB schema type. + * + * @template DBTypes DB schema type, or unknown if the DB isn't typed. + */ +export declare type StoreNames = DBTypes extends DBSchema ? KnownKeys : string; +/** + * Extract database value types from the DB schema type. + * + * @template DBTypes DB schema type, or unknown if the DB isn't typed. + * @template StoreName Names of the object stores to get the types of. + */ +export declare type StoreValue> = DBTypes extends DBSchema ? DBTypes[StoreName]['value'] : any; +/** + * Extract database key types from the DB schema type. + * + * @template DBTypes DB schema type, or unknown if the DB isn't typed. + * @template StoreName Names of the object stores to get the types of. + */ +export declare type StoreKey> = DBTypes extends DBSchema ? DBTypes[StoreName]['key'] : IDBValidKey; +/** + * Extract the names of indexes in certain object stores from the DB schema type. + * + * @template DBTypes DB schema type, or unknown if the DB isn't typed. + * @template StoreName Names of the object stores to get the types of. + */ +export declare type IndexNames> = DBTypes extends DBSchema ? keyof DBTypes[StoreName]['indexes'] : string; +/** + * Extract the types of indexes in certain object stores from the DB schema type. + * + * @template DBTypes DB schema type, or unknown if the DB isn't typed. + * @template StoreName Names of the object stores to get the types of. + * @template IndexName Names of the indexes to get the types of. + */ +export declare type IndexKey, IndexName extends IndexNames> = DBTypes extends DBSchema ? IndexName extends keyof DBTypes[StoreName]['indexes'] ? DBTypes[StoreName]['indexes'][IndexName] : IDBValidKey : IDBValidKey; +declare type CursorSource>, StoreName extends StoreNames, IndexName extends IndexNames | unknown, Mode extends IDBTransactionMode = 'readonly'> = IndexName extends IndexNames ? IDBPIndex : IDBPObjectStore; +declare type CursorKey, IndexName extends IndexNames | unknown> = IndexName extends IndexNames ? IndexKey : StoreKey; +declare type IDBPDatabaseExtends = Omit; +/** + * A variation of DOMStringList with precise string types + */ +export interface TypedDOMStringList extends DOMStringList { + contains(string: T): boolean; + item(index: number): T | null; + [index: number]: T; + [Symbol.iterator](): IterableIterator; +} +interface IDBTransactionOptions { + /** + * The durability of the transaction. + * + * The default is "default". Using "relaxed" provides better performance, but with fewer + * guarantees. Web applications are encouraged to use "relaxed" for ephemeral data such as caches + * or quickly changing records, and "strict" in cases where reducing the risk of data loss + * outweighs the impact to performance and power. + */ + durability?: 'default' | 'strict' | 'relaxed'; +} +export interface IDBPDatabase extends IDBPDatabaseExtends { + /** + * The names of stores in the database. + */ + readonly objectStoreNames: TypedDOMStringList>; + /** + * Creates a new object store. + * + * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction. + */ + createObjectStore>(name: Name, optionalParameters?: IDBObjectStoreParameters): IDBPObjectStore>, Name, 'versionchange'>; + /** + * Deletes the object store with the given name. + * + * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction. + */ + deleteObjectStore(name: StoreNames): void; + /** + * Start a new transaction. + * + * @param storeNames The object store(s) this transaction needs. + * @param mode + * @param options + */ + transaction, Mode extends IDBTransactionMode = 'readonly'>(storeNames: Name, mode?: Mode, options?: IDBTransactionOptions): IDBPTransaction; + transaction>, Mode extends IDBTransactionMode = 'readonly'>(storeNames: Names, mode?: Mode, options?: IDBTransactionOptions): IDBPTransaction; + /** + * Add a value to a store. + * + * Rejects if an item of a given key already exists in the store. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param value + * @param key + */ + add>(storeName: Name, value: StoreValue, key?: StoreKey | IDBKeyRange): Promise>; + /** + * Deletes all records in a store. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + */ + clear(name: StoreNames): Promise; + /** + * Retrieves the number of records matching the given query in a store. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param key + */ + count>(storeName: Name, key?: StoreKey | IDBKeyRange | null): Promise; + /** + * Retrieves the number of records matching the given query in an index. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param indexName Name of the index within the store. + * @param key + */ + countFromIndex, IndexName extends IndexNames>(storeName: Name, indexName: IndexName, key?: IndexKey | IDBKeyRange | null): Promise; + /** + * Deletes records in a store matching the given query. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param key + */ + delete>(storeName: Name, key: StoreKey | IDBKeyRange): Promise; + /** + * Retrieves the value of the first record in a store matching the query. + * + * Resolves with undefined if no match is found. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param query + */ + get>(storeName: Name, query: StoreKey | IDBKeyRange): Promise | undefined>; + /** + * Retrieves the value of the first record in an index matching the query. + * + * Resolves with undefined if no match is found. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param indexName Name of the index within the store. + * @param query + */ + getFromIndex, IndexName extends IndexNames>(storeName: Name, indexName: IndexName, query: IndexKey | IDBKeyRange): Promise | undefined>; + /** + * Retrieves all values in a store that match the query. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param query + * @param count Maximum number of values to return. + */ + getAll>(storeName: Name, query?: StoreKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves all values in an index that match the query. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param indexName Name of the index within the store. + * @param query + * @param count Maximum number of values to return. + */ + getAllFromIndex, IndexName extends IndexNames>(storeName: Name, indexName: IndexName, query?: IndexKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the keys of records in a store matching the query. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param query + * @param count Maximum number of keys to return. + */ + getAllKeys>(storeName: Name, query?: StoreKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the keys of records in an index matching the query. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param indexName Name of the index within the store. + * @param query + * @param count Maximum number of keys to return. + */ + getAllKeysFromIndex, IndexName extends IndexNames>(storeName: Name, indexName: IndexName, query?: IndexKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the key of the first record in a store that matches the query. + * + * Resolves with undefined if no match is found. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param query + */ + getKey>(storeName: Name, query: StoreKey | IDBKeyRange): Promise | undefined>; + /** + * Retrieves the key of the first record in an index that matches the query. + * + * Resolves with undefined if no match is found. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param indexName Name of the index within the store. + * @param query + */ + getKeyFromIndex, IndexName extends IndexNames>(storeName: Name, indexName: IndexName, query: IndexKey | IDBKeyRange): Promise | undefined>; + /** + * Put an item in the database. + * + * Replaces any item with the same key. + * + * This is a shortcut that creates a transaction for this single action. If you need to do more + * than one action, create a transaction instead. + * + * @param storeName Name of the store. + * @param value + * @param key + */ + put>(storeName: Name, value: StoreValue, key?: StoreKey | IDBKeyRange): Promise>; +} +declare type IDBPTransactionExtends = Omit; +export interface IDBPTransaction> = ArrayLike>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPTransactionExtends { + /** + * The transaction's mode. + */ + readonly mode: Mode; + /** + * The names of stores in scope for this transaction. + */ + readonly objectStoreNames: TypedDOMStringList; + /** + * The transaction's connection. + */ + readonly db: IDBPDatabase; + /** + * Promise for the completion of this transaction. + */ + readonly done: Promise; + /** + * The associated object store, if the transaction covers a single store, otherwise undefined. + */ + readonly store: TxStores[1] extends undefined ? IDBPObjectStore : undefined; + /** + * Returns an IDBObjectStore in the transaction's scope. + */ + objectStore(name: StoreName): IDBPObjectStore; +} +declare type IDBPObjectStoreExtends = Omit; +export interface IDBPObjectStore> = ArrayLike>, StoreName extends StoreNames = StoreNames, Mode extends IDBTransactionMode = 'readonly'> extends IDBPObjectStoreExtends { + /** + * The names of indexes in the store. + */ + readonly indexNames: TypedDOMStringList>; + /** + * The associated transaction. + */ + readonly transaction: IDBPTransaction; + /** + * Add a value to the store. + * + * Rejects if an item of a given key already exists in the store. + */ + add: Mode extends 'readonly' ? undefined : (value: StoreValue, key?: StoreKey | IDBKeyRange) => Promise>; + /** + * Deletes all records in store. + */ + clear: Mode extends 'readonly' ? undefined : () => Promise; + /** + * Retrieves the number of records matching the given query. + */ + count(key?: StoreKey | IDBKeyRange | null): Promise; + /** + * Creates a new index in store. + * + * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction. + */ + createIndex: Mode extends 'versionchange' ? >(name: IndexName, keyPath: string | string[], options?: IDBIndexParameters) => IDBPIndex : undefined; + /** + * Deletes records in store matching the given query. + */ + delete: Mode extends 'readonly' ? undefined : (key: StoreKey | IDBKeyRange) => Promise; + /** + * Retrieves the value of the first record matching the query. + * + * Resolves with undefined if no match is found. + */ + get(query: StoreKey | IDBKeyRange): Promise | undefined>; + /** + * Retrieves all values that match the query. + * + * @param query + * @param count Maximum number of values to return. + */ + getAll(query?: StoreKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the keys of records matching the query. + * + * @param query + * @param count Maximum number of keys to return. + */ + getAllKeys(query?: StoreKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the key of the first record that matches the query. + * + * Resolves with undefined if no match is found. + */ + getKey(query: StoreKey | IDBKeyRange): Promise | undefined>; + /** + * Get a query of a given name. + */ + index>(name: IndexName): IDBPIndex; + /** + * Opens a cursor over the records matching the query. + * + * Resolves with null if no matches are found. + * + * @param query If null, all records match. + * @param direction + */ + openCursor(query?: StoreKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise | null>; + /** + * Opens a cursor over the keys matching the query. + * + * Resolves with null if no matches are found. + * + * @param query If null, all records match. + * @param direction + */ + openKeyCursor(query?: StoreKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise | null>; + /** + * Put an item in the store. + * + * Replaces any item with the same key. + */ + put: Mode extends 'readonly' ? undefined : (value: StoreValue, key?: StoreKey | IDBKeyRange) => Promise>; + /** + * Iterate over the store. + */ + [Symbol.asyncIterator](): AsyncIterableIterator>; + /** + * Iterate over the records matching the query. + * + * @param query If null, all records match. + * @param direction + */ + iterate(query?: StoreKey | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncIterableIterator>; +} +declare type IDBPIndexExtends = Omit; +export interface IDBPIndex> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames = IndexNames, Mode extends IDBTransactionMode = 'readonly'> extends IDBPIndexExtends { + /** + * The IDBObjectStore the index belongs to. + */ + readonly objectStore: IDBPObjectStore; + /** + * Retrieves the number of records matching the given query. + */ + count(key?: IndexKey | IDBKeyRange | null): Promise; + /** + * Retrieves the value of the first record matching the query. + * + * Resolves with undefined if no match is found. + */ + get(query: IndexKey | IDBKeyRange): Promise | undefined>; + /** + * Retrieves all values that match the query. + * + * @param query + * @param count Maximum number of values to return. + */ + getAll(query?: IndexKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the keys of records matching the query. + * + * @param query + * @param count Maximum number of keys to return. + */ + getAllKeys(query?: IndexKey | IDBKeyRange | null, count?: number): Promise[]>; + /** + * Retrieves the key of the first record that matches the query. + * + * Resolves with undefined if no match is found. + */ + getKey(query: IndexKey | IDBKeyRange): Promise | undefined>; + /** + * Opens a cursor over the records matching the query. + * + * Resolves with null if no matches are found. + * + * @param query If null, all records match. + * @param direction + */ + openCursor(query?: IndexKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise | null>; + /** + * Opens a cursor over the keys matching the query. + * + * Resolves with null if no matches are found. + * + * @param query If null, all records match. + * @param direction + */ + openKeyCursor(query?: IndexKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise | null>; + /** + * Iterate over the index. + */ + [Symbol.asyncIterator](): AsyncIterableIterator>; + /** + * Iterate over the records matching the query. + * + * Resolves with null if no matches are found. + * + * @param query If null, all records match. + * @param direction + */ + iterate(query?: IndexKey | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncIterableIterator>; +} +declare type IDBPCursorExtends = Omit; +export interface IDBPCursor> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorExtends { + /** + * The key of the current index or object store item. + */ + readonly key: CursorKey; + /** + * The key of the current object store item. + */ + readonly primaryKey: StoreKey; + /** + * Returns the IDBObjectStore or IDBIndex the cursor was opened from. + */ + readonly source: CursorSource; + /** + * Advances the cursor a given number of records. + * + * Resolves to null if no matching records remain. + */ + advance(this: T, count: number): Promise; + /** + * Advance the cursor by one record (unless 'key' is provided). + * + * Resolves to null if no matching records remain. + * + * @param key Advance to the index or object store with a key equal to or greater than this value. + */ + continue(this: T, key?: CursorKey): Promise; + /** + * Advance the cursor by given keys. + * + * The operation is 'and' – both keys must be satisfied. + * + * Resolves to null if no matching records remain. + * + * @param key Advance to the index or object store with a key equal to or greater than this value. + * @param primaryKey and where the object store has a key equal to or greater than this value. + */ + continuePrimaryKey(this: T, key: CursorKey, primaryKey: StoreKey): Promise; + /** + * Delete the current record. + */ + delete: Mode extends 'readonly' ? undefined : () => Promise; + /** + * Updated the current record. + */ + update: Mode extends 'readonly' ? undefined : (value: StoreValue) => Promise>; + /** + * Iterate over the cursor. + */ + [Symbol.asyncIterator](): AsyncIterableIterator>; +} +declare type IDBPCursorIteratorValueExtends> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit, 'advance' | 'continue' | 'continuePrimaryKey'>; +export interface IDBPCursorIteratorValue> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorIteratorValueExtends { + /** + * Advances the cursor a given number of records. + */ + advance(this: T, count: number): void; + /** + * Advance the cursor by one record (unless 'key' is provided). + * + * @param key Advance to the index or object store with a key equal to or greater than this value. + */ + continue(this: T, key?: CursorKey): void; + /** + * Advance the cursor by given keys. + * + * The operation is 'and' – both keys must be satisfied. + * + * @param key Advance to the index or object store with a key equal to or greater than this value. + * @param primaryKey and where the object store has a key equal to or greater than this value. + */ + continuePrimaryKey(this: T, key: CursorKey, primaryKey: StoreKey): void; +} +export interface IDBPCursorWithValue> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursor { + /** + * The value of the current item. + */ + readonly value: StoreValue; + /** + * Iterate over the cursor. + */ + [Symbol.asyncIterator](): AsyncIterableIterator>; +} +declare type IDBPCursorWithValueIteratorValueExtends> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit, 'advance' | 'continue' | 'continuePrimaryKey'>; +export interface IDBPCursorWithValueIteratorValue> = ArrayLike>, StoreName extends StoreNames = StoreNames, IndexName extends IndexNames | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorWithValueIteratorValueExtends { + /** + * Advances the cursor a given number of records. + */ + advance(this: T, count: number): void; + /** + * Advance the cursor by one record (unless 'key' is provided). + * + * @param key Advance to the index or object store with a key equal to or greater than this value. + */ + continue(this: T, key?: CursorKey): void; + /** + * Advance the cursor by given keys. + * + * The operation is 'and' – both keys must be satisfied. + * + * @param key Advance to the index or object store with a key equal to or greater than this value. + * @param primaryKey and where the object store has a key equal to or greater than this value. + */ + continuePrimaryKey(this: T, key: CursorKey, primaryKey: StoreKey): void; +} -- cgit v1.2.3