indexeddbshim 12.0.0 → 13.0.0

package/src/IDBObjectStore.js

@@ -1,4 +1,4 @@
-import SyncPromise from 'sync-promise';
+import SyncPromise from 'sync-promise-expanded';
 import {createDOMException} from './DOMException.js';
 import {IDBCursor, IDBCursorWithValue} from './IDBCursor.js';
 import {setSQLForKeyRange, convertValueToKeyRange} from './IDBKeyRange.js';
@@ -12,22 +12,63 @@ import CFG from './CFG.js';
 
 const readonlyProperties = ['keyPath', 'indexNames', 'transaction', 'autoIncrement'];
 
-/* eslint-disable jsdoc/check-param-names */
+/**
+ * @typedef {number} Integer
+ */
+
 /**
  * IndexedDB Object Store.
  * @see http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBObjectStore
- * @param {IDBObjectStoreProperties} storeProperties
- * @param {IDBTransaction} transaction
  * @class
  */
 function IDBObjectStore () {
-    /* eslint-enable jsdoc/check-param-names */
     throw new TypeError('Illegal constructor');
 }
 const IDBObjectStoreAlias = IDBObjectStore;
+
+/**
+ * @typedef {IDBObjectStore & {
+ *   name: string,
+ *   keyPath: import('./Key.js').KeyPath,
+ *   transaction?: import('./IDBTransaction.js').IDBTransactionFull,
+ *   indexNames: import('./DOMStringList.js').DOMStringListFull,
+ *   autoIncrement: boolean,
+ *   __autoIncrement: boolean,
+ *   __indexes: {[key: string]: import('./IDBIndex.js').IDBIndexFull},
+ *   __indexHandles: {[key: string]: import('./IDBIndex.js').IDBIndexFull},
+ *   __indexNames: import('./DOMStringList.js').DOMStringListFull,
+ *   __oldIndexNames: import('./DOMStringList.js').DOMStringListFull,
+ *   __transaction?: import('./IDBTransaction.js').IDBTransactionFull,
+ *   __name: string,
+ *   __keyPath: import('./Key.js').KeyPath,
+ *   __originalName: string,
+ *   __currentName: string,
+ *   __pendingName?: string,
+ *   __pendingDelete?: boolean,
+ *   __pendingCreate?: boolean,
+ *   __deleted?: boolean,
+ *   __cursors: (
+ *     import('./IDBCursor.js').IDBCursorFull|
+ *     import('./IDBCursor.js').IDBCursorWithValueFull
+ *   )[],
+ *   __idbdb: import('./IDBDatabase.js').IDBDatabaseFull,
+ * }} IDBObjectStoreFull
+ */
+
+/**
+ *
+ * @param {import('./IDBDatabase.js').IDBObjectStoreProperties} storeProperties
+ * @param {import('./IDBTransaction.js').IDBTransactionFull} [transaction]
+ * @returns {IDBObjectStoreFull}
+ */
 IDBObjectStore.__createInstance = function (storeProperties, transaction) {
+    /**
+     * @class
+     * @this {IDBObjectStoreFull}
+     */
     function IDBObjectStore () {
         const me = this;
+        // @ts-expect-error It's ok
         me[Symbol.toStringTag] = 'IDBObjectStore';
         util.defineReadonlyProperties(this, readonlyProperties);
         me.__name = me.__originalName = storeProperties.name;
@@ -44,7 +85,7 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
         me.__indexNames = DOMStringList.__createInstance();
         const {indexList} = storeProperties;
         for (const indexName in indexList) {
-            if (util.hasOwn(indexList, indexName)) {
+            if (Object.hasOwn(indexList, indexName)) {
                 const index = IDBIndex.__createInstance(me, indexList[indexName]);
                 me.__indexes[index.name] = index;
                 if (!index.__deleted) {
@@ -61,9 +102,18 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
         Object.defineProperty(this, 'name', {
             enumerable: false,
             configurable: false,
+            /**
+             * @this {IDBObjectStoreFull}
+             * @returns {string}
+             */
             get () {
                 return this.__name;
             },
+            /**
+             * @param {string} name
+             * @this {IDBObjectStoreFull}
+             * @returns {void}
+             */
             set (name) {
                 const me = this;
                 name = util.convertToDOMString(name);
@@ -87,41 +137,51 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
 
                 me.__idbdb.objectStoreNames.splice(me.__idbdb.objectStoreNames.indexOf(oldName), 1, name);
 
-                const oldHandle = me.transaction.__storeHandles[oldName];
+                const oldHandle = /** @type {IDBObjectStoreFull} */ (
+                    /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+                        me.transaction
+                    ).__storeHandles[oldName]
+                );
                 oldHandle.__name = name; // Fix old references
-                me.transaction.__storeHandles[name] = oldHandle; // Ensure new reference accessible
+                /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+                    me.transaction
+                ).__storeHandles[name] = oldHandle; // Ensure new reference accessible
 
                 me.__pendingName = oldName;
 
                 const sql = 'UPDATE __sys__ SET "name" = ? WHERE "name" = ?';
                 const sqlValues = [util.escapeSQLiteStatement(name), util.escapeSQLiteStatement(oldName)];
-                CFG.DEBUG && console.log(sql, sqlValues);
-                me.transaction.__addNonRequestToTransactionQueue(function objectStoreClear (tx, args, success, error) {
-                    tx.executeSql(sql, sqlValues, function (tx, data) {
+                if (CFG.DEBUG) { console.log(sql, sqlValues); }
+                /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+                    me.transaction
+                ).__addNonRequestToTransactionQueue(function objectStoreClear (tx, args, success, error) {
+                    tx.executeSql(sql, sqlValues, function (tx) {
                         // This SQL preserves indexes per https://www.sqlite.org/lang_altertable.html
                         const sql = 'ALTER TABLE ' + util.escapeStoreNameForSQL(oldName) + ' RENAME TO ' + util.escapeStoreNameForSQL(name);
-                        CFG.DEBUG && console.log(sql);
-                        tx.executeSql(sql, [], function (tx, data) {
+                        if (CFG.DEBUG) { console.log(sql); }
+                        tx.executeSql(sql, [], function () {
                             delete me.__pendingName;
                             success();
                         });
                     }, function (tx, err) {
                         error(err);
+                        return false;
                     });
                 });
             }
         });
     }
     IDBObjectStore.prototype = IDBObjectStoreAlias.prototype;
+
+    // @ts-expect-error It's ok
     return new IDBObjectStore();
 };
 
 /**
  * Clones an IDBObjectStore instance for a different IDBTransaction instance.
- * @param {IDBObjectStore} store
- * @param {IDBTransaction} transaction
- * @protected
- * @returns {IDBObjectStore}
+ * @param {IDBObjectStoreFull} store
+ * @param {import('./IDBTransaction.js').IDBTransactionFull} transaction
+ * @returns {IDBObjectStoreFull}
  */
 IDBObjectStore.__clone = function (store, transaction) {
     const newStore = IDBObjectStore.__createInstance({
@@ -133,23 +193,37 @@ IDBObjectStore.__clone = function (store, transaction) {
         cursors: store.__cursors
     }, transaction);
 
-    ['__indexes', '__indexNames', '__oldIndexNames', '__deleted', '__pendingDelete', '__pendingCreate', '__originalName'].forEach((p) => {
+    /** @type {const} */ ([
+        '__indexes', '__indexNames', '__oldIndexNames',
+        '__deleted', '__pendingDelete', '__pendingCreate', '__originalName'
+    ]).forEach((p) => {
+        // @ts-expect-error It's ok
         newStore[p] = store[p];
     });
     return newStore;
 };
 
+/**
+ *
+ * @param {IDBObjectStoreFull|import('./IDBIndex.js').IDBIndexFull} store
+ * @param {string} [msg]
+ * @throws {DOMException}
+ * @returns {void}
+ */
 IDBObjectStore.__invalidStateIfDeleted = function (store, msg) {
-    if (store.__deleted || store.__pendingDelete || (store.__pendingCreate && (store.transaction && store.transaction.__errored))) {
+    if (
+        store.__deleted || store.__pendingDelete || (store.__pendingCreate && (
+            'transaction' in store && store.transaction && store.transaction.__errored
+        ))
+    ) {
         throw createDOMException('InvalidStateError', msg || 'This store has been deleted');
     }
 };
 
 /**
  * Creates a new object store in the database.
- * @param {IDBDatabase} db
- * @param {IDBObjectStore} store
- * @protected
+ * @param {import('./IDBDatabase.js').IDBDatabaseFull} db
+ * @param {IDBObjectStoreFull} store
  * @returns {IDBObjectStore}
  */
 IDBObjectStore.__createObjectStore = function (db, store) {
@@ -160,7 +234,9 @@ IDBObjectStore.__createObjectStore = function (db, store) {
     db.objectStoreNames.push(storeName);
 
     // Add the object store to WebSQL
-    const transaction = db.__versionTransaction;
+    const transaction =/** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        db.__versionTransaction
+    );
 
     const storeHandles = transaction.__storeHandles;
     if (!storeHandles[storeName] ||
@@ -172,16 +248,25 @@ IDBObjectStore.__createObjectStore = function (db, store) {
     }
 
     transaction.__addNonRequestToTransactionQueue(function createObjectStore (tx, args, success, failure) {
+        /**
+         * @param {SQLTransaction} tx
+         * @param {SQLError} [err]
+         * @returns {boolean}
+         */
         function error (tx, err) {
-            CFG.DEBUG && console.log(err);
+            if (CFG.DEBUG) { console.log(err); }
             failure(createDOMException('UnknownError', 'Could not create object store "' + storeName + '"', err));
+            return false;
         }
 
         const escapedStoreNameSQL = util.escapeStoreNameForSQL(storeName);
         // key INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE
         const sql = ['CREATE TABLE', escapedStoreNameSQL, '(key BLOB', store.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY', ', value BLOB)'].join(' ');
-        CFG.DEBUG && console.log(sql);
-        tx.executeSql(sql, [], function (tx, data) {
+        if (CFG.DEBUG) { console.log(sql); }
+        tx.executeSql(sql, [], function (tx) {
+            /**
+             * @returns {void}
+             */
             function insertStoreInfo () {
                 const encodedKeyPath = JSON.stringify(store.keyPath);
                 tx.executeSql('INSERT INTO __sys__ VALUES (?,?,?,?,?)', [
@@ -213,9 +298,8 @@ IDBObjectStore.__createObjectStore = function (db, store) {
 
 /**
  * Deletes an object store from the database.
- * @param {IDBDatabase} db
- * @param {IDBObjectStore} store
- * @protected
+ * @param {import('./IDBDatabase.js').IDBDatabaseFull} db
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull} store
  * @returns {void}
  */
 IDBObjectStore.__deleteObjectStore = function (db, store) {
@@ -233,11 +317,19 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
     }
 
     // Remove the object store from WebSQL
-    const transaction = db.__versionTransaction;
+    const transaction = /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        db.__versionTransaction
+    );
     transaction.__addNonRequestToTransactionQueue(function deleteObjectStore (tx, args, success, failure) {
+        /**
+         * @param {SQLTransaction} tx
+         * @param {SQLError} [err]
+         * @returns {boolean}
+         */
         function error (tx, err) {
-            CFG.DEBUG && console.log(err);
+            if (CFG.DEBUG) { console.log(err); }
             failure(createDOMException('UnknownError', 'Could not delete ObjectStore', err));
+            return false;
         }
 
         tx.executeSql('SELECT "name" FROM __sys__ WHERE "name" = ?', [util.escapeSQLiteStatement(store.__currentName)], function (tx, data) {
@@ -259,10 +351,8 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
 };
 
 /**
-* @typedef {GenericArray} KeyValueArray
-* @property {module:Key.Key} 0
-* @property {*} 1
-*/
+ * @typedef {[import('./Key.js').Key, import('./Key.js').Value]} KeyValueArray
+ */
 
 // Todo: Although we may end up needing to do cloning genuinely asynchronously (for Blobs and FileLists),
 //   and we'll want to ensure the queue starts up synchronously, we nevertheless do the cloning
@@ -275,18 +365,18 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
 /**
  * Determines whether the given inline or out-of-line key is valid,
  *   according to the object store's schema.
- * @param {*} value Used for inline keys
- * @param {*} key Used for out-of-line keys
+ * @param {import('./Key.js').Value} value Used for inline keys
+ * @param {import('./Key.js').Key} key Used for out-of-line keys
  * @param {boolean} cursorUpdate
  * @throws {DOMException}
+ * @this {IDBObjectStoreFull}
  * @returns {KeyValueArray}
- * @private
  */
 IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, key, cursorUpdate) {
     const me = this;
     if (me.keyPath !== null) {
         if (key !== undefined) {
-            throw createDOMException('DataError', 'The object store uses in-line keys and the key parameter was provided', me);
+            throw createDOMException('DataError', 'The object store uses in-line keys and the key parameter was provided');
         }
         // Todo Binary: Avoid blobs loading async to ensure cloning (and errors therein)
         //   occurs sync; then can make cloning and this method without callbacks (except where ok
@@ -301,7 +391,8 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
                 if (!me.autoIncrement) {
                     throw createDOMException('DataError', 'Could not evaluate a key from keyPath and there is no key generator');
                 }
-                if (!Key.checkKeyCouldBeInjectedIntoValue(clonedValue, me.keyPath)) {
+                // Todo: Could the keyPath not be an array?
+                if (!Key.checkKeyCouldBeInjectedIntoValue(clonedValue, /** @type {string} */ (me.keyPath))) {
                     throw createDOMException('DataError', 'A key could not be injected into a value');
                 }
                 // A key will be generated
@@ -314,7 +405,7 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
     }
     if (key === undefined) {
         if (!me.autoIncrement) {
-            throw createDOMException('DataError', 'The object store uses out-of-line keys and has no key generator and the key parameter was not provided.', me);
+            throw createDOMException('DataError', 'The object store uses out-of-line keys and has no key generator and the key parameter was not provided.');
         }
         // A key will be generated
         key = undefined;
@@ -330,17 +421,22 @@ IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, k
  *   the object store
  * If the table has auto increment, get the current number (unless it has
  *   a keyPath leading to a valid but non-numeric or < 1 key).
- * @param {Object} tx
- * @param {Object} value
- * @param {Object} key
- * @param {function} success
- * @param {function} failCb
+ * @param {SQLTransaction} tx
+ * @param {import('./Key.js').Value} value
+ * @param {import('./Key.js').Key} key
+ * @param {(key: import('./Key.js').Key, cn?: Integer) => void} success
+ * @param {import('./Key.js').SQLFailureCallback} failCb
+ * @this {IDBObjectStoreFull}
  * @returns {void}
  */
 IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb) {
     const me = this;
 
     // Only run if cloning is needed
+    /**
+     * @param {Integer} [oldCn]
+     * @returns {void}
+     */
     function keyCloneThenSuccess (oldCn) { // We want to return the original key, so we don't need to accept an argument here
         Sca.encode(key, function (key) {
             key = Sca.decode(key);
@@ -351,6 +447,7 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
     if (me.autoIncrement) {
         // If auto-increment and no valid primaryKey found on the keyPath, get and set the new value, and use
         if (key === undefined) {
+            // @ts-expect-error Due to re-exporting `Key.d.ts` file (needed for `node_modules` imports)
             Key.generateKeyForStore(tx, me, function (failure, key, oldCn) {
                 if (failure) {
                     failCb(createDOMException('ConstraintError', 'The key generator\'s current number has reached the maximum safe integer limit'));
@@ -358,11 +455,15 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
                 }
                 if (me.keyPath !== null) {
                     // Should not throw now as checked earlier
-                    Key.injectKeyIntoValueUsingKeyPath(value, key, me.keyPath);
+                    // Todo: Could this not be an array here?
+                    Key.injectKeyIntoValueUsingKeyPath(
+                        value, key, /** @type {string} */ (me.keyPath)
+                    );
                 }
                 success(key, oldCn);
             }, failCb);
         } else {
+            // @ts-expect-error Due to re-exporting `Key.d.ts` file (needed for `node_modules` imports)
             Key.possiblyUpdateKeyGenerator(tx, me, key, keyCloneThenSuccess, failCb);
         }
     // Not auto-increment
@@ -371,10 +472,25 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
     }
 };
 
+/**
+ *
+ * @param {SQLTransaction} tx
+ * @param {string} encoded
+ * @param {import('./Key.js').Value} value
+ * @param {import('./Key.js').Key|Integer} clonedKeyOrCurrentNumber
+ * @param {Integer|undefined} oldCn
+ * @param {(
+ *   clonedKeyOrCurrentNumber: import('./Key.js').Key|Integer
+ * ) => void} success
+ * @param {(err: Error|DOMException) => void} error
+ * @this {IDBObjectStoreFull}
+ * @returns {SyncPromise}
+ */
 IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyOrCurrentNumber, oldCn, success, error) {
     const me = this;
     // The `ConstraintError` to occur for `add` upon a duplicate will occur naturally in attempting an insert
     // We process the index information first as it will stored in the same table as the store
+    /** @type {{[key: string]: string}} */
     const paramMap = {};
     const indexPromises = Object.keys(
         // We do not iterate `indexNames` as those can be modified synchronously (e.g.,
@@ -403,25 +519,38 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
                 //  after this add), we avoid checks
                 index.__deleted
             ) {
-                resolve();
+                resolve(undefined);
                 return;
             }
+            /**
+             * @type {import('./Key.js').KeyValueObject|
+             *   import('./Key.js').KeyPathEvaluateValue}
+             */
             let indexKey;
             try {
                 indexKey = Key.extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry); // Add as necessary to this and skip past this index if exceptions here)
-                if (indexKey.invalid || indexKey.failure) {
+                if (
+                    ('invalid' in indexKey && indexKey.invalid) ||
+                    ('failure' in indexKey && indexKey.failure)
+                ) {
                     throw new Error('Go to catch');
                 }
             } catch (err) {
-                resolve();
+                resolve(undefined);
                 return;
             }
             indexKey = indexKey.value;
+            /**
+             * @param {import('./IDBIndex.js').IDBIndexFull} index
+             * @returns {void}
+             */
             function setIndexInfo (index) {
                 if (indexKey === undefined) {
                     return;
                 }
-                paramMap[index.__currentName] = Key.encode(indexKey, index.multiEntry);
+                paramMap[index.__currentName] = /** @type {string} */ (
+                    Key.encode(indexKey, index.multiEntry)
+                );
             }
             if (index.unique) {
                 const multiCheck = index.multiEntry && Array.isArray(indexKey);
@@ -429,7 +558,7 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
                 executeFetchIndexData(null, ...fetchArgs, tx, null, function success (key) {
                     if (key === undefined) {
                         setIndexInfo(index);
-                        resolve();
+                        resolve(undefined);
                         return;
                     }
                     reject(createDOMException(
@@ -441,7 +570,7 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
                 }, reject);
             } else {
                 setIndexInfo(index);
-                resolve();
+                resolve(undefined);
             }
         });
     });
@@ -455,7 +584,7 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
             sqlEnd.push('?,');
             insertSqlValues.push(
                 util.escapeSQLiteStatement(
-                    Key.encode(clonedKeyOrCurrentNumber)
+                    /** @type {string} */ (Key.encode(clonedKeyOrCurrentNumber))
                 )
             );
         }
@@ -470,29 +599,43 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
         insertSqlValues.push(util.escapeSQLiteStatement(encoded));
 
         const insertSql = sqlStart.join(' ') + sqlEnd.join(' ');
-        CFG.DEBUG && console.log('SQL for adding', insertSql, insertSqlValues);
+        if (CFG.DEBUG) { console.log('SQL for adding', insertSql, insertSqlValues); }
 
-        tx.executeSql(insertSql, insertSqlValues, function (tx, data) {
+        tx.executeSql(insertSql, insertSqlValues, function () {
             success(clonedKeyOrCurrentNumber);
         }, function (tx, err) {
             // Should occur for `add` operation
-            error(createDOMException('ConstraintError', err.message, err));
+            error(createDOMException(
+                'ConstraintError', /** @type {string} */ (err.message), err
+            ));
+            return false;
         });
         return undefined;
     }).catch(function (err) {
+        /**
+         * @returns {void}
+         */
         function fail () {
             // Todo: Add a different error object here if `assignCurrentNumber`
             //  fails in reverting?
             error(err);
         }
         if (typeof oldCn === 'number') {
+            // @ts-expect-error Due to re-exporting `Key.d.ts` file (needed for `node_modules` imports)
             Key.assignCurrentNumber(tx, me, oldCn, fail, fail);
-            return;
+            return null;
         }
         fail();
+        return null;
     });
 };
 
+/**
+ *
+ * @param {import('./Key.js').Value} value
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.add = function (value /* , key */) {
     const me = this;
     // eslint-disable-next-line prefer-rest-params
@@ -505,15 +648,26 @@ IDBObjectStore.prototype.add = function (value /* , key */) {
     }
     IDBObjectStore.__invalidStateIfDeleted(me);
     IDBTransaction.__assertActive(me.transaction);
-    me.transaction.__assertWritable();
+    /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__assertWritable();
 
-    const request = me.transaction.__createRequest(me);
+    const request = /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__createRequest(me);
     const [ky, clonedValue] = me.__validateKeyAndValueAndCloneValue(value, key, false);
     IDBObjectStore.__storingRecordObjectStore(request, me, true, clonedValue, true, ky);
     return request;
 };
 
-IDBObjectStore.prototype.put = function (value /*, key */) {
+/**
+ *
+ * @param {import('./Key.js').Value} value
+ * @throws {TypeError}
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
+IDBObjectStore.prototype.put = function (value /* , key */) {
     const me = this;
     // eslint-disable-next-line prefer-rest-params
     const key = arguments[1];
@@ -525,34 +679,63 @@ IDBObjectStore.prototype.put = function (value /*, key */) {
     }
     IDBObjectStore.__invalidStateIfDeleted(me);
     IDBTransaction.__assertActive(me.transaction);
-    me.transaction.__assertWritable();
+    /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__assertWritable();
 
-    const request = me.transaction.__createRequest(me);
+    const request = /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__createRequest(me);
     const [ky, clonedValue] = me.__validateKeyAndValueAndCloneValue(value, key, false);
     IDBObjectStore.__storingRecordObjectStore(request, me, true, clonedValue, false, ky);
     return request;
 };
 
+/**
+ *
+ * @param {SQLTransaction} tx
+ * @param {import('./Key.js').Key} key
+ * @param {(tx: SQLTransaction) => void} cb
+ * @param {(err: SQLError) => void} error
+ * @this {IDBObjectStoreFull}
+ * @returns {void}
+ */
 IDBObjectStore.prototype.__overwrite = function (tx, key, cb, error) {
     const me = this;
     // First try to delete if the record exists
     // Key.convertValueToKey(key); // Already run
     const sql = 'DELETE FROM ' + util.escapeStoreNameForSQL(me.__currentName) + ' WHERE "key" = ?';
-    const encodedKey = Key.encode(key);
+    const encodedKey = /** @type {string} */ (Key.encode(key));
     tx.executeSql(sql, [util.escapeSQLiteStatement(encodedKey)], function (tx, data) {
-        CFG.DEBUG && console.log('Did the row with the', key, 'exist?', data.rowsAffected);
+        if (CFG.DEBUG) { console.log('Did the row with the', key, 'exist?', data.rowsAffected); }
         cb(tx);
     }, function (tx, err) {
         error(err);
+        return false;
     });
 };
 
+/**
+ *
+ * @param {import('./IDBRequest.js').IDBRequestFull} request
+ * @param {IDBObjectStoreFull} store
+ * @param {boolean} invalidateCache
+ * @param {import('./Key.js').Value} value
+ * @param {boolean} noOverwrite
+ * @returns {void}
+ */
 IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidateCache, value, noOverwrite /* , key */) {
     // eslint-disable-next-line prefer-rest-params
     const key = arguments[5];
-    store.transaction.__pushToQueue(request, function (tx, args, success, error) {
+    /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        store.transaction
+    ).__pushToQueue(request, function (tx, args, success, error) {
         store.__deriveKey(tx, value, key, function (clonedKeyOrCurrentNumber, oldCn) {
             Sca.encode(value, function (encoded) {
+                /**
+                 * @param {SQLTransaction} tx
+                 * @returns {void}
+                 */
                 function insert (tx) {
                     store.__insertData(tx, encoded, value, clonedKeyOrCurrentNumber, oldCn, function (...args) {
                         if (invalidateCache) {
@@ -573,6 +756,15 @@ IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidate
     });
 };
 
+/**
+ *
+ * @param {import('./Key.js').Value} query
+ * @param {boolean} [getKey]
+ * @param {boolean} [getAll]
+ * @param {Integer} [count]
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.__get = function (query, getKey, getAll, count) {
     const me = this;
     if (count !== undefined) {
@@ -584,7 +776,8 @@ IDBObjectStore.prototype.__get = function (query, getKey, getAll, count) {
     const range = convertValueToKeyRange(query, !getAll);
 
     const col = getKey ? 'key' : 'value';
-    let sql = ['SELECT', util.sqlQuote(col), 'FROM', util.escapeStoreNameForSQL(me.__currentName)];
+    const sql = ['SELECT', util.sqlQuote(col), 'FROM', util.escapeStoreNameForSQL(me.__currentName)];
+    /** @type {string[]} */
     const sqlValues = [];
     if (range !== undefined) {
         sql.push('WHERE');
@@ -597,13 +790,15 @@ IDBObjectStore.prototype.__get = function (query, getKey, getAll, count) {
         if (!Number.isFinite(count)) {
             throw new TypeError('The count parameter must be a finite number');
         }
-        sql.push('LIMIT', count);
+        sql.push('LIMIT', String(count));
     }
-    sql = sql.join(' ');
-    return me.transaction.__addToTransactionQueue(function objectStoreGet (tx, args, success, error) {
-        CFG.DEBUG && console.log('Fetching', me.__currentName, sqlValues);
-        tx.executeSql(sql, sqlValues, function (tx, data) {
-            CFG.DEBUG && console.log('Fetched data', data);
+    const sqlStr = sql.join(' ');
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__addToTransactionQueue(function objectStoreGet (tx, args, success, error) {
+        if (CFG.DEBUG) { console.log('Fetching', me.__currentName, sqlValues); }
+        tx.executeSql(sqlStr, sqlValues, function (tx, data) {
+            if (CFG.DEBUG) { console.log('Fetched data', data); }
             let ret;
             try {
                 // Opera can't deal with the try-catch here.
@@ -635,15 +830,23 @@ IDBObjectStore.prototype.__get = function (query, getKey, getAll, count) {
                 }
             } catch (e) {
                 // If no result is returned, or error occurs when parsing JSON
-                CFG.DEBUG && console.log(e);
+                if (CFG.DEBUG) { console.log(e); }
             }
             success(ret);
         }, function (tx, err) {
             error(err);
+            return false;
         });
     }, undefined, me);
 };
 
+/**
+ *
+ * @param {import('./Key.js').Value} query
+ * @throws {TypeError}
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.get = function (query) {
     if (!arguments.length) {
         throw new TypeError('A parameter was missing for `IDBObjectStore.get`.');
@@ -651,6 +854,12 @@ IDBObjectStore.prototype.get = function (query) {
     return this.__get(query);
 };
 
+/**
+ *
+ * @param {import('./Key.js').Value} query
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.getKey = function (query) {
     if (!arguments.length) {
         throw new TypeError('A parameter was missing for `IDBObjectStore.getKey`.');
@@ -658,18 +867,33 @@ IDBObjectStore.prototype.getKey = function (query) {
     return this.__get(query, true);
 };
 
+/**
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.getAll = function (/* query, count */) {
     // eslint-disable-next-line prefer-rest-params
     const [query, count] = arguments;
     return this.__get(query, false, true, count);
 };
 
+/**
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.getAllKeys = function (/* query, count */) {
     // eslint-disable-next-line prefer-rest-params
     const [query, count] = arguments;
     return this.__get(query, true, true, count);
 };
 
+/**
+ *
+ * @param {import('./Key.js').Value} query
+ * @throws {TypeError}
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.delete = function (query) {
     const me = this;
     if (!(this instanceof IDBObjectStore)) {
@@ -681,29 +905,39 @@ IDBObjectStore.prototype.delete = function (query) {
 
     IDBObjectStore.__invalidStateIfDeleted(me);
     IDBTransaction.__assertActive(me.transaction);
-    me.transaction.__assertWritable();
+    /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__assertWritable();
 
     const range = convertValueToKeyRange(query, true);
 
     const sqlArr = ['DELETE FROM', util.escapeStoreNameForSQL(me.__currentName), 'WHERE'];
+    /** @type {string[]} */
     const sqlValues = [];
     setSQLForKeyRange(range, util.sqlQuote('key'), sqlArr, sqlValues);
     const sql = sqlArr.join(' ');
 
-    return me.transaction.__addToTransactionQueue(function objectStoreDelete (tx, args, success, error) {
-        CFG.DEBUG && console.log('Deleting', me.__currentName, sqlValues);
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__addToTransactionQueue(function objectStoreDelete (tx, args, success, error) {
+        if (CFG.DEBUG) { console.log('Deleting', me.__currentName, sqlValues); }
         tx.executeSql(sql, sqlValues, function (tx, data) {
-            CFG.DEBUG && console.log('Deleted from database', data.rowsAffected);
+            if (CFG.DEBUG) { console.log('Deleted from database', data.rowsAffected); }
             me.__cursors.forEach((cursor) => {
                 cursor.__invalidateCache(); // Delete
             });
             success();
         }, function (tx, err) {
             error(err);
+            return false;
         });
     }, undefined, me);
 };
 
+/**
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.clear = function () {
     const me = this;
     if (!(this instanceof IDBObjectStore)) {
@@ -711,21 +945,30 @@ IDBObjectStore.prototype.clear = function () {
     }
     IDBObjectStore.__invalidStateIfDeleted(me);
     IDBTransaction.__assertActive(me.transaction);
-    me.transaction.__assertWritable();
+    /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__assertWritable();
 
-    return me.transaction.__addToTransactionQueue(function objectStoreClear (tx, args, success, error) {
+    return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
+        me.transaction
+    ).__addToTransactionQueue(function objectStoreClear (tx, args, success, error) {
         tx.executeSql('DELETE FROM ' + util.escapeStoreNameForSQL(me.__currentName), [], function (tx, data) {
-            CFG.DEBUG && console.log('Cleared all records from database', data.rowsAffected);
+            if (CFG.DEBUG) { console.log('Cleared all records from database', data.rowsAffected); }
             me.__cursors.forEach((cursor) => {
                 cursor.__invalidateCache(); // Clear
             });
             success();
         }, function (tx, err) {
             error(err);
+            return false;
         });
     }, undefined, me);
 };
 
+/**
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.count = function (/* query */) {
     const me = this;
     // eslint-disable-next-line prefer-rest-params
@@ -740,6 +983,10 @@ IDBObjectStore.prototype.count = function (/* query */) {
     return IDBCursorWithValue.__createInstance(query, 'next', me, me, 'key', 'value', true).__request;
 };
 
+/**
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.openCursor = function (/* query, direction */) {
     const me = this;
     // eslint-disable-next-line prefer-rest-params
@@ -753,6 +1000,10 @@ IDBObjectStore.prototype.openCursor = function (/* query, direction */) {
     return cursor.__request;
 };
 
+/**
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
 IDBObjectStore.prototype.openKeyCursor = function (/* query, direction */) {
     const me = this;
     if (!(me instanceof IDBObjectStore)) {
@@ -766,6 +1017,12 @@ IDBObjectStore.prototype.openKeyCursor = function (/* query, direction */) {
     return cursor.__request;
 };
 
+/**
+ *
+ * @param {string} indexName
+ * @this {IDBObjectStoreFull}
+ * @returns {import('./IDBIndex.js').IDBIndexFull}
+ */
 IDBObjectStore.prototype.index = function (indexName) {
     const me = this;
     if (!(me instanceof IDBObjectStore)) {
@@ -790,16 +1047,14 @@ IDBObjectStore.prototype.index = function (indexName) {
     return me.__indexHandles[indexName];
 };
 
-/* eslint-disable jsdoc/check-param-names */
 /**
  * Creates a new index on the object store.
  * @param {string} indexName
- * @param {string} keyPath
- * @param {object} optionalParameters
+ * @param {string|string[]} keyPath
+ * @this {IDBObjectStoreFull}
  * @returns {IDBIndex}
  */
 IDBObjectStore.prototype.createIndex = function (indexName, keyPath /* , optionalParameters */) {
-    /* eslint-enable jsdoc/check-param-names */
     const me = this;
     // eslint-disable-next-line prefer-rest-params
     let optionalParameters = arguments[2];
@@ -829,7 +1084,7 @@ IDBObjectStore.prototype.createIndex = function (indexName, keyPath /* , optiona
     }
 
     optionalParameters = optionalParameters || {};
-    /** @name IDBIndexProperties */
+    /** @type {import('./IDBIndex.js').IDBIndexProperties} */
     const indexProperties = {
         columnName: indexName,
         keyPath,
@@ -843,6 +1098,12 @@ IDBObjectStore.prototype.createIndex = function (indexName, keyPath /* , optiona
     return index;
 };
 
+/**
+ *
+ * @param {string} name
+ * @this {IDBObjectStoreFull}
+ * @returns {void}
+ */
 IDBObjectStore.prototype.deleteIndex = function (name) {
     const me = this;
     if (!(me instanceof IDBObjectStore)) {