indexeddbshim 17.3.2 → 17.3.3

package/dist/indexeddbshim-UnicodeIdentifiers.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v17.3.2 - 8/24/2026 */
+/*! indexeddbshim - v17.3.3 - 8/25/2026 */
 
 (function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
@@ -6161,9 +6161,15 @@
     if (err !== null) {
       me.__error = err;
     }
-    if (me.__requestsFinished) {
+    if (me.__requestsFinished && err !== null) {
       // The transaction has already completed, so we can't call "onerror" or "onabort".
-      // So throw the error instead.
+      // So throw the error instead. `err` is only ever `null` here via
+      //   `IDBTransaction.prototype.abort`'s own `__abortTransaction(null)`
+      //   call, which now checks `__requestsFinished` itself first and
+      //   throws `InvalidStateError` synchronously before ever reaching
+      //   this point -- so this guard is just defense in depth against
+      //   `err` somehow being `null` some other way, not something this
+      //   path should see in practice.
       setTimeout(function () {
         throw err;
       }, 0);
@@ -6283,6 +6289,14 @@
     if (me.__committed) {
       throw createDOMException('InvalidStateError', 'The transaction has already been committed');
     }
+    if (me.__requestsFinished) {
+      // All requests have already finished and the transaction is
+      //   auto-committing (the async SQL commit round trip just hasn't
+      //   resolved yet) -- too late to abort per spec, even though
+      //   `__committed` itself isn't set until that round trip actually
+      //   finishes.
+      throw createDOMException('InvalidStateError', 'The transaction is already committing');
+    }
     me.__abortTransaction(null);
   };
 
@@ -11097,7 +11111,29 @@
         return new SyncPromise(function (resolve) {
           setTimeout(function () {
             entry.dispatchEvent(e); // No need to catch errors
-            resolve(undefined);
+            // Unlike a native `Promise`, `SyncPromise#then` chains
+            //   synchronously off `resolve()` (verified directly:
+            //   `SyncPromise.resolve().then(cb)` runs `cb` before
+            //   even the calling code below it finishes) -- so
+            //   resolving immediately here would let the
+            //   `connectionsClosed()` check below run before a
+            //   same-task-but-microtask-later continuation of a
+            //   `versionchange` listener above (e.g. an `await`-
+            //   based one that then calls `db.close()`, as in
+            //   `transaction-lifetime.any.js`) ever gets a turn,
+            //   incorrectly firing `blocked` even though the
+            //   connection was about to close in time. Give real
+            //   microtask-deferred continuations a small, bounded
+            //   number of turns first -- same pattern as
+            //   `IDBTransaction.js`'s `checkQueueEntry`.
+            var attemptsLeft = 10;
+            (function wait() {
+              if (attemptsLeft-- <= 0) {
+                resolve(undefined);
+                return;
+              }
+              queueMicrotask(wait);
+            })();
           }, 0);
         });
       });
@@ -11157,6 +11193,23 @@
    */
   var websqlDBCache = {};
 
+  /**
+   * Tracks databases with a creation/upgrade currently in flight but not yet
+   *   committed or aborted -- keyed by (unescaped) database name. The
+   *   `dbVersions` row in `sysdb` these entries shadow is written *before*
+   *   `upgradeneeded` is even dispatched to user code (as the success
+   *   callback of that very `INSERT`/`UPDATE`), on the same shared `sysdb`
+   *   connection `databases()` itself reads from -- so, absent this, a
+   *   `databases()` call made while an upgrade is still pending would see
+   *   the new row (or new version) immediately, rather than only once the
+   *   corresponding `versionchange` transaction has genuinely committed, as
+   *   required by `get-databases.any.js`'s "doesn't pick up changes that
+   *   haven't committed" test. `IDBFactory.prototype.databases` filters
+   *   its SQL results against this map.
+   * @type {Map<string, {oldVersion: Integer, newVersion: Integer}>}
+   */
+  var pendingVersionChanges = new Map();
+
   /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
   var sysdb;
   var nameCounter = 0;
@@ -11459,6 +11512,19 @@
       if (calledDbCreateError) {
         return false;
       }
+      // Defensive cleanup: `pendingVersionChanges.set(name, ...)` (see
+      //   below) runs *before* the `dbVersions` `INSERT`/`UPDATE` it
+      //   guards is even attempted, but only `versionSet`'s own
+      //   `on__beforecomplete`/`on__preabort` handlers ever clear it --
+      //   and `versionSet` never runs at all if that `INSERT`/`UPDATE`,
+      //   or an earlier step in this same `open()` flow, fails first.
+      //   Without this, such a failure would leave the entry orphaned
+      //   forever, silently corrupting `databases()` for any *other*,
+      //   unrelated later `open()` call that happens to reuse the same
+      //   database name (common in WPT tests, e.g. generic names like
+      //   "DB1"/"TestDatabase" reused across different test files in
+      //   the same process). A no-op if no entry was ever set.
+      pendingVersionChanges.delete(name);
       var 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
@@ -11570,22 +11636,43 @@
                   //   open/close the transaction's active-handler window itself.
                   req.transaction.__handlerActive = true;
                   req.dispatchEvent(e);
-                  // Give any same-tick microtask scheduled from within the
+                  // Give any microtask-scheduled continuation of the
                   //   `upgradeneeded` handler (e.g. a plain
-                  //   `Promise.resolve().then(...)`) a chance to run -- and still
-                  //   observe the transaction as active -- before we deactivate it
-                  //   again, per https://github.com/w3c/IndexedDB/issues/87. Only
-                  //   the flag reset itself is deferred here -- unlike
-                  //   `IDBTransaction.js`'s `advanceAfterDispatch`, `finished()`
-                  //   (this transaction's own queue-advancement/completion signal)
-                  //   still runs synchronously, at exactly its previous timing: an
-                  //   earlier attempt at deferring `finished()` too raced against
-                  //   unrelated test setup that assumed a freshly deleted/created
-                  //   database's upgrade transaction had already fully completed by
-                  //   the time this function returns.
-                  queueMicrotask(function () {
-                    req.transaction.__handlerActive = false;
-                  });
+                  //   `Promise.resolve().then(...)`, or an `await`-based
+                  //   continuation of a promise resolved from within the handler,
+                  //   such as testharness.js's own `EventWatcher`) a chance to
+                  //   run -- and still observe the transaction as active -- before
+                  //   we deactivate it again, per
+                  //   https://github.com/w3c/IndexedDB/issues/87. A single deferred
+                  //   tick isn't always enough: an `await`-based continuation can
+                  //   take more than one microtask turn to resume (e.g.
+                  //   `transaction-lifetime.any.js`'s `EventWatcher`-based
+                  //   `await eventWatcher.wait_for('upgradeneeded')`), so retry a
+                  //   small, bounded number of times first -- same pattern as
+                  //   `IDBTransaction.js`'s `checkQueueEntry` -- rather than
+                  //   resetting after only one. Only the flag reset itself is
+                  //   deferred here -- unlike `IDBTransaction.js`'s
+                  //   `advanceAfterDispatch`, `finished()` (this transaction's own
+                  //   queue-advancement/completion signal) still runs
+                  //   synchronously, at exactly its previous timing: an earlier
+                  //   attempt at deferring `finished()` too raced against unrelated
+                  //   test setup that assumed a freshly deleted/created database's
+                  //   upgrade transaction had already fully completed by the time
+                  //   this function returns.
+                  /**
+                   * @param {Integer} attemptsLeft
+                   * @returns {void}
+                   */
+                  function deferHandlerActiveReset(attemptsLeft) {
+                    if (attemptsLeft <= 0) {
+                      req.transaction.__handlerActive = false;
+                      return;
+                    }
+                    queueMicrotask(function () {
+                      deferHandlerActiveReset(attemptsLeft - 1);
+                    });
+                  }
+                  deferHandlerActiveReset(10);
                   if (e.__legacyOutputDidListenersThrowError) {
                     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.'));
@@ -11601,6 +11688,7 @@
                  * @returns {void}
                  */
                 function (ev) {
+                  pendingVersionChanges.delete(name);
                   connection.__upgradeTransaction = null;
                   /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */
                   req.__result.__versionTransaction = null;
@@ -11615,6 +11703,7 @@
 
                 // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__preabort = function () {
+                  pendingVersionChanges.delete(name);
                   connection.__upgradeTransaction = null;
                   // We ensure any cache is deleted before any request error events fire and try to reopen
                   if (useDatabaseCache) {
@@ -11677,6 +11766,10 @@
                   // });
                 };
               }
+              pendingVersionChanges.set(name, {
+                oldVersion: oldVersion,
+                newVersion: version
+              });
               if (oldVersion === 0) {
                 systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
               } else {
@@ -11979,6 +12072,15 @@
   IDBFactory.prototype.databases = function () {
     var me = this;
     var calledDbCreateError = false;
+    // Snapshotted *now*, synchronously, at call time -- not read later
+    // from inside the SQL query's callback below, which runs on a
+    //   deferred macrotask (see `nodeSQLiteDatabase.js`'s `exec`) and so
+    //   could otherwise race against (and lose to) an in-flight upgrade's
+    //   own commit/abort handler clearing its `pendingVersionChanges`
+    //   entry in the meantime -- which would make this method incorrectly
+    //   reflect a since-committed change that hadn't committed yet when
+    //   it was actually called.
+    var pendingVersionChangesSnapshot = new Map(pendingVersionChanges);
     return new Promise(function (resolve, reject) {
       // eslint-disable-line promise/avoid-new -- Own polyfill
       if (!(me instanceof IDBFactory)) {
@@ -12008,10 +12110,29 @@
             var dbNames = [];
             for (var i = 0; i < data.rows.length; i++) {
               var _data$rows$item2 = /** @type {{name: string, version: Integer}} */data.rows.item(i),
-                name = _data$rows$item2.name,
+                encodedName = _data$rows$item2.name,
                 version = _data$rows$item2.version;
+              var name = unescapeSQLiteResponse(encodedName);
+              // A row for a database whose creation/upgrade hasn't
+              //   committed yet (see `pendingVersionChanges`) must
+              //   not reflect that in-flight change: a brand new
+              //   database (`oldVersion === 0`) isn't reported at
+              //   all until its creation commits, and an existing
+              //   database being upgraded is still reported, but
+              //   with its pre-upgrade version.
+              var pending = pendingVersionChangesSnapshot.get(name);
+              if (pending) {
+                if (pending.oldVersion === 0) {
+                  continue;
+                }
+                dbNames.push({
+                  name: name,
+                  version: pending.oldVersion
+                });
+                continue;
+              }
               dbNames.push({
-                name: unescapeSQLiteResponse(name),
+                name: name,
                 version: version
               });
             }
@@ -12431,9 +12552,26 @@
       // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
       sqlValues.push(/** @type {string} */_encode(key));
     } else if (continueCall && me.__key !== undefined) {
-      sql.push('AND', quotedKeyColumnName, op + ' ?');
       // Key.convertValueToKey(me.__key); // Already checked when stored
-      sqlValues.push(/** @type {string} */_encode(me.__key));
+      if (!me.__unique && me.__keyColumnName !== 'key' && me.__primaryKey !== undefined) {
+        // A plain `continue()` on a non-unique index cursor must find
+        //   the next record strictly after the (key, primaryKey) pair
+        //   this cursor last returned -- a scalar `key > lastKey` alone
+        //   would wrongly exclude a *different*, not-yet-visited record
+        //   that's still tied on key with the last one (e.g. another
+        //   record that always had that same indexed value), and would
+        //   also wrongly re-admit the *same* record forever if a
+        //   same-transaction `update()` bumped its own key back above
+        //   the threshold, since a scalar comparison can't distinguish
+        //   "some other record newly tied" from "this record moved
+        //   past its own last position." Comparing the full tuple (via
+        //   this OR) against both key and primary key resolves both.
+        sql.push('AND (', quotedKeyColumnName, op, '?', 'OR (', quotedKeyColumnName, '= ?', 'AND', quotedKey, op, '?))');
+        sqlValues.push(/** @type {string} */_encode(me.__key), /** @type {string} */_encode(me.__key), /** @type {string} */_encode(me.__primaryKey));
+      } else {
+        sql.push('AND', quotedKeyColumnName, op + ' ?');
+        sqlValues.push(/** @type {string} */_encode(me.__key));
+      }
     }
     if (!me.__count) {
       // 1. Sort by key
@@ -13063,9 +13201,15 @@
      * @returns {void}
      */
     function addToQueue(clonedValue) {
-      // We set the `invalidateCache` argument to `false` since the old value shouldn't be accessed
+      // `invalidateCache: true` so any cursor on this store (including
+      //   this one) drops its prefetched row batch, forcing its next
+      //   `continue()` to re-query live rather than serve rows snapshotted
+      //   before this update -- needed for the compound-tuple
+      //   continuation logic in `__findBasic` to see this update's
+      //   effect on ordering (see "Modify records during cursor
+      //   iteration" in idbcursor_update_index.any.js).
       // @ts-ignore -- API (not erring in TS 6)
-      IDBObjectStore.__storingRecordObjectStore(request, me.__store, false, clonedValue, false, key);
+      IDBObjectStore.__storingRecordObjectStore(request, me.__store, true, clonedValue, false, key);
     }
     if (me.__store.keyPath !== null) {
       var _me$__store$__validat = me.__store.__validateKeyAndValueAndCloneValue(valueToUpdate, undefined, true),