indexeddbshim 11.0.0 → 12.0.0-pre.0

package/src/IDBFactory.js

@@ -1,6 +1,6 @@
 /* globals location */
 import path from 'path';
-import SyncPromise from 'sync-promise';
+import SyncPromise from 'sync-promise-expanded';
 
 import {createEvent} from './Event.js';
 import IDBVersionChangeEvent from './IDBVersionChangeEvent.js';
@@ -13,11 +13,29 @@ import IDBTransaction from './IDBTransaction.js';
 import IDBDatabase from './IDBDatabase.js';
 import CFG from './CFG.js';
 
+/**
+ * @typedef {number} Integer
+ */
+
+/**
+ * @callback DatabaseDeleted
+ * @returns {void}
+ */
+
+/** @type {import('./CFG.js').FSApi} */
 let fs;
+
+/**
+ * @param {import('./CFG.js').FSApi} _fs
+ * @returns {void}
+ */
 const setFS = (_fs) => {
     fs = _fs;
 };
 
+/**
+ * @returns {string}
+ */
 const getOrigin = () => {
     return (typeof location !== 'object' || !location) ? 'null' : location.origin;
 };
@@ -26,14 +44,34 @@ const hasNullOrigin = () => CFG.checkOrigin !== false && (getOrigin() === 'null'
 // Todo: This really should be process and tab-independent so the
 //  origin could vary; in the browser, this might be through a
 //  `SharedWorker`
+
+/**
+ * @type {{
+ *   [key: string]: {
+ *     [key: string]: {
+ *       req: import('./IDBRequest.js').IDBOpenDBRequestFull,
+ *       cb: (req: import('./IDBRequest.js').IDBRequestFull) => void,
+ *     }[]
+ *   }
+ * }}
+ */
 const connectionQueue = {};
 
+/**
+ * @param {string} name
+ * @param {string} origin
+ * @returns {void}
+ */
 function processNextInConnectionQueue (name, origin = getOrigin()) {
     const queueItems = connectionQueue[origin][name];
     if (!queueItems[0]) { // Nothing left to process
         return;
     }
     const {req, cb} = queueItems[0]; // Keep in queue to prevent continuation
+
+    /**
+     * @returns {void}
+     */
     function removeFromQueue () {
         queueItems.shift();
         processNextInConnectionQueue(name, origin);
@@ -43,8 +81,16 @@ function processNextInConnectionQueue (name, origin = getOrigin()) {
     cb(req);
 }
 
-// eslint-disable-next-line default-param-last
+/* eslint-disable default-param-last */
+/**
+ * @param {import('./IDBRequest.js').IDBOpenDBRequestFull} req
+ * @param {string} name
+ * @param {string} origin
+ * @param {(req: import('./IDBRequest.js').IDBOpenDBRequestFull) => void} cb
+ * @returns {void}
+ */
 function addRequestToConnectionQueue (req, name, origin = getOrigin(), cb) {
+    /* eslint-enable default-param-last */
     if (!connectionQueue[origin][name]) {
         connectionQueue[origin][name] = [];
     }
@@ -55,10 +101,22 @@ function addRequestToConnectionQueue (req, name, origin = getOrigin(), cb) {
     }
 }
 
+/**
+ * @param {import('./IDBDatabase.js').IDBDatabaseFull[]} openConnections
+ * @param {import('./IDBRequest.js').IDBRequestFull} req
+ * @param {Integer} oldVersion
+ * @param {Integer|null} newVersion
+ * @returns {SyncPromise}
+ */
 function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersion, newVersion) {
     // Todo: For Node (and in browser using service workers if available?) the
     //    connections ought to involve those in any process; should also
     //    auto-close if unloading
+
+    /**
+     * @param {IDBDatabase} connection
+     * @returns {boolean|undefined}
+     */
     const connectionIsClosed = (connection) => connection.__closePending;
     const connectionsClosed = () => openConnections.every((conn) => {
         return connectionIsClosed(conn);
@@ -72,15 +130,17 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
                 // Prior onversionchange must have caused this connection to be closed
                 return undefined;
             }
-            const e = new IDBVersionChangeEvent('versionchange', {oldVersion, newVersion});
+            const e = /** @type {Event & IDBVersionChangeEvent} */ (
+                new IDBVersionChangeEvent('versionchange', {oldVersion, newVersion})
+            );
             return new SyncPromise(function (resolve) {
                 setTimeout(() => {
                     entry.dispatchEvent(e); // No need to catch errors
-                    resolve();
+                    resolve(undefined);
                 });
             });
         });
-    }, SyncPromise.resolve()).then(function () {
+    }, SyncPromise.resolve(undefined)).then(function () {
         if (connectionsClosed()) {
             return undefined;
         }
@@ -88,11 +148,13 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
             const unblocking = {
                 check () {
                     if (connectionsClosed()) {
-                        resolve();
+                        resolve(undefined);
                     }
                 }
             };
-            const e = new IDBVersionChangeEvent('blocked', {oldVersion, newVersion});
+            const e = /** @type {Event & IDBVersionChangeEvent} */ (
+                new IDBVersionChangeEvent('blocked', {oldVersion, newVersion})
+            );
             setTimeout(() => {
                 req.dispatchEvent(e); // No need to catch errors
                 if (!connectionsClosed()) {
@@ -102,17 +164,40 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
                         }
                     });
                 } else {
-                    resolve();
+                    resolve(undefined);
                 }
             });
         });
     });
 }
 
+/**
+ * @typedef {import('websql-configurable/lib/websql/WebSQLDatabase.js').default & {
+ *   _db: {
+ *     _db: {
+ *       close: (errBack: (err: Error) => void) => void
+ *     }
+ *   }
+ * }} DatabaseFull
+ */
+
+/**
+ * @type {{
+ *   [key: string]: {
+ *     [key: string]: DatabaseFull
+ *   }
+ * }}
+ */
 const websqlDBCache = {};
+
+/** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
 let sysdb;
 let nameCounter = 0;
 
+/**
+ * @param {string} name
+ * @returns {Integer}
+ */
 function getLatestCachedWebSQLVersion (name) {
     return Object.keys(websqlDBCache[name]).map(Number).reduce(
         (prev, curr) => {
@@ -121,12 +206,24 @@ function getLatestCachedWebSQLVersion (name) {
     );
 }
 
+/**
+ * @param {string} name
+ * @returns {DatabaseFull}
+ */
 function getLatestCachedWebSQLDB (name) {
     return websqlDBCache[name] && websqlDBCache[name][
         getLatestCachedWebSQLVersion(name)
     ];
 }
 
+/**
+ * @param {OpenDatabase} __openDatabase
+ * @param {string} name
+ * @param {string} escapedDatabaseName
+ * @param {DatabaseDeleted} databaseDeleted
+ * @param {(tx: SQLTransaction|Error|SQLError, err?: SQLError) => boolean} dbError
+ * @returns {void}
+ */
 function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError) {
     const useMemoryDatabase = typeof CFG.memoryDatabase === 'string';
     if (useMemoryDatabase) {
@@ -141,13 +238,19 @@ function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, da
             console.error('The `openDatabase` implementation does not have the expected `._db._db.close` method for closing the database');
             return;
         }
-        sqliteDB.close(function (err) {
-            if (err) {
-                console.warn('Error closing (destroying) memory database');
-                return;
+        sqliteDB.close(
+            /**
+             * @param {Error} err
+             * @returns {void}
+             */
+            (err) => {
+                if (err) {
+                    console.warn('Error closing (destroying) memory database');
+                    return;
+                }
+                databaseDeleted();
             }
-            databaseDeleted();
-        });
+        );
         return;
     }
     if (fs && CFG.deleteDatabaseFiles !== false) {
@@ -166,7 +269,7 @@ function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, da
 
     const sqliteDB = __openDatabase(
         path.join(CFG.databaseBasePath || '', escapedDatabaseName),
-        1,
+        '1',
         name,
         CFG.DEFAULT_DB_SIZE
     );
@@ -189,33 +292,41 @@ function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, da
                         deleteTables(i + 1);
                     }, function () {
                         deleteTables(i + 1);
+                        return true;
                     });
                 }
             }(0));
         }, function (e) {
             // __sys__ table does not exist, but that does not mean delete did not happen
             databaseDeleted();
+            return true;
         });
     });
 }
 
 /**
-* @callback CreateSysDBSuccessCallback
-* @returns {void}
-*/
+ * @callback CreateSysDBSuccessCallback
+ * @returns {void}
+ */
 
 /**
  * Creates the sysDB to keep track of version numbers for databases.
- * @param {openDatabase} __openDatabase
+ * @param {OpenDatabase} __openDatabase
  * @param {CreateSysDBSuccessCallback} success
- * @param {DOMException} failure
+ * @param {(tx: SQLTransaction|SQLError|Error, err?: SQLError) => void} failure
  * @returns {void}
  */
 function createSysDB (__openDatabase, success, failure) {
+    /**
+     *
+     * @param {boolean|SQLTransaction|SQLError} tx
+     * @param {SQLError} [err]
+     * @returns {void}
+     */
     function sysDbCreateError (tx, err) {
-        err = webSQLErrback(err || tx);
+        const er = webSQLErrback(/** @type {SQLError} */ (err) || tx);
         CFG.DEBUG && console.log('Error in sysdb transaction - when creating dbVersions', err);
-        failure(err);
+        failure(er);
     }
 
     if (sysdb) {
@@ -230,7 +341,7 @@ function createSysDB (__openDatabase, success, failure) {
                         : (CFG.databaseBasePath || '')),
                     '__sysdb__' + (CFG.addSQLiteExtension !== false ? '.sqlite' : '')
                 ),
-            1,
+            '1',
             'System Database',
             CFG.DEFAULT_DB_SIZE
         );
@@ -240,8 +351,13 @@ function createSysDB (__openDatabase, success, failure) {
                     success();
                     return;
                 }
-                systx.executeSql('CREATE INDEX IF NOT EXISTS dbvname ON dbVersions(name)', [], success, sysDbCreateError);
-            }, sysDbCreateError);
+                systx.executeSql(
+                    'CREATE INDEX IF NOT EXISTS dbvname ON dbVersions(name)',
+                    [],
+                    success,
+                    /** @type {SQLStatementErrorCallback} */ (sysDbCreateError)
+                );
+            }, /** @type {SQLStatementErrorCallback} */ (sysDbCreateError));
         }, sysDbCreateError);
     }
 }
@@ -254,26 +370,48 @@ function createSysDB (__openDatabase, success, failure) {
 function IDBFactory () {
     throw new TypeError('Illegal constructor');
 }
+
+/**
+ * @typedef {(
+ *   name: string, version: string, displayName: string, estimatedSize: number
+ * ) => import('websql-configurable/lib/websql/WebSQLDatabase.js').default} OpenDatabase
+ */
+
+/**
+ * @typedef {globalThis.IDBFactory & {
+ *   __openDatabase: OpenDatabase,
+ *   __connections: {
+ *     [key: string]: import('./IDBDatabase.js').IDBDatabaseFull[]
+ *   }
+* }} IDBFactoryFull
+ */
+
 const IDBFactoryAlias = IDBFactory;
+/**
+ * @returns {IDBFactoryFull}
+ */
 IDBFactory.__createInstance = function () {
+    /**
+     * @class
+     */
     function IDBFactory () {
         this[Symbol.toStringTag] = 'IDBFactory';
         this.__connections = {};
     }
     IDBFactory.prototype = IDBFactoryAlias.prototype;
+
+    // @ts-expect-error It's ok
     return new IDBFactory();
 };
 
-/* eslint-disable jsdoc/check-param-names */
 /**
  * The IndexedDB Method to create a new database and return the DB.
  * @param {string} name
- * @param {number} version
+ * @this {IDBFactoryFull}
  * @throws {TypeError} Illegal invocation or no arguments (for database name)
  * @returns {IDBOpenDBRequest}
  */
 IDBFactory.prototype.open = function (name /* , version */) {
-    /* eslint-enable jsdoc/check-param-names */
     const me = this;
     if (!(me instanceof IDBFactory)) {
         throw new TypeError('Illegal invocation');
@@ -306,6 +444,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
     const useMemoryDatabase = typeof CFG.memoryDatabase === 'string';
     const useDatabaseCache = CFG.cacheDatabaseInstances !== false || useMemoryDatabase;
 
+    /** @type {string} */
     let escapedDatabaseName;
     // eslint-disable-next-line no-useless-catch
     try {
@@ -315,22 +454,39 @@ IDBFactory.prototype.open = function (name /* , version */) {
         throw err; // new TypeError('You have supplied a database name which does not match the currently supported configuration, possibly due to a length limit enforced for Node compatibility.');
     }
 
+    /**
+     *
+     * @param {SQLTransaction|Error|SQLError} tx
+     * @param {SQLError} [err]
+     * @returns {boolean}
+     */
     function dbCreateError (tx, err) {
         if (calledDbCreateError) {
-            return;
+            return true;
         }
-        err = err ? webSQLErrback(err) : tx;
+        const er = err ? webSQLErrback(err) : /** @type {Error} */ (tx);
         calledDbCreateError = true;
         // Re: why bubbling here (and how cancelable is only really relevant for `window.onerror`) see: https://github.com/w3c/IndexedDB/issues/86
-        const evt = createEvent('error', err, {bubbles: true, cancelable: true});
+        const evt = createEvent('error', er, {bubbles: true, cancelable: true});
         req.__done = true;
-        req.__error = err;
+        req.__error = er;
         req.__result = undefined; // Must be undefined if an error per `result` getter
         req.dispatchEvent(evt);
+        return true;
     }
 
+    /**
+     *
+     * @param {SQLTransaction} tx
+     * @param {DatabaseFull} db
+     * @param {Integer} oldVersion
+     * @returns {void}
+     */
     function setupDatabase (tx, db, oldVersion) {
         tx.executeSql('SELECT "name", "keyPath", "autoInc", "indexList" FROM __sys__', [], function (tx, data) {
+            /**
+             * @returns {void}
+             */
             function finishRequest () {
                 req.__result = connection;
                 req.__done = true;
@@ -345,6 +501,13 @@ IDBFactory.prototype.open = function (name /* , version */) {
                 const openConnections = me.__connections[name].slice(0, -1);
                 triggerAnyVersionChangeAndBlockedEvents(openConnections, req, oldVersion, version).then(function () {
                     // DB Upgrade in progress
+                    /**
+                     *
+                     * @param {SQLTransaction} systx
+                     * @param {boolean|SQLError|DOMException|Error} err
+                     * @param {(tx?: SQLTransaction|SQLError, err?: SQLError|SQLResultSet) => boolean} cb
+                     * @returns {void}
+                     */
                     let sysdbFinishedCb = function (systx, err, cb) {
                         if (err) {
                             try {
@@ -353,17 +516,38 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                 // Browser may fail with expired transaction above so
                                 //     no choice but to manually revert
                                 sysdb.transaction(function (systx) {
+                                    /**
+                                     *
+                                     * @param {string} msg
+                                     * @throws {Error}
+                                     * @returns {never}
+                                     */
                                     function reportError (msg) {
                                         throw new Error('Unable to roll back upgrade transaction!' + (msg || ''));
                                     }
 
                                     // Attempt to revert
                                     if (oldVersion === 0) {
-                                        systx.executeSql('DELETE FROM dbVersions WHERE "name" = ?', [sqlSafeName], function () {
-                                            cb(reportError); // eslint-disable-line promise/no-callback-in-promise
-                                        }, reportError);
+                                        systx.executeSql(
+                                            'DELETE FROM dbVersions WHERE "name" = ?',
+                                            [sqlSafeName],
+                                            function () {
+                                                // @ts-expect-error Force to work
+                                                cb(reportError); // eslint-disable-line promise/no-callback-in-promise
+                                            },
+                                            // @ts-expect-error Force to work
+                                            reportError
+                                        );
                                     } else {
-                                        systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [oldVersion, sqlSafeName], cb, reportError);
+                                        systx.executeSql(
+                                            'UPDATE dbVersions SET "version" = ? WHERE "name" = ?',
+                                            [
+                                                oldVersion, sqlSafeName
+                                            ],
+                                            cb,
+                                            // @ts-expect-error Force to work
+                                            reportError
+                                        );
                                     }
                                 });
                             }
@@ -374,8 +558,13 @@ IDBFactory.prototype.open = function (name /* , version */) {
                     };
 
                     sysdb.transaction(function (systx) {
+                        /**
+                         * @returns {void}
+                         */
                         function versionSet () {
-                            const e = new IDBVersionChangeEvent('upgradeneeded', {oldVersion, newVersion: version});
+                            const e = /** @type {import('eventtargeter').EventWithProps & Event & IDBVersionChangeEvent} */ (
+                                new IDBVersionChangeEvent('upgradeneeded', {oldVersion, newVersion: version})
+                            );
                             req.__result = connection;
                             connection.__upgradeTransaction = req.__transaction = req.__result.__versionTransaction = IDBTransaction.__createInstance(req.__result, req.__result.objectStoreNames, 'versionchange');
                             req.__done = true;
@@ -384,7 +573,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                 req.dispatchEvent(e);
 
                                 if (e.__legacyOutputDidListenersThrowError) {
-                                    logError('Error', 'An error occurred in an upgradeneeded handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
+                                    logError('Error', 'An error occurred in an upgradeneeded handler attached to request chain', /** @type {Error} */ (e.__legacyOutputDidListenersThrowError)); // We do nothing else with this error as per spec
                                     req.transaction.__abortTransaction(createDOMException('AbortError', 'A request was aborted.'));
                                     return;
                                 }
@@ -392,12 +581,15 @@ IDBFactory.prototype.open = function (name /* , version */) {
                             });
                             req.transaction.on__beforecomplete = function (ev) {
                                 connection.__upgradeTransaction = null;
-                                req.__result.__versionTransaction = null;
+                                /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */ (
+                                    req.__result
+                                ).__versionTransaction = null;
                                 sysdbFinishedCb(systx, false, function () {
                                     req.transaction.__transFinishedCb(false, function () {
                                         ev.complete();
                                         req.__transaction = null;
                                     });
+                                    return true;
                                 });
                             };
                             req.transaction.on__preabort = function () {
@@ -420,15 +612,25 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                     const err = createDOMException('AbortError', 'The upgrade transaction was aborted.');
                                     sysdbFinishedCb(systx, err, function (reportError) {
                                         if (oldVersion === 0) {
-                                            cleanupDatabaseResources(me.__openDatabase, name, escapedDatabaseName, dbCreateError.bind(null, err), reportError || dbCreateError);
-                                            return;
+                                            cleanupDatabaseResources(
+                                                me.__openDatabase,
+                                                name,
+                                                escapedDatabaseName,
+                                                dbCreateError.bind(null, err),
+                                                // @ts-expect-error It's ok
+                                                reportError || dbCreateError
+                                            );
+                                            return true;
                                         }
                                         dbCreateError(err);
+                                        return true;
                                     });
                                 });
                             };
                             req.transaction.on__complete = function () {
-                                if (req.__result.__closePending) {
+                                if (/** @type {import('./IDBDatabase.js').IDBDatabaseFull} */ (
+                                    req.__result
+                                ).__closePending) {
                                     req.__transaction = null;
                                     const err = createDOMException('AbortError', 'The connection has been closed.');
                                     dbCreateError(err);
@@ -460,7 +662,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                         } else {
                             systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [version, sqlSafeName], versionSet, dbCreateError);
                         }
-                    }, dbCreateError, null, function (currentTask, err, done, rollback, commit) {
+                    }, dbCreateError, undefined, function (currentTask, err, done, rollback, commit) {
                         if (currentTask.readOnly || err) {
                             return true;
                         }
@@ -487,14 +689,20 @@ IDBFactory.prototype.open = function (name /* , version */) {
         }, dbCreateError);
     }
 
+    /**
+     *
+     * @param {Integer} oldVersion
+     * @returns {void}
+     */
     function openDB (oldVersion) {
+        /** @type {DatabaseFull} */
         let db;
         if ((useMemoryDatabase || useDatabaseCache) && name in websqlDBCache && websqlDBCache[name][version]) {
             db = websqlDBCache[name][version];
         } else {
             db = me.__openDatabase(
                 useMemoryDatabase ? CFG.memoryDatabase : path.join(CFG.databaseBasePath || '', escapedDatabaseName),
-                1,
+                '1',
                 name,
                 CFG.DEFAULT_DB_SIZE
             );
@@ -523,6 +731,9 @@ IDBFactory.prototype.open = function (name /* , version */) {
 
         db.transaction(function (tx) {
             tx.executeSql('CREATE TABLE IF NOT EXISTS __sys__ (name BLOB, keyPath BLOB, autoInc BOOLEAN, indexList BLOB, currNum INTEGER)', [], function () {
+                /**
+                 * @returns {void}
+                 */
                 function setup () {
                     setupDatabase(tx, db, oldVersion);
                 }
@@ -531,7 +742,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                     return;
                 }
                 tx.executeSql('CREATE INDEX IF NOT EXISTS sysname ON __sys__(name)', [], setup, dbCreateError);
-            }, dbCreateError);
+            }, /** @type {SQLStatementErrorCallback} */ (dbCreateError));
         }, dbCreateError);
     }
 
@@ -567,6 +778,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
 /**
  * Deletes a database.
  * @param {string} name
+ * @this {IDBFactoryFull}
  * @returns {IDBOpenDBRequest}
  */
 IDBFactory.prototype.deleteDatabase = function (name) {
@@ -584,6 +796,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
     name = String(name); // cast to a string
     const sqlSafeName = util.escapeSQLiteStatement(name);
 
+    /** @type {string} */
     let escapedDatabaseName;
     // eslint-disable-next-line no-useless-catch
     try {
@@ -600,6 +813,12 @@ IDBFactory.prototype.deleteDatabase = function (name) {
     let calledDBError = false;
     let version = 0;
 
+    /**
+     *
+     * @param {boolean} err
+     * @param {(erred?: boolean) => void} cb
+     * @returns {void}
+     */
     let sysdbFinishedCbDelete = function (err, cb) {
         cb(err);
     };
@@ -607,20 +826,27 @@ IDBFactory.prototype.deleteDatabase = function (name) {
     // Although the spec has no specific conditions where an error
     //  may occur in `deleteDatabase`, it does provide for
     //  `UnknownError` as we may require upon a SQL deletion error
+    /**
+     *
+     * @param {SQLTransaction|SQLError|Error} tx
+     * @param {SQLError|boolean} [err]
+     * @returns {boolean}
+     */
     function dbError (tx, err) {
         if (calledDBError || err === true) {
-            return;
+            return true;
         }
-        err = webSQLErrback(err || tx);
+        const er = webSQLErrback(/** @type {SQLError} */ (err || tx));
         sysdbFinishedCbDelete(true, function () {
             req.__done = true;
-            req.__error = err;
+            req.__error = er;
             req.__result = undefined; // Must be undefined if an error per `result` getter
             // Re: why bubbling here (and how cancelable is only really relevant for `window.onerror`) see: https://github.com/w3c/IndexedDB/issues/86
-            const e = createEvent('error', err, {bubbles: true, cancelable: true});
+            const e = createEvent('error', er, {bubbles: true, cancelable: true});
             req.dispatchEvent(e);
             calledDBError = true;
         });
+        return true;
     }
 
     addRequestToConnectionQueue(req, name, /* origin */ undefined, function (req) {
@@ -628,13 +854,19 @@ IDBFactory.prototype.deleteDatabase = function (name) {
             // function callback (cb) { cb(); }
             // callback(function () {
 
+            /**
+             * @returns {void}
+             */
             function completeDatabaseDelete () {
                 req.__result = undefined;
                 req.__done = true;
-                const e = new IDBVersionChangeEvent('success', {oldVersion: version, newVersion: null});
+                const e = /** @type {Event & IDBVersionChangeEvent} */ (
+                    new IDBVersionChangeEvent('success', {oldVersion: version, newVersion: null})
+                );
                 req.dispatchEvent(e);
             }
 
+            /** @type {DatabaseDeleted} */
             function databaseDeleted () {
                 sysdbFinishedCbDelete(false, function () {
                     if (useDatabaseCache && name in websqlDBCache) {
@@ -668,7 +900,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
                                 //    above code with `DELETE FROM dbVersions`)
                                 cleanupDatabaseResources(me.__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError);
                             }, dbError);
-                        }, dbError, null, function (currentTask, err, done, rollback, commit) {
+                        }, dbError, undefined, function (currentTask, err, done, rollback, commit) {
                             if (currentTask.readOnly || err) {
                                 return true;
                             }
@@ -682,6 +914,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
                             return false;
                         });
                         return undefined;
+                    // @ts-expect-error It's ok
                     }, dbError);
                     return undefined;
                 }, dbError);
@@ -692,6 +925,13 @@ IDBFactory.prototype.deleteDatabase = function (name) {
     return req;
 };
 
+/**
+ *
+ * @param {import('./Key.js').Key} key1
+ * @param {import('./Key.js').Key} key2
+ * @throws {TypeError}
+ * @returns {0|1|-1}
+ */
 IDBFactory.prototype.cmp = function (key1, key2) {
     if (!(this instanceof IDBFactory)) {
         throw new TypeError('Illegal invocation');
@@ -709,7 +949,11 @@ IDBFactory.prototype.cmp = function (key1, key2) {
 /**
 * May return outdated information if a database has since been deleted.
 * @see https://github.com/w3c/IndexedDB/pull/240/files
-* @returns {Promise<string[]>}
+* @this {IDBFactoryFull}
+* @returns {Promise<{
+*   name: string,
+*   version: Integer
+* }[]>}
 */
 IDBFactory.prototype.databases = function () {
     const me = this;
@@ -721,13 +965,20 @@ IDBFactory.prototype.databases = function () {
         if (hasNullOrigin()) {
             throw createDOMException('SecurityError', 'Cannot get IndexedDB database names from an opaque origin.');
         }
+        /**
+         *
+         * @param {true|SQLTransaction|SQLError|DOMException|Error} tx
+         * @param {SQLError|DOMException|Error} [err]
+         * @returns {boolean}
+         */
         function dbGetDatabaseNamesError (tx, err) {
             if (calledDbCreateError) {
-                return;
+                return true;
             }
-            err = err ? webSQLErrback(err) : tx;
+            const er = err ? webSQLErrback(/** @type {SQLError} */ (err)) : tx;
             calledDbCreateError = true;
-            reject(err);
+            reject(er);
+            return true;
         }
         createSysDB(me.__openDatabase, function () {
             sysdb.readTransaction(function (sysReadTx) {
@@ -756,15 +1007,22 @@ IDBFactory.prototype.databases = function () {
 * @param {Integer} connIdx
 * @param {string} msg
 * @throws {TypeError}
+* @this {IDBFactoryFull}
 * @returns {void}
 */
 IDBFactory.prototype.__forceClose = function (dbName, connIdx, msg) {
     const me = this;
+    /**
+     *
+     * @param {import('./IDBDatabase.js').IDBDatabaseFull} conn
+     * @returns {void}
+     */
     function forceClose (conn) {
         conn.__forceClose(msg);
     }
     if (util.isNullish(dbName)) {
-        Object.values(me.__connections).forEach((conn) => {
+        (Object.values(me.__connections)).forEach((conn) => {
+            // @ts-expect-error It's ok
             forceClose(conn);
         });
     } else if (!me.__connections[dbName]) {
@@ -783,6 +1041,11 @@ IDBFactory.prototype.__forceClose = function (dbName, connIdx, msg) {
     }
 };
 
+/**
+ *
+ * @param {string} [origin]
+ * @returns {void}
+ */
 IDBFactory.prototype.__setConnectionQueueOrigin = function (origin = getOrigin()) {
     connectionQueue[origin] = {};
 };