indexeddbshim 11.0.0 → 12.0.0-pre.0

package/src/IDBRequest.js

@@ -14,9 +14,36 @@ const doneFlagGetters = ['result', 'error'];
 function IDBRequest () {
     throw new TypeError('Illegal constructor');
 }
-// eslint-disable-next-line func-name-matching
+
+/**
+ * @typedef {IDBRequest & EventTarget & import('eventtargeter').ShimEventTarget & {
+ *   transaction: import('./IDBTransaction.js').IDBTransactionFull,
+ *   __done: boolean,
+ *   __result: import('./IDBDatabase.js').IDBDatabaseFull|undefined,
+ *   __error: null|DOMException|Error,
+ *   __source: null|import('./IDBDatabase.js').IDBDatabaseFull|
+ *     import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *     import('./IDBIndex.js').IDBIndexFull,
+ *   __transaction: undefined|null|
+ *     import('./IDBTransaction.js').IDBTransactionFull,
+ *   addLateEventListener: (ev: string, listener: (e: Event & {
+ *     __legacyOutputDidListenersThrowError: boolean
+ *   }) => void) => void
+ *   addDefaultEventListener: (ev: string, listener: (e: Event & {
+ *     __legacyOutputDidListenersThrowError: boolean
+ *   }) => void) => void
+ * }} IDBRequestFull
+ */
+
+/* eslint-disable func-name-matching -- Polyfill */
+/**
+ * @class
+ * @this {IDBRequestFull}
+ */
 IDBRequest.__super = function IDBRequest () {
+    // @ts-expect-error It's ok
     this[Symbol.toStringTag] = 'IDBRequest';
+    // @ts-expect-error Part of `ShimEventTarget`
     this.__setOptions({
         legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
     });
@@ -39,6 +66,10 @@ IDBRequest.__super = function IDBRequest () {
     });
     util.defineReadonlyProperties(this, readonlyProperties, {
         readyState: {
+            /**
+             * @this {IDBRequestFull}
+             * @returns {"done"|"pending"}
+             */
             get readyState () {
                 return this.__done ? 'done' : 'pending';
             }
@@ -50,14 +81,24 @@ IDBRequest.__super = function IDBRequest () {
     this.__error = this.__source = this.__transaction = null;
     this.__done = false;
 };
+/* eslint-enable func-name-matching -- Polyfill */
 
+/**
+ * @returns {IDBRequestFull}
+ */
 IDBRequest.__createInstance = function () {
+    // @ts-expect-error Casting this causes other errors
     return new IDBRequest.__super();
 };
 
+// @ts-expect-error It's ok
 IDBRequest.prototype = EventTargetFactory.createInstance({extraProperties: ['debug']});
 IDBRequest.prototype[Symbol.toStringTag] = 'IDBRequestPrototype';
 
+/**
+ * @this {IDBRequestFull}
+ * @returns {import('./IDBTransaction.js').IDBTransactionFull|null|undefined}
+ */
 IDBRequest.prototype.__getParent = function () {
     if (this.toString() === '[object IDBOpenDBRequest]') {
         return null;
@@ -85,6 +126,10 @@ Object.defineProperty(IDBRequest, 'prototype', {
 
 const openListeners = ['onblocked', 'onupgradeneeded'];
 
+/**
+ * @typedef {IDBRequestFull & IDBOpenDBRequest & {}} IDBOpenDBRequestFull
+ */
+
 /**
  * The IDBOpenDBRequest called when a database is opened.
  * @class
@@ -92,6 +137,8 @@ const openListeners = ['onblocked', 'onupgradeneeded'];
 function IDBOpenDBRequest () {
     throw new TypeError('Illegal constructor');
 }
+
+// @ts-expect-error It's ok
 IDBOpenDBRequest.prototype = Object.create(IDBRequest.prototype);
 
 Object.defineProperty(IDBOpenDBRequest.prototype, 'constructor', {
@@ -102,11 +149,20 @@ Object.defineProperty(IDBOpenDBRequest.prototype, 'constructor', {
 });
 
 const IDBOpenDBRequestAlias = IDBOpenDBRequest;
+/**
+ * @returns {IDBRequestFull & IDBOpenDBRequest}
+ */
 IDBOpenDBRequest.__createInstance = function () {
+    /**
+     * @class
+     * @this {IDBOpenDBRequestFull}
+     */
     function IDBOpenDBRequest () {
         IDBRequest.__super.call(this);
 
+        // @ts-expect-error It's ok
         this[Symbol.toStringTag] = 'IDBOpenDBRequest';
+        // @ts-expect-error It's ok
         this.__setOptions({
             legacyOutputDidListenersThrowFlag: true, // Event hook for IndexedB
             extraProperties: ['oldVersion', 'newVersion', 'debug']
@@ -114,6 +170,8 @@ IDBOpenDBRequest.__createInstance = function () {
         util.defineListenerProperties(this, openListeners);
     }
     IDBOpenDBRequest.prototype = IDBOpenDBRequestAlias.prototype;
+
+    // @ts-expect-error It's ok
     return new IDBOpenDBRequest();
 };
 

package/src/IDBTransaction.js

@@ -1,5 +1,5 @@
 import {EventTargetFactory} from 'eventtargeter';
-import SyncPromise from 'sync-promise';
+import SyncPromise from 'sync-promise-expanded';
 import {createEvent} from './Event.js';
 import {logError, findError, webSQLErrback, createDOMException} from './DOMException.js';
 import {IDBRequest} from './IDBRequest.js';
@@ -11,23 +11,101 @@ let uniqueID = 0;
 const listeners = ['onabort', 'oncomplete', 'onerror'];
 const readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
 
-/* eslint-disable jsdoc/check-param-names */
+/**
+ * @typedef {number} Integer
+ */
+
+/**
+ * @typedef {{
+ *   op: SQLCallback,
+ *   args: ObjectArray,
+ *   req: import('./IDBRequest.js').IDBRequestFull|null
+ * }} RequestInfo
+ */
+
+/**
+ * @typedef {EventTarget & {
+ *   mode: "readonly"|"readwrite"|"versionchange",
+ *   db: import('./IDBDatabase.js').IDBDatabaseFull,
+ *   on__abort: () => void,
+ *   on__complete: () => void,
+ *   on__beforecomplete: (ev: Event & {
+ *     complete: () => void
+ *   }) => void,
+ *   on__preabort: () => void,
+ *   __abortTransaction: (err: Error|DOMException|null) => void,
+ *   __executeRequests: () => void,
+ *   __tx: SQLTransaction,
+ *   __id: Integer,
+ *   __active: boolean,
+ *   __running: boolean,
+ *   __errored: boolean,
+ *   __requests: RequestInfo[],
+ *   __db: import('./IDBDatabase.js').IDBDatabaseFull,
+ *   __mode: string,
+ *   __error: null|DOMException|Error,
+ *   __objectStoreNames: import('./DOMStringList.js').DOMStringListFull,
+ *   __storeHandles: {
+ *     [key: string]: import('./IDBObjectStore.js').IDBObjectStoreFull
+ *   },
+ *   __requestsFinished: boolean,
+ *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
+ *   __transactionEndCallback: () => void,
+ *   __transactionFinished: boolean,
+ *   __completed: boolean,
+ *   __internal: boolean,
+ *   __abortFinished: boolean,
+ *   __createRequest: (
+ *     source: import('./IDBDatabase.js').IDBDatabaseFull|
+ *       import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *       import('./IDBIndex.js').IDBIndexFull|
+ *       import('./IDBCursor.js').IDBCursorFull
+ *   ) => import('./IDBRequest.js').IDBRequestFull,
+ *   __pushToQueue: (
+ *     request: import('./IDBRequest.js').IDBRequestFull|null,
+ *     callback: SQLCallback,
+ *     args?: ObjectArray
+ *   ) => void,
+ *   __assertActive: () => void,
+ *   __addNonRequestToTransactionQueue: (
+ *     callback: SQLCallback,
+ *     args?: ObjectArray
+ *   ) => void
+ *   __addToTransactionQueue: (
+ *     callback: SQLCallback,
+ *     args: ObjectArray|undefined,
+ *     source: import('./IDBDatabase.js').IDBDatabaseFull|
+ *       import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *       import('./IDBIndex.js').IDBIndexFull|
+ *       import('./IDBCursor.js').IDBCursorFull
+ *   ) => import('./IDBRequest.js').IDBRequestFull
+ *   __assertWritable: () => void,
+ * }} IDBTransactionFull
+ */
+
 /**
  * The IndexedDB Transaction.
  * @see http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBTransaction
- * @param {IDBDatabase} db
- * @param {string[]} storeNames
- * @param {string} mode
  * @class
  */
 function IDBTransaction () {
-    /* eslint-enable jsdoc/check-param-names */
     throw new TypeError('Illegal constructor');
 }
 const IDBTransactionAlias = IDBTransaction;
+/**
+ * @param {import('./IDBDatabase.js').IDBDatabaseFull} db
+ * @param {import('./DOMStringList.js').DOMStringListFull} storeNames
+ * @param {string} mode
+ * @returns {IDBTransactionFull}
+ */
 IDBTransaction.__createInstance = function (db, storeNames, mode) {
+    /**
+     * @class
+     * @this {IDBTransactionFull}
+     */
     function IDBTransaction () {
         const me = this;
+        // @ts-expect-error It's ok
         me[Symbol.toStringTag] = 'IDBTransaction';
         util.defineReadonlyProperties(me, readonlyProperties);
         me.__id = ++uniqueID; // for debugging simultaneous transactions
@@ -39,6 +117,7 @@ IDBTransaction.__createInstance = function (db, storeNames, mode) {
         me.__mode = mode;
         me.__db = db;
         me.__error = null;
+        // @ts-expect-error Part of `ShimEventTarget`
         me.__setOptions({
             legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
         });
@@ -55,18 +134,31 @@ IDBTransaction.__createInstance = function (db, storeNames, mode) {
         setTimeout(() => { me.__executeRequests(); }, 0);
     }
     IDBTransaction.prototype = IDBTransactionAlias.prototype;
+
+    // @ts-expect-error It's ok
     return new IDBTransaction();
 };
 
+// @ts-expect-error It's ok
 IDBTransaction.prototype = EventTargetFactory.createInstance({
     defaultSync: true,
     // Ensure EventTarget preserves our properties
     extraProperties: ['complete']
 });
 
+/**
+ *
+ * @param {boolean} err
+ * @param {(bool: boolean) => void} cb
+ * @returns {void}
+ */
 IDBTransaction.prototype.__transFinishedCb = function (err, cb) {
     cb(Boolean(err));
 };
+/**
+ * @this {IDBTransactionFull}
+ * @returns {void}
+ */
 IDBTransaction.prototype.__executeRequests = function () {
     const me = this;
     if (me.__running) {
@@ -79,8 +171,19 @@ IDBTransaction.prototype.__executeRequests = function () {
     me.db.__db[me.mode === 'readonly' ? 'readTransaction' : 'transaction']( // `readTransaction` is optimized, at least in `node-websql`
         function executeRequests (tx) {
             me.__tx = tx;
-            let q = null, i = -1;
-
+            /** @type {RequestInfo} */
+            let q,
+                i = -1;
+
+            /**
+             * @typedef {any} IDBRequestResult
+             */
+
+            /**
+             * @param {IDBRequestResult} [result]
+             * @param {import('./IDBRequest.js').IDBRequestFull} [req]
+             * @returns {void}
+             */
             function success (result, req) {
                 if (me.__errored || me.__requestsFinished) {
                     // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
@@ -89,6 +192,9 @@ IDBTransaction.prototype.__executeRequests = function () {
                 if (req) {
                     q.req = req; // Need to do this in case of cursors
                 }
+                if (!q.req) { // TS guard
+                    return;
+                }
                 if (q.req.__done) { // Avoid continuing with aborted requests
                     return;
                 }
@@ -109,6 +215,10 @@ IDBTransaction.prototype.__executeRequests = function () {
                 executeNextRequest();
             }
 
+            /**
+             * @param {[tx: SQLTransaction|DOMException|Error|SQLError, err?: SQLError]} args
+             * @returns {void}
+             */
             function error (...args /* tx, err */) {
                 if (me.__errored || me.__requestsFinished) {
                     // We've already called "onerror", "onabort", or thrown within
@@ -118,7 +228,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 if (q.req && q.req.__done) { // Avoid continuing with aborted requests
                     return;
                 }
-                const err = findError(args);
+                const err = /** @type {Error|DOMException} */ (findError(args));
                 if (!q.req) {
                     me.__abortTransaction(err);
                     return;
@@ -134,6 +244,9 @@ IDBTransaction.prototype.__executeRequests = function () {
                     }
                 });
                 q.req.addDefaultEventListener('error', function () {
+                    if (!q.req) { // TS guard
+                        return;
+                    }
                     me.__abortTransaction(q.req.__error);
                 });
 
@@ -148,6 +261,9 @@ IDBTransaction.prototype.__executeRequests = function () {
                 }
             }
 
+            /**
+             * @returns {void}
+             */
             function executeNextRequest () {
                 if (me.__errored || me.__requestsFinished) {
                     // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
@@ -172,7 +288,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                         }
                         q.op(tx, q.args, success, error, executeNextRequest);
                     } catch (e) {
-                        error(e);
+                        error(/** @type {Error} */ (e));
                     }
                 }
             }
@@ -180,10 +296,11 @@ IDBTransaction.prototype.__executeRequests = function () {
             executeNextRequest();
         },
         function webSQLError (webSQLErr) {
+            // @ts-expect-error It's ok
             if (webSQLErr === true) { // Not a genuine SQL error
                 return;
             }
-            const err = webSQLErrback(webSQLErr);
+            const err = webSQLErrback(/** @type {SQLError} */ (webSQLErr));
             me.__abortTransaction(err);
         },
         function () {
@@ -219,10 +336,17 @@ IDBTransaction.prototype.__executeRequests = function () {
         }
     );
 
+    /**
+     * @returns {void}
+     */
     function requestsFinished () {
         me.__active = false;
         me.__requestsFinished = true;
 
+        /**
+         * @throws {Error}
+         * @returns {void}
+         */
         function complete () {
             me.__completed = true;
             CFG.DEBUG && console.log('Transaction completed');
@@ -255,7 +379,9 @@ IDBTransaction.prototype.__executeRequests = function () {
             complete();
             return;
         }
-        const ev = createEvent('__beforecomplete');
+        const ev = /** @type {Event & {complete: () => void}} */ (
+            createEvent('__beforecomplete')
+        );
         ev.complete = complete;
         me.dispatchEvent(ev);
     }
@@ -264,9 +390,9 @@ IDBTransaction.prototype.__executeRequests = function () {
 /**
  * Creates a new IDBRequest for the transaction.
  * NOTE: The transaction is not queued until you call {@link IDBTransaction#__pushToQueue}.
- * @param {IDBDatabase} source
+ * @param {import('./IDBDatabase.js').IDBDatabaseFull} source
+ * @this {IDBTransactionFull}
  * @returns {IDBRequest}
- * @protected
  */
 IDBTransaction.prototype.__createRequest = function (source) {
     const me = this;
@@ -276,13 +402,25 @@ IDBTransaction.prototype.__createRequest = function (source) {
     return request;
 };
 
+/**
+ * @typedef {(
+ *   tx: SQLTransaction,
+ *   args: ObjectArray,
+ *   success: (result?: any, req?: import('./IDBRequest.js').IDBRequestFull) => void,
+ *   error: (tx: SQLTransaction|Error|DOMException|SQLError, err?: SQLError) => void,
+ *   executeNextRequest?: () => void
+ * ) => void} SQLCallback
+ */
+
 /**
  * Adds a callback function to the transaction queue.
- * @param {function} callback
- * @param {*} args
- * @param {IDBDatabase} source
- * @returns {IDBRequest}
- * @protected
+ * @param {SQLCallback} callback
+ * @param {ObjectArray} args
+ * @param {import('./IDBDatabase.js').IDBDatabaseFull|
+ *   import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *   import('./IDBIndex.js').IDBIndexFull} source
+ * @this {IDBTransactionFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
  */
 IDBTransaction.prototype.__addToTransactionQueue = function (callback, args, source) {
     const request = this.__createRequest(source);
@@ -293,22 +431,21 @@ IDBTransaction.prototype.__addToTransactionQueue = function (callback, args, sou
 /**
  * Adds a callback function to the transaction queue without generating a
  *   request.
- * @param {function} callback
- * @param {*} args
- * @param {IDBDatabase} source
+ * @param {SQLCallback} callback
+ * @param {ObjectArray} args
+ * @this {IDBTransactionFull}
  * @returns {void}
- * @protected
  */
-IDBTransaction.prototype.__addNonRequestToTransactionQueue = function (callback, args, source) {
+IDBTransaction.prototype.__addNonRequestToTransactionQueue = function (callback, args) {
     this.__pushToQueue(null, callback, args);
 };
 
 /**
  * Adds an IDBRequest to the transaction queue.
- * @param {IDBRequest} request
- * @param {function} callback
- * @param {*} args
- * @protected
+ * @param {import('./IDBRequest.js').IDBRequestFull|null} request
+ * @param {SQLCallback} callback
+ * @param {ObjectArray} args
+ * @this {IDBTransactionFull}
  * @returns {void}
  */
 IDBTransaction.prototype.__pushToQueue = function (request, callback, args) {
@@ -320,18 +457,31 @@ IDBTransaction.prototype.__pushToQueue = function (request, callback, args) {
     });
 };
 
+/**
+ * @throws {DOMException}
+ * @returns {void}
+ */
 IDBTransaction.prototype.__assertActive = function () {
     if (!this.__active) {
         throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
     }
 };
 
+/**
+ * @throws {DOMException}
+ * @this {IDBTransactionFull}
+ * @returns {void}
+ */
 IDBTransaction.prototype.__assertWritable = function () {
     if (this.mode === 'readonly') {
         throw createDOMException('ReadOnlyError', 'The transaction is read only');
     }
 };
 
+/**
+ * @this {IDBTransactionFull}
+ * @returns {void}
+ */
 IDBTransaction.prototype.__assertVersionChange = function () {
     IDBTransaction.__assertVersionChange(this);
 };
@@ -339,6 +489,7 @@ IDBTransaction.prototype.__assertVersionChange = function () {
 /**
  * Returns the specified object store.
  * @param {string} objectStoreName
+ * @this {IDBTransactionFull}
  * @returns {IDBObjectStore}
  */
 IDBTransaction.prototype.objectStore = function (objectStoreName) {
@@ -368,6 +519,12 @@ IDBTransaction.prototype.objectStore = function (objectStoreName) {
     return me.__storeHandles[objectStoreName];
 };
 
+/**
+ *
+ * @param {Error|DOMException|null} err
+ * @this {IDBTransactionFull}
+ * @returns {void}
+ */
 IDBTransaction.prototype.__abortTransaction = function (err) {
     const me = this;
     logError('Error', 'An error occurred in a transaction', err);
@@ -419,10 +576,15 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         }, 0);
     }
 
+    /**
+     * @param {SQLTransaction|null} [tx]
+     * @param {SQLResultSet|SQLError|{code: 0}} [errOrResult]
+     * @returns {void}
+     */
     function abort (tx, errOrResult) {
         if (!tx) {
             CFG.DEBUG && console.log('Rollback not possible due to missing transaction', me);
-        } else if (errOrResult && typeof errOrResult.code === 'number') {
+        } else if (errOrResult && 'code' in errOrResult && typeof errOrResult.code === 'number') {
             CFG.DEBUG && console.log('Rollback erred; feature is probably not supported as per WebSQL', me);
         } else {
             CFG.DEBUG && console.log('Rollback succeeded', me);
@@ -439,18 +601,27 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
             //  behaves first-in-first-out with the same timeout so we could
             //  just use a `forEach`.
             return promises.then(function () {
+                if (!q.req) { // TS guard
+                    throw new Error('Missing request');
+                }
                 q.req.__done = true;
                 q.req.__result = undefined;
                 q.req.__error = createDOMException('AbortError', 'A request was aborted (an unfinished request).');
                 const reqEvt = createEvent('error', q.req.__error, {bubbles: true, cancelable: true});
-                return new SyncPromise(function (resolve) {
-                    setTimeout(() => {
-                        q.req.dispatchEvent(reqEvt); // No need to catch errors
-                        resolve();
-                    });
-                });
+                return new SyncPromise(
+                    /** @type {() => void} */
+                    (resolve) => {
+                        setTimeout(() => {
+                            if (!q.req) { // TS guard
+                                throw new Error('Missing request');
+                            }
+                            q.req.dispatchEvent(reqEvt); // No need to catch errors
+                            resolve();
+                        });
+                    }
+                );
             });
-        }, SyncPromise.resolve()).then(function () { // Also works when there are no pending requests
+        }, SyncPromise.resolve(undefined)).then(function () { // Also works when there are no pending requests
             const evt = createEvent('abort', err, {bubbles: true, cancelable: false});
             setTimeout(() => {
                 me.__abortFinished = true;
@@ -478,7 +649,12 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                 return;
             }
             try {
-                me.__tx.executeSql('ROLLBACK', [], abort, abort); // Not working in some circumstances, even in Node
+                me.__tx.executeSql(
+                    'ROLLBACK',
+                    [],
+                    abort,
+                    /** @type {SQLStatementErrorCallback} */ (abort)
+                ); // Not working in some circumstances, even in Node
             } catch (err) {
                 // Browser errs when transaction has ended and since it most likely already erred here,
                 //   we call to abort
@@ -490,6 +666,10 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
     });
 };
 
+/**
+ * @this {IDBTransactionFull}
+ * @returns {void}
+ */
 IDBTransaction.prototype.abort = function () {
     const me = this;
     if (!(me instanceof IDBTransaction)) {
@@ -502,17 +682,34 @@ IDBTransaction.prototype.abort = function () {
 
 IDBTransaction.prototype[Symbol.toStringTag] = 'IDBTransactionPrototype';
 
+/**
+ *
+ * @param {IDBTransactionFull|undefined} tx
+ * @returns {void}
+ */
 IDBTransaction.__assertVersionChange = function (tx) {
     if (!tx || tx.mode !== 'versionchange') {
         throw createDOMException('InvalidStateError', 'Not a version transaction');
     }
 };
+/**
+ *
+ * @param {IDBTransactionFull} tx
+ * @throws {DOMException}
+ * @returns {void}
+ */
 IDBTransaction.__assertNotVersionChange = function (tx) {
     if (tx && tx.mode === 'versionchange') {
         throw createDOMException('InvalidStateError', 'Cannot be called during a version transaction');
     }
 };
 
+/**
+ *
+ * @param {IDBTransactionFull|undefined} tx
+ * @throws {DOMException}
+ * @returns {void}
+ */
 IDBTransaction.__assertNotFinished = function (tx) {
     if (!tx || tx.__completed || tx.__abortFinished || tx.__errored) {
         throw createDOMException('InvalidStateError', 'Transaction finished by commit or abort');
@@ -520,6 +717,11 @@ IDBTransaction.__assertNotFinished = function (tx) {
 };
 
 // object store methods behave differently: see https://github.com/w3c/IndexedDB/issues/192
+/**
+ *
+ * @param {IDBTransactionFull} tx
+ * @returns {void}
+ */
 IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
     try {
         IDBTransaction.__assertNotFinished(tx);
@@ -531,6 +733,12 @@ IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
     }
 };
 
+/**
+ *
+ * @param {IDBTransactionFull|undefined} tx
+ * @throws {DOMException}
+ * @returns {void}
+ */
 IDBTransaction.__assertActive = function (tx) {
     if (!tx || !tx.__active) {
         throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
@@ -539,7 +747,8 @@ IDBTransaction.__assertActive = function (tx) {
 
 /**
 * Used by our `EventTarget.prototype` library to implement bubbling/capturing.
-* @returns {IDBDatabase}
+ * @this {IDBTransactionFull}
+* @returns {import('./IDBDatabase.js').IDBDatabaseFull}
 */
 IDBTransaction.prototype.__getParent = function () {
     return this.db;