indexeddbshim 19.0.3 → 19.0.5

package/dist/indexeddbshim-noninvasive.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v19.0.3 - 9/15/2026 */
+/*! indexeddbshim - v19.0.5 - 9/17/2026 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -1814,7 +1814,7 @@
   'UnicodeIDStart',
   // In the non-Unicode builds, defaults to /[$0-9A-Z_a-z]/
   'UnicodeIDContinue',
-  // Used by SCA.js for optional restructuring of typeson-registry
+  // Used by Sca.js for optional restructuring of typeson-registry
   //   Structured Cloning Algorithm; should only be needed for ensuring data
   //   created in 3.* versions of IndexedDBShim continue to work; see the
   //   library `typeson-registry-sca-reverter` to get a function to do this
@@ -5378,6 +5378,7 @@
    *   __requestsFinished: boolean,
    *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
    *   __callTransFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
+   *   __usesStandardDriver: () => boolean,
    *   __transactionEndCallback: (() => void)|undefined,
    *   __transactionFinished: boolean,
    *   __completed: boolean,
@@ -5517,6 +5518,27 @@
     cb(Boolean(err));
   };
 
+  /**
+   * A standard (3-argument) `transaction()`/`readTransaction()` implementation
+   *   (browser WebSQL, `cordova-plugin-sqlite-2`, etc.) never invokes the
+   *   non-standard 4th callback that installs the real `__transFinishedCb`,
+   *   and finalizes its own underlying SQL transaction synchronously, as soon
+   *   as it sees no further `executeSql` call already in flight or queued --
+   *   with no way for it to know a JS-level continuation (e.g. an
+   *   `await`-deferred follow-up request) is still coming. Detected via
+   *   arity, checking whichever of the two methods this transaction's own
+   *   mode actually uses.
+   * @this {IDBTransactionFull}
+   * @returns {boolean}
+   */
+  IDBTransaction.prototype.__usesStandardDriver = function () {
+    var me = this;
+    var dbConn = me.db && me.db.__db;
+    var dbMethodName = me.mode === 'readonly' ? 'readTransaction' : 'transaction';
+    var supportsNonstandardTransCb = Boolean(dbConn && typeof dbConn[dbMethodName] === 'function' && dbConn[dbMethodName].length >= 4);
+    return !supportsNonstandardTransCb;
+  };
+
   /**
    * In Node, the real (SQL-commit-capable) `__transFinishedCb` is only
    * installed once the underlying WebSQL driver's own SQL-queue-idle check
@@ -5551,17 +5573,11 @@
       return;
     }
     if (me.__transFinishedCb === IDBTransaction.prototype.__transFinishedCb) {
-      // Standard (3-argument) `transaction()`/`readTransaction()` 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
-      //  (checking whichever of the two methods this transaction's own mode
-      //  actually uses -- see `__executeRequests`) 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 dbMethodName = me.mode === 'readonly' ? 'readTransaction' : 'transaction';
-      var supportsNonstandardTransCb = Boolean(dbConn && typeof dbConn[dbMethodName] === 'function' && dbConn[dbMethodName].length >= 4);
-      if (!supportsNonstandardTransCb) {
+      // Waiting here for the non-standard 4th callback to install the real
+      //  `__transFinishedCb` would defer forever on a standard driver, which
+      //  never invokes it -- call the default instead (the driver auto-commits
+      //  on its own).
+      if (me.__usesStandardDriver()) {
         me.__transFinishedCbFired = true;
         me.__transFinishedCb(err, cb);
         return;
@@ -5600,10 +5616,56 @@
     // `readTransaction` is optimized, at least in `node-websql`
     function executeRequests(tx) {
       me.__tx = tx;
+      var isStandardDriver = me.__usesStandardDriver();
       /** @type {RequestInfo} */
       var q,
         i = -1;
 
+      // On a standard driver, `keepAliveAndWait` issues a SQL query, which
+      //   is a macrotask. Otherwise it issues ten microtasks.
+      var keepAliveAttempts = isStandardDriver ? 1 : 10;
+
+      /**
+       * A continuation that must still be able to observe the
+       *   transaction as safe to extend (e.g., re-checking whether an
+       *   `await`-based follow-up request has arrived yet, or giving a
+       *   same-tick microtask scheduled from a handler a chance to run
+       *   first) can normally just be deferred via `queueMicrotask`.
+       *   That alone isn't safe on a standard (3-argument) driver,
+       *   though: it finalizes its own underlying SQL transaction
+       *   synchronously, as soon as it sees no further `executeSql`
+       *   call already in flight or queued, and a microtask hop by
+       *   itself never issues one -- so the driver already considers
+       *   the transaction done by the time the deferred continuation
+       *   runs, silently dropping whatever it tries to do next. Issuing
+       *   a harmless `SELECT 1` instead keeps the driver's own queue
+       *   non-empty across that same gap, at the cost of a real SQL
+       *   round trip; Node's driver doesn't need this since its real
+       *   commit/rollback is already deferred separately, via
+       *   `nonstandardTransCb`.
+       * @param {() => void} cb
+       * @returns {void}
+       */
+      function keepAliveAndWait(cb) {
+        if (!isStandardDriver) {
+          queueMicrotask(cb);
+          return;
+        }
+        try {
+          tx.executeSql('SELECT 1', [], function () {
+            cb();
+          }, function () {
+            cb();
+            return false; // Don't roll back the transaction over a keep-alive no-op
+          });
+        } catch (err) {
+          // The driver has already finalized the transaction (or otherwise
+          //   rejected the call) -- nothing left to hold open. We explicitly
+          //   abort the transaction here.
+          me.__abortTransaction(/** @type {Error|DOMException} */err);
+        }
+      }
+
       /**
        * @typedef {unknown} IDBRequestResult
        */
@@ -5797,9 +5859,9 @@
        *   from a microtask -- so if the JS-level queue is merely found
        *   empty here, that doesn't yet mean no more work is coming, only
        *   that none has been queued *yet*. Re-check across a small, bounded
-       *   number of further microtask turns (letting a typical `await`
-       *   chain like `await store.put(...); await store.get(...)` catch
-       *   up) before finally concluding the transaction is genuinely done.
+       *   number of further turns (see `keepAliveAndWait`, letting a typical
+       *   `await` chain like `await store.put(...); await store.get(...)`
+       *   catch up) before finally concluding the transaction is genuinely done.
        *   Applies to `readonly` transactions too, not just `readwrite`/
        *   `versionchange`: a `readonly` transaction's `complete` event
        *   can otherwise fire synchronously, immediately after its last
@@ -5807,9 +5869,11 @@
        *   consumer of that same handler (e.g. one that resolves a
        *   promise from within `onsuccess` and only attaches `oncomplete`
        *   afterward) ever gets a turn to run, so it can miss `complete`
-       *   entirely. `readonly` requests don't hold a real SQL
-       *   transaction open, though, so there's no file-lock/connection
-       *   collision risk in waiting the same bounded amount here.
+       *   afterward) ever gets a turn to run, so it can miss `complete`
+       *   entirely. On a non-standard driver, `readonly` requests don't hold
+       *   a real SQL transaction open, so there's no file-lock/connection
+       *   collision risk. On a standard driver, the wait now issues real SQL
+       *   inside the read transaction, so this does carry a slight risk.
        * @param {number} attemptsLeft
        * @returns {void}
        */
@@ -5829,7 +5893,7 @@
           }
           return;
         }
-        queueMicrotask(function () {
+        keepAliveAndWait(function () {
           checkQueueEntry(attemptsLeft - 1);
         });
       }
@@ -5844,7 +5908,7 @@
         }
         i++;
         if (i >= me.__requests.length) {
-          checkQueueEntry(10);
+          checkQueueEntry(keepAliveAttempts);
           return;
         }
         runQueuedRequest();
@@ -5881,10 +5945,10 @@
         }
         i++;
         if (i >= me.__requests.length) {
-          checkQueueEntry(10);
+          checkQueueEntry(keepAliveAttempts);
           return;
         }
-        queueMicrotask(function () {
+        keepAliveAndWait(function () {
           if (me.__errored || me.__requestsFinished) {
             return;
           }
@@ -13890,10 +13954,11 @@
               setNonIDBGlobals();
             }
           }
-          /* istanbul ignore next -- TS guard */
+          /* c8 ignore start -- TS guard */
           if (!IDB.shimIndexedDB) {
             return;
           }
+          /* c8 ignore stop -- TS guard */
           IDB.shimIndexedDB.__setConnectionQueueOrigin();
         }
       };