@dumbmatter/idb 7.0.0 → 8.0.3

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+# Breaking changes in 8.x
+
+- Finally dropped support for old EdgeHTML engine.
+- Dropped support for browsers that don't support [`cursor.request`](https://caniuse.com/mdn-api_idbcursor_request).
+- Removed separate async iterators build. It's now one build with async iterator support.
+
 # Breaking changes in 7.x
 
 - No longer committing `build` to GitHub.

package/README.md

@@ -1,6 +1,6 @@
 # IndexedDB with usability.
 
-This is a tiny (~1.05k brotli'd) library that mostly mirrors the IndexedDB API, but with small improvements that make a big difference to usability.
+This is a tiny (~1.19kB brotli'd) library that mostly mirrors the IndexedDB API, but with small improvements that make a big difference to usability.
 
 1. [Installation](#installation)
 1. [Changes](#changes)
@@ -42,7 +42,7 @@ async function doDatabaseStuff() {
 
 ```html
 <script type="module">
-  import { openDB, deleteDB, wrap, unwrap } from 'https://cdn.jsdelivr.net/npm/idb@7/+esm';
+  import { openDB, deleteDB, wrap, unwrap } from 'https://cdn.jsdelivr.net/npm/idb@8/+esm';
 
   async function doDatabaseStuff() {
     const db = await openDB(…);
@@ -53,7 +53,7 @@ async function doDatabaseStuff() {
 ### Using external script reference
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/idb@7/build/umd.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/idb@8/build/umd.js"></script>
 <script>
   async function doDatabaseStuff() {
     const db = await idb.openDB(…);
@@ -71,8 +71,6 @@ A global, `idb`, will be created, containing all exports of the module version.
 
 This library targets modern browsers, as in Chrome, Firefox, Safari, and other browsers that use those engines, such as Edge. IE is not supported.
 
-If you want to target much older versions of those browsers, you can transpile the library using something like [Babel](https://babeljs.io/). You can't transpile the library for IE, as it relies on a proper implementation of [JavaScript proxies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy).
-
 # API
 
 ## `openDB`
@@ -81,13 +79,13 @@ This method opens a database, and returns a promise for an enhanced [`IDBDatabas
 
 ```js
 const db = await openDB(name, version, {
-  upgrade(db, oldVersion, newVersion, transaction) {
+  upgrade(db, oldVersion, newVersion, transaction, event) {
     // …
   },
-  blocked() {
+  blocked(currentVersion, blockedVersion, event) {
     // …
   },
-  blocking() {
+  blocking(currentVersion, blockedVersion, event) {
     // …
   },
   terminated() {
@@ -103,8 +101,15 @@ const db = await openDB(name, version, {
   - `oldVersion`: Last version of the database opened by the user.
   - `newVersion`: Whatever new version you provided.
   - `transaction`: An enhanced transaction for this upgrade. This is useful if you need to get data from other stores as part of a migration.
+  - `event`: The event object for the associated `upgradeneeded` event.
 - `blocked` (optional): Called if there are older versions of the database open on the origin, so this version cannot open. This is similar to the [`blocked` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest/blocked_event) in plain IndexedDB.
+  - `currentVersion`: Version of the database that's blocking this one.
+  - `blockedVersion`: The version of the database being blocked (whatever version you provided to `openDB`).
+  - `event`: The event object for the associated `blocked` event.
 - `blocking` (optional): Called if this connection is blocking a future version of the database from opening. This is similar to the [`versionchange` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase/versionchange_event) in plain IndexedDB.
+  - `currentVersion`: Version of the open database (whatever version you provided to `openDB`).
+  - `blockedVersion`: The version of the database that's being blocked.
+  - `event`: The event object for the associated `versionchange` event.
 - `terminated` (optional): Called if the browser abnormally terminates the connection, but not on regular closures like calling `db.close()`. This is similar to the [`close` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase/close_event) in plain IndexedDB.
 
 ## `deleteDB`
@@ -121,6 +126,8 @@ await deleteDB(name, {
 
 - `name`: Name of the database.
 - `blocked` (optional): Called if the database already exists and there are open connections that don’t close in response to a versionchange event, the request will be blocked until they all close.
+  - `currentVersion`: Version of the database that's blocking the delete operation.
+  - `event`: The event object for the associated 'versionchange' event.
 
 ## `unwrap`
 
@@ -142,8 +149,6 @@ const wrapped = wrap(unwrapped);
 
 This is useful if some third party code gives you an `IDBDatabase` object and you want it to have the features of this library.
 
-This doesn't work with `IDBCursor`, [due to missing primitives](https://github.com/w3c/IndexedDB/issues/255). Also, if you wrap an `IDBTransaction`, `tx.store` and `tx.objectStoreNames` won't work in Edge. To avoid these issues, wrap the `IDBDatabase` object, and use the wrapped object to create a new transaction.
-
 ## General enhancements
 
 Once you've opened the database the API is the same as IndexedDB, except for a few changes to make things easier.
@@ -261,15 +266,7 @@ while (cursor) {
 
 ## Async iterators
 
-Async iterator support isn't included by default (Edge doesn't support them). To include them, import `idb/with-async-ittr` instead of `idb` (this increases the library size to ~1.28k brotli'd):
-
-```js
-import { openDB } from 'idb/with-async-ittr';
-```
-
-Or `https://cdn.jsdelivr.net/npm/idb@7/build/umd-with-async-ittr.js` if you're using the non-module version.
-
-Now you can iterate over stores, indexes, and cursors:
+You can iterate over stores, indexes, and cursors:
 
 ```js
 const tx = db.transaction(storeName);
@@ -320,19 +317,19 @@ const dbPromise = openDB('keyval-store', 1, {
 
 export async function get(key) {
   return (await dbPromise).get('keyval', key);
-};
+}
 export async function set(key, val) {
   return (await dbPromise).put('keyval', val, key);
-};
+}
 export async function del(key) {
   return (await dbPromise).delete('keyval', key);
-};
+}
 export async function clear() {
   return (await dbPromise).clear('keyval');
-};
+}
 export async function keys() {
   return (await dbPromise).getAllKeys('keyval');
-};
+}
 ```
 
 ## Article store
@@ -497,7 +494,7 @@ Note: Types like `IDBPDatabase` are used by TypeScript only. The implementation
 # Developing
 
 ```sh
-npm run dev
+pnpm run dev
 ```
 
 This will also perform type testing.

package/build/entry.d.ts

@@ -6,19 +6,28 @@ export interface OpenDBCallbacks<DBTypes extends DBSchema | unknown> {
      * @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 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<DBTypes>, oldVersion: number, newVersion: number | null, transaction: IDBPTransaction<DBTypes, StoreNames<DBTypes>[], 'versionchange'>): void;
+    upgrade?(database: IDBPDatabase<DBTypes>, oldVersion: number, newVersion: number | null, transaction: IDBPTransaction<DBTypes, StoreNames<DBTypes>[], '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?(): void;
+    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?(): void;
+    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.
@@ -36,8 +45,11 @@ export declare function openDB<DBTypes extends DBSchema | unknown = unknown>(nam
 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?(): void;
+    blocked?(currentVersion: number, event: IDBVersionChangeEvent): void;
 }
 /**
  * Delete a database.
@@ -45,15 +57,15 @@ export interface DeleteDBCallbacks {
  * @param name Name of the database.
  */
 export declare function deleteDB(name: string, { blocked }?: DeleteDBCallbacks): Promise<void>;
-export { unwrap, wrap } from './wrap-idb-value';
-declare type KeyToKeyNoIndex<T> = {
+export { unwrap, wrap } from './wrap-idb-value.js';
+type KeyToKeyNoIndex<T> = {
     [K in keyof T]: string extends K ? never : number extends K ? never : K;
 };
-declare type ValuesOf<T> = T extends {
+type ValuesOf<T> = T extends {
     [K in keyof T]: infer U;
 } ? U : never;
-declare type KnownKeys<T> = ValuesOf<KeyToKeyNoIndex<T>>;
-declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+type KnownKeys<T> = ValuesOf<KeyToKeyNoIndex<T>>;
+type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
 export interface DBSchema {
     [s: string]: DBSchemaValue;
 }
@@ -71,38 +83,38 @@ interface DBSchemaValue {
  *
  * @template DBTypes DB schema type, or unknown if the DB isn't typed.
  */
-export declare type StoreNames<DBTypes extends DBSchema | unknown> = DBTypes extends DBSchema ? KnownKeys<DBTypes> : string;
+export type StoreNames<DBTypes extends DBSchema | unknown> = DBTypes extends DBSchema ? KnownKeys<DBTypes> : 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 | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['value'] : any;
-declare type KeyPathToNestedObject<S extends string> = S extends `${infer T}.${infer U}` ? {
+export type StoreValue<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['value'] : any;
+type KeyPathToNestedObject<S extends string> = S extends `${infer T}.${infer U}` ? {
     [Key in T]: KeyPathToNestedObject<U>;
 } : S;
-declare type OptionalNested<Type, PathToKey> = PathToKey extends object ? Omit<Type, keyof PathToKey> & {
+type OptionalNested<Type, PathToKey> = PathToKey extends object ? Omit<Type, keyof PathToKey> & {
     [Key in Extract<keyof PathToKey, keyof Type>]: OptionalNested<Type[Key], PathToKey[Key]>;
 } : PathToKey extends keyof Type ? Omit<Type, PathToKey> & {
     [Key in PathToKey]?: Type[Key];
 } : never;
-declare type ValueWithOptionalKeyPath<Value extends unknown, KeyPath extends string> = OptionalNested<Value, KeyPathToNestedObject<KeyPath>>;
-export declare type StoreValueWithOptionalKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['autoIncrementKeyPath'] extends string ? (ValueWithOptionalKeyPath<DBTypes[StoreName]['value'], DBTypes[StoreName]['autoIncrementKeyPath']>) : StoreValue<DBTypes, StoreName> : any;
+type ValueWithOptionalKeyPath<Value extends unknown, KeyPath extends string> = OptionalNested<Value, KeyPathToNestedObject<KeyPath>>;
+export type StoreValueWithOptionalKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['autoIncrementKeyPath'] extends string ? (ValueWithOptionalKeyPath<DBTypes[StoreName]['value'], DBTypes[StoreName]['autoIncrementKeyPath']>) : StoreValue<DBTypes, StoreName> : 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 | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['key'] : IDBValidKey;
+export type StoreKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = 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 | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? keyof DBTypes[StoreName]['indexes'] : string;
+export type IndexNames<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? keyof DBTypes[StoreName]['indexes'] & string : string;
 /**
  * Extract the types of indexes in certain object stores from the DB schema type.
  *
@@ -110,10 +122,13 @@ export declare type IndexNames<DBTypes extends DBSchema | unknown, StoreName ext
  * @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<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName>> = DBTypes extends DBSchema ? IndexName extends keyof DBTypes[StoreName]['indexes'] ? DBTypes[StoreName]['indexes'][IndexName] : IDBValidKey : IDBValidKey;
-declare type CursorSource<DBTypes extends DBSchema | unknown, TxStores extends ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown, Mode extends IDBTransactionMode = 'readonly'> = IndexName extends IndexNames<DBTypes, StoreName> ? IDBPIndex<DBTypes, TxStores, StoreName, IndexName, Mode> : IDBPObjectStore<DBTypes, TxStores, StoreName, Mode>;
-declare type CursorKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown> = IndexName extends IndexNames<DBTypes, StoreName> ? IndexKey<DBTypes, StoreName, IndexName> : StoreKey<DBTypes, StoreName>;
-declare type IDBPDatabaseExtends = Omit<IDBDatabase, 'createObjectStore' | 'deleteObjectStore' | 'transaction' | 'objectStoreNames'>;
+export type IndexKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName>> = DBTypes extends DBSchema ? IndexName extends keyof DBTypes[StoreName]['indexes'] ? DBTypes[StoreName]['indexes'][IndexName] : IDBValidKey : IDBValidKey;
+type CursorSource<DBTypes extends DBSchema | unknown, TxStores extends ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown, Mode extends IDBTransactionMode = 'readonly'> = IndexName extends IndexNames<DBTypes, StoreName> ? IDBPIndex<DBTypes, TxStores, StoreName, IndexName, Mode> : IDBPObjectStore<DBTypes, TxStores, StoreName, Mode>;
+type CursorKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown> = IndexName extends IndexNames<DBTypes, StoreName> ? IndexKey<DBTypes, StoreName, IndexName> : StoreKey<DBTypes, StoreName>;
+type IDBPDatabaseExtends = Omit<IDBDatabase, 'createObjectStore' | 'deleteObjectStore' | 'transaction' | 'objectStoreNames'>;
+export type DOMStringListSymbolIteratorType = DOMStringList extends {
+    [Symbol.iterator](): infer R;
+} ? R : IterableIterator<string>;
 /**
  * A variation of DOMStringList with precise string types
  */
@@ -121,7 +136,11 @@ export interface TypedDOMStringList<T extends string> extends DOMStringList {
     contains(string: T): boolean;
     item(index: number): T | null;
     [index: number]: T;
-    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * To resolve https://github.com/jakearchibald/idb/issues/327,
+     * and for compatibility with TypeScript >= 5.6 with ArrayIterator.
+     */
+    [Symbol.iterator](): IterableIterator<string> extends DOMStringListSymbolIteratorType ? IterableIterator<T> : DOMStringListSymbolIteratorType & Iterator<T>;
 }
 interface IDBTransactionOptions {
     /**
@@ -144,10 +163,12 @@ export interface IDBPDatabase<DBTypes extends DBSchema | unknown = unknown> exte
      *
      * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
      */
-    createObjectStore<Name extends StoreNames<DBTypes>>(name: Name, optionalParameters?: DBTypes extends DBSchema ? DBTypes[Name]['autoIncrementKeyPath'] extends string ? (IDBObjectStoreParameters & {
-        autoIncrement: true;
-        keyPath: DBTypes[Name]['autoIncrementKeyPath'];
-    }) : IDBObjectStoreParameters : IDBObjectStoreParameters): IDBPObjectStore<DBTypes, ArrayLike<StoreNames<DBTypes>>, Name, 'versionchange'>;
+    createObjectStore<Name extends StoreNames<DBTypes>>(name: Name, ...args: DBTypes extends DBSchema ? DBTypes[Name]['autoIncrementKeyPath'] extends string ? [
+        optionalParameters: (IDBObjectStoreParameters & {
+            autoIncrement: true;
+            keyPath: DBTypes[Name]['autoIncrementKeyPath'];
+        })
+    ] : [optionalParameters?: IDBObjectStoreParameters] : [optionalParameters?: IDBObjectStoreParameters]): IDBPObjectStore<DBTypes, ArrayLike<StoreNames<DBTypes>>, Name, 'versionchange'>;
     /**
      * Deletes the object store with the given name.
      *
@@ -326,7 +347,7 @@ export interface IDBPDatabase<DBTypes extends DBSchema | unknown = unknown> exte
      */
     put<Name extends StoreNames<DBTypes>>(storeName: Name, value: StoreValueWithOptionalKey<DBTypes, Name>, key?: StoreKey<DBTypes, Name> | IDBKeyRange): Promise<StoreKey<DBTypes, Name>>;
 }
-declare type IDBPTransactionExtends = Omit<IDBTransaction, 'db' | 'objectStore' | 'objectStoreNames'>;
+type IDBPTransactionExtends = Omit<IDBTransaction, 'db' | 'objectStore' | 'objectStoreNames'>;
 export interface IDBPTransaction<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPTransactionExtends {
     /**
      * The transaction's mode.
@@ -353,7 +374,7 @@ export interface IDBPTransaction<DBTypes extends DBSchema | unknown = unknown, T
      */
     objectStore<StoreName extends TxStores[number]>(name: StoreName): IDBPObjectStore<DBTypes, TxStores, StoreName, Mode>;
 }
-declare type IDBPObjectStoreExtends = Omit<IDBObjectStore, 'transaction' | 'add' | 'clear' | 'count' | 'createIndex' | 'delete' | 'get' | 'getAll' | 'getAllKeys' | 'getKey' | 'index' | 'openCursor' | 'openKeyCursor' | 'put' | 'indexNames'>;
+type IDBPObjectStoreExtends = Omit<IDBObjectStore, 'transaction' | 'add' | 'clear' | 'count' | 'createIndex' | 'delete' | 'get' | 'getAll' | 'getAllKeys' | 'getKey' | 'index' | 'openCursor' | 'openKeyCursor' | 'put' | 'indexNames'>;
 export interface IDBPObjectStore<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPObjectStoreExtends {
     /**
      * The names of indexes in the store.
@@ -453,7 +474,7 @@ export interface IDBPObjectStore<DBTypes extends DBSchema | unknown = unknown, T
      */
     iterate(query?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, unknown, Mode>>;
 }
-declare type IDBPIndexExtends = Omit<IDBIndex, 'objectStore' | 'count' | 'get' | 'getAll' | 'getAllKeys' | 'getKey' | 'openCursor' | 'openKeyCursor'>;
+type IDBPIndexExtends = Omit<IDBIndex, 'objectStore' | 'count' | 'get' | 'getAll' | 'getAllKeys' | 'getKey' | 'openCursor' | 'openKeyCursor'>;
 export interface IDBPIndex<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> = IndexNames<DBTypes, StoreName>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPIndexExtends {
     /**
      * The IDBObjectStore the index belongs to.
@@ -521,7 +542,7 @@ export interface IDBPIndex<DBTypes extends DBSchema | unknown = unknown, TxStore
      */
     iterate(query?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
 }
-declare type IDBPCursorExtends = Omit<IDBCursor, 'key' | 'primaryKey' | 'source' | 'advance' | 'continue' | 'continuePrimaryKey' | 'delete' | 'update'>;
+type IDBPCursorExtends = Omit<IDBCursor, 'key' | 'primaryKey' | 'source' | 'advance' | 'continue' | 'continuePrimaryKey' | 'delete' | 'update'>;
 export interface IDBPCursor<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorExtends {
     /**
      * The key of the current index or object store item.
@@ -573,7 +594,7 @@ export interface IDBPCursor<DBTypes extends DBSchema | unknown = unknown, TxStor
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<IDBPCursorIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
 }
-declare type IDBPCursorIteratorValueExtends<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit<IDBPCursor<DBTypes, TxStores, StoreName, IndexName, Mode>, 'advance' | 'continue' | 'continuePrimaryKey'>;
+type IDBPCursorIteratorValueExtends<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit<IDBPCursor<DBTypes, TxStores, StoreName, IndexName, Mode>, 'advance' | 'continue' | 'continuePrimaryKey'>;
 export interface IDBPCursorIteratorValue<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorIteratorValueExtends<DBTypes, TxStores, StoreName, IndexName, Mode> {
     /**
      * Advances the cursor a given number of records.
@@ -605,7 +626,7 @@ export interface IDBPCursorWithValue<DBTypes extends DBSchema | unknown = unknow
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
 }
-declare type IDBPCursorWithValueIteratorValueExtends<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit<IDBPCursorWithValue<DBTypes, TxStores, StoreName, IndexName, Mode>, 'advance' | 'continue' | 'continuePrimaryKey'>;
+type IDBPCursorWithValueIteratorValueExtends<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit<IDBPCursorWithValue<DBTypes, TxStores, StoreName, IndexName, Mode>, 'advance' | 'continue' | 'continuePrimaryKey'>;
 export interface IDBPCursorWithValueIteratorValue<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorWithValueIteratorValueExtends<DBTypes, TxStores, StoreName, IndexName, Mode> {
     /**
      * Advances the cursor a given number of records.

package/build/index.cjs

@@ -1,8 +1,163 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
 
-var wrapIdbValue = require('./wrap-idb-value.cjs');
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+    return (idbProxyableTypes ||
+        (idbProxyableTypes = [
+            IDBDatabase,
+            IDBObjectStore,
+            IDBIndex,
+            IDBCursor,
+            IDBTransaction,
+        ]));
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+    return (cursorAdvanceMethods ||
+        (cursorAdvanceMethods = [
+            IDBCursor.prototype.advance,
+            IDBCursor.prototype.continue,
+            IDBCursor.prototype.continuePrimaryKey,
+        ]));
+}
+const transactionDoneMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+    const promise = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            request.removeEventListener('success', success);
+            request.removeEventListener('error', error);
+        };
+        const success = () => {
+            resolve(wrap(request.result));
+            unlisten();
+        };
+        const error = () => {
+            reject(request.error);
+            unlisten();
+        };
+        request.addEventListener('success', success);
+        request.addEventListener('error', error);
+    });
+    // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
+    // is because we create many promises from a single IDBRequest.
+    reverseTransformCache.set(promise, request);
+    return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+    // Early bail if we've already created a done promise for this transaction.
+    if (transactionDoneMap.has(tx))
+        return;
+    const done = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            tx.removeEventListener('complete', complete);
+            tx.removeEventListener('error', error);
+            tx.removeEventListener('abort', error);
+        };
+        const complete = () => {
+            resolve();
+            unlisten();
+        };
+        const error = () => {
+            reject(tx.error || new DOMException('AbortError', 'AbortError'));
+            unlisten();
+        };
+        tx.addEventListener('complete', complete);
+        tx.addEventListener('error', error);
+        tx.addEventListener('abort', error);
+    });
+    // Cache it for later retrieval.
+    transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+    get(target, prop, receiver) {
+        if (target instanceof IDBTransaction) {
+            // Special handling for transaction.done.
+            if (prop === 'done')
+                return transactionDoneMap.get(target);
+            // Make tx.store return the only store in the transaction, or undefined if there are many.
+            if (prop === 'store') {
+                return receiver.objectStoreNames[1]
+                    ? undefined
+                    : receiver.objectStore(receiver.objectStoreNames[0]);
+            }
+        }
+        // Else transform whatever we get back.
+        return wrap(target[prop]);
+    },
+    set(target, prop, value) {
+        target[prop] = value;
+        return true;
+    },
+    has(target, prop) {
+        if (target instanceof IDBTransaction &&
+            (prop === 'done' || prop === 'store')) {
+            return true;
+        }
+        return prop in target;
+    },
+};
+function replaceTraps(callback) {
+    idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+    // Due to expected object equality (which is enforced by the caching in `wrap`), we
+    // only create one new func per func.
+    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+    // with real promises, so each advance methods returns a new promise for the cursor object, or
+    // undefined if the end of the cursor has been reached.
+    if (getCursorAdvanceMethods().includes(func)) {
+        return function (...args) {
+            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+            // the original object.
+            func.apply(unwrap(this), args);
+            return wrap(this.request);
+        };
+    }
+    return function (...args) {
+        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+        // the original object.
+        return wrap(func.apply(unwrap(this), args));
+    };
+}
+function transformCachableValue(value) {
+    if (typeof value === 'function')
+        return wrapFunction(value);
+    // This doesn't return, it just creates a 'done' promise for the transaction,
+    // which is later returned for transaction.done (see idbObjectHandler).
+    if (value instanceof IDBTransaction)
+        cacheDonePromiseForTransaction(value);
+    if (instanceOfAny(value, getIdbProxyableTypes()))
+        return new Proxy(value, idbProxyTraps);
+    // Return the same value back if we're not going to transform it.
+    return value;
+}
+function wrap(value) {
+    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+    if (value instanceof IDBRequest)
+        return promisifyRequest(value);
+    // If we've already transformed this value before, reuse the transformed value.
+    // This is faster, but it also provides object equality.
+    if (transformCache.has(value))
+        return transformCache.get(value);
+    const newValue = transformCachableValue(value);
+    // Not all types are transformed.
+    // These may be primitive types, so they can't be WeakMap keys.
+    if (newValue !== value) {
+        transformCache.set(value, newValue);
+        reverseTransformCache.set(newValue, value);
+    }
+    return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
 
 /**
  * Open a database.
@@ -13,20 +168,24 @@ var wrapIdbValue = require('./wrap-idb-value.cjs');
  */
 function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
     const request = indexedDB.open(name, version);
-    const openPromise = wrapIdbValue.wrap(request);
+    const openPromise = wrap(request);
     if (upgrade) {
         request.addEventListener('upgradeneeded', (event) => {
-            upgrade(wrapIdbValue.wrap(request.result), event.oldVersion, event.newVersion, wrapIdbValue.wrap(request.transaction));
+            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
         });
     }
-    if (blocked)
-        request.addEventListener('blocked', () => blocked());
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event.newVersion, event));
+    }
     openPromise
         .then((db) => {
         if (terminated)
             db.addEventListener('close', () => terminated());
-        if (blocking)
-            db.addEventListener('versionchange', () => blocking());
+        if (blocking) {
+            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
+        }
     })
         .catch(() => { });
     return openPromise;
@@ -38,9 +197,12 @@ function openDB(name, version, { blocked, upgrade, blocking, terminated } = {})
  */
 function deleteDB(name, { blocked } = {}) {
     const request = indexedDB.deleteDatabase(name);
-    if (blocked)
-        request.addEventListener('blocked', () => blocked());
-    return wrapIdbValue.wrap(request).then(() => undefined);
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event));
+    }
+    return wrap(request).then(() => undefined);
 }
 
 const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
@@ -82,13 +244,67 @@ function getMethod(target, prop) {
     cachedMethods.set(prop, method);
     return method;
 }
-wrapIdbValue.replaceTraps((oldTraps) => ({
+replaceTraps((oldTraps) => ({
     ...oldTraps,
     get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
     has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
 }));
 
-exports.unwrap = wrapIdbValue.unwrap;
-exports.wrap = wrapIdbValue.wrap;
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+    get(target, prop) {
+        if (!advanceMethodProps.includes(prop))
+            return target[prop];
+        let cachedFunc = methodMap[prop];
+        if (!cachedFunc) {
+            cachedFunc = methodMap[prop] = function (...args) {
+                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+            };
+        }
+        return cachedFunc;
+    },
+};
+async function* iterate(...args) {
+    // tslint:disable-next-line:no-this-assignment
+    let cursor = this;
+    if (!(cursor instanceof IDBCursor)) {
+        cursor = await cursor.openCursor(...args);
+    }
+    if (!cursor)
+        return;
+    cursor = cursor;
+    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+    // Map this double-proxy back to the original, so other cursor methods work.
+    reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+    while (cursor) {
+        yield proxiedCursor;
+        // If one of the advancing methods was not called, call continue().
+        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+        advanceResults.delete(proxiedCursor);
+    }
+}
+function isIteratorProp(target, prop) {
+    return ((prop === Symbol.asyncIterator &&
+        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||
+        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));
+}
+replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get(target, prop, receiver) {
+        if (isIteratorProp(target, prop))
+            return iterate;
+        return oldTraps.get(target, prop, receiver);
+    },
+    has(target, prop) {
+        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+    },
+}));
+
 exports.deleteDB = deleteDB;
 exports.openDB = openDB;
+exports.unwrap = unwrap;
+exports.wrap = wrap;

package/build/index.d.ts

@@ -1,2 +1,3 @@
-export * from './entry';
-import './database-extras';
+export * from './entry.js';
+import './database-extras.js';
+import './async-iterators.js';