indexeddbshim 17.2.0 → 17.2.2

package/dist/indexeddbshim-UnicodeIdentifiers.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v17.2.0 - 8/18/2026 */
+/*! indexeddbshim - v17.2.2 - 8/18/2026 */
 
 (function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
@@ -4930,6 +4930,17 @@
   IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
     var me = this;
     if (me.__transFinishedCb === IDBTransaction.prototype.__transFinishedCb) {
+      // Standard (3-argument) `transaction()` implementations (browser WebSQL,
+      //  `cordova-plugin-sqlite-2`, etc.) never invoke the non-standard 4th
+      //  callback that installs the real `__transFinishedCb`, so waiting for
+      //  it here would defer forever. Detect that via arity and, if it's not
+      //  supported, just call the default (the driver auto-commits on its own).
+      var dbConn = me.db && me.db.__db;
+      var supportsNonstandardTransCb = Boolean(dbConn && typeof dbConn.transaction === 'function' && dbConn.transaction.length >= 4);
+      if (!supportsNonstandardTransCb) {
+        me.__transFinishedCb(err, cb);
+        return;
+      }
       setTimeout(function () {
         me.__callTransFinishedCb(err, cb);
       }, 0);
@@ -9871,6 +9882,56 @@
     return websqlDBCache[name] && websqlDBCache[name][getLatestCachedWebSQLVersion(name)];
   }
 
+  /**
+   * A cached WebSQL connection (e.g., from a prior `open()`) can keep the
+   *  underlying SQLite file handle open even after `IDBDatabase#close()`
+   *  (which only flags the connection for closing without releasing the
+   *  handle, to allow instance reuse). On Windows, deleting a file while a
+   *  handle to it is still open fails with `EBUSY`, so any cached connections
+   *  for `name` must be actually closed (and evicted, since they're no longer
+   *  usable) before attempting to remove the file.
+   * @param {string} name
+   * @param {() => void} cb
+   * @returns {void}
+   */
+  function closeCachedWebSQLConnections(name, cb) {
+    if (!Object.hasOwn(websqlDBCache, name)) {
+      cb();
+      return;
+    }
+    var dbs = Object.values(websqlDBCache[name]);
+    delete websqlDBCache[name];
+    var remaining = dbs.length;
+    if (remaining === 0) {
+      cb();
+      return;
+    }
+    dbs.forEach(function (db) {
+      var sqliteDB = db._db && db._db._db;
+      if (!sqliteDB || !sqliteDB.close) {
+        remaining--;
+        if (remaining === 0) {
+          cb();
+        }
+        return;
+      }
+      sqliteDB.close(
+      /**
+       * @param {Error} err
+       * @returns {void}
+       */
+      function (err) {
+        if (err) {
+          console.warn('Error closing database connection prior to file removal: ' + err);
+        }
+        remaining--;
+        if (remaining === 0) {
+          cb();
+        }
+      });
+    });
+  }
+
   /**
    * @param {OpenDatabase} __openDatabase
    * @param {string} name
@@ -9908,16 +9969,18 @@
       return;
     }
     if (fs && CFG.deleteDatabaseFiles !== false) {
-      fs.unlink(path.join(CFG.databaseBasePath || '', escapedDatabaseName), function (err) {
-        if (err && err.code !== 'ENOENT') {
-          // Ignore if file is already deleted
-          dbError({
-            code: 0,
-            message: 'Error removing database file: ' + escapedDatabaseName + ' ' + err
-          });
-          return;
-        }
-        databaseDeleted();
+      closeCachedWebSQLConnections(name, function () {
+        fs.unlink(path.join(CFG.databaseBasePath || '', escapedDatabaseName), function (err) {
+          if (err && err.code !== 'ENOENT') {
+            // Ignore if file is already deleted
+            dbError({
+              code: 0,
+              message: 'Error removing database file: ' + escapedDatabaseName + ' ' + err
+            });
+            return;
+          }
+          databaseDeleted();
+        });
       });
       return;
     }
@@ -10446,9 +10509,17 @@
      * @returns {boolean}
      */
     function dbError(tx, err) {
-      if (calledDBError || err === true) {
+      if (calledDBError) {
         return false;
       }
+      // Must be set synchronously (not inside the `sysdbFinishedCbDelete` callback below) to
+      //  guard against reentrancy: `sysdbFinishedCbDelete` -> `rollback`/`commit` -> websql-configurable's
+      //  `done()` -> `currentTask.errorCallback(er)`, which is this very `dbError`, calling back into
+      //  us before the first invocation has finished. Without this, a second rollback/commit gets
+      //  issued on the shared `sysdb` connection after it has already moved on to the next queued
+      //  transaction, corrupting that connection's task queue (see issue with unrelated `open()` calls
+      //  failing/crashing after a `deleteDatabase` file-removal error).
+      calledDBError = true;
       var er = webSQLErrback(/** @type {SQLError} */err || tx);
       sysdbFinishedCbDelete(true, function () {
         req.__done = true;
@@ -10460,7 +10531,6 @@
           cancelable: true
         });
         req.dispatchEvent(e);
-        calledDBError = true;
       });
       return false;
     }