indexeddbshim 19.0.5 → 19.0.6

package/src/setGlobalVars.js

@@ -108,7 +108,7 @@ function setGlobalVars (idb, initialConfig) {
         setConfig(initialConfig);
     }
     const IDB = /** @type {ShimmedObject & {[key: string]: unknown}} */ (
-        /** @type {unknown} */ (idb || globalThis || {})
+        /** @type {unknown} */ (idb || globalThis)
     );
     /**
      * @param {string} name
@@ -213,90 +213,98 @@ function setGlobalVars (idb, initialConfig) {
                 });
             }
             const shimIDBFactory = IDBFactory;
-            if (CFG.win.openDatabase !== undefined) {
-                shimIndexedDB.__openDatabase = CFG.win.openDatabase.bind(CFG.win); // We cache here in case the function is overwritten later as by the IndexedDB support promises tests
-                // Polyfill ALL of IndexedDB, using WebSQL
-                shim('indexedDB', shimIndexedDB, {
-                    enumerable: true,
-                    configurable: true,
-                    get () {
-                        if (this !== IDB && !isNullish(this) && !this.shimNS) { // Latter is hack for test environment
-                            throw new TypeError('Illegal invocation');
-                        }
-                        return shimIndexedDB;
+            if (CFG.win.openDatabase === undefined) {
+                return;
+            }
+
+            shimIndexedDB.__openDatabase = CFG.win.openDatabase.bind(CFG.win); // We cache here in case the function is overwritten later as by the IndexedDB support promises tests
+            // Polyfill ALL of IndexedDB, using WebSQL
+            shim('indexedDB', shimIndexedDB, {
+                enumerable: true,
+                configurable: true,
+                get () {
+                    if (this !== IDB && !isNullish(this) && !this.shimNS) { // Latter is hack for test environment
+                        throw new TypeError('Illegal invocation');
                     }
-                });
-                /** @type {[string, unknown][]} */
-                ([
-                    ['IDBFactory', shimIDBFactory],
-                    ['IDBDatabase', shimIDBDatabase],
-                    ['IDBObjectStore', shimIDBObjectStore],
-                    ['IDBIndex', shimIDBIndex],
-                    ['IDBTransaction', shimIDBTransaction],
-                    ['IDBCursor', shimIDBCursor],
-                    ['IDBCursorWithValue', shimIDBCursorWithValue],
-                    ['IDBRecord', shimIDBRecord],
-                    ['IDBKeyRange', shimIDBKeyRange],
-                    ['IDBRequest', shimIDBRequest],
-                    ['IDBOpenDBRequest', shimIDBOpenDBRequest],
-                    ['IDBVersionChangeEvent', shimIDBVersionChangeEvent]
-                ]).forEach(([prop, obj]) => {
-                    shim(prop, obj, {
-                        enumerable: false,
-                        configurable: true
-                    });
-                });
-                // For Node environments
-                if (CFG.fs) {
-                    setFS(CFG.fs);
+                    return shimIndexedDB;
                 }
-                if (CFG.fullIDLSupport) {
-                    // Slow per MDN so off by default! Though apparently needed for WebIDL: https://stackoverflow.com/questions/41927589/rationales-consequences-of-webidl-class-inheritance-requirements
+            });
+            /** @type {[string, unknown][]} */
+            ([
+                ['IDBFactory', shimIDBFactory],
+                ['IDBDatabase', shimIDBDatabase],
+                ['IDBObjectStore', shimIDBObjectStore],
+                ['IDBIndex', shimIDBIndex],
+                ['IDBTransaction', shimIDBTransaction],
+                ['IDBCursor', shimIDBCursor],
+                ['IDBCursorWithValue', shimIDBCursorWithValue],
+                ['IDBRecord', shimIDBRecord],
+                ['IDBKeyRange', shimIDBKeyRange],
+                ['IDBRequest', shimIDBRequest],
+                ['IDBOpenDBRequest', shimIDBOpenDBRequest],
+                ['IDBVersionChangeEvent', shimIDBVersionChangeEvent]
+            ]).forEach(([prop, obj]) => {
+                shim(prop, obj, {
+                    enumerable: false,
+                    configurable: true
+                });
+            });
+            // For Node environments
+            if (CFG.fs) {
+                setFS(CFG.fs);
+            }
+            if (CFG.fullIDLSupport) {
+                // Slow per MDN so off by default! Though apparently needed for WebIDL: https://stackoverflow.com/questions/41927589/rationales-consequences-of-webidl-class-inheritance-requirements
 
-                    Object.setPrototypeOf(IDB.IDBOpenDBRequest, IDB.IDBRequest);
-                    Object.setPrototypeOf(IDB.IDBCursorWithValue, IDB.IDBCursor);
+                Object.setPrototypeOf(IDB.IDBOpenDBRequest, IDB.IDBRequest);
+                Object.setPrototypeOf(IDB.IDBCursorWithValue, IDB.IDBCursor);
 
-                    Object.setPrototypeOf(shimIDBDatabase, ShimEventTarget);
-                    Object.setPrototypeOf(shimIDBRequest, ShimEventTarget);
-                    Object.setPrototypeOf(shimIDBTransaction, ShimEventTarget);
-                    Object.setPrototypeOf(shimIDBVersionChangeEvent, ShimEvent);
-                    // `ShimDOMException` is the real native `DOMException` when one
-                    //   is available (see `DOMException.js`'s `useNativeDOMException`)
-                    //   -- which, unlike the shim classes above, is a single,
-                    //   process-wide singleton shared by reference across every
-                    //   sandbox this library gets installed into (see
-                    //   `node-idb-test.js`'s `sandboxObj`). A native `DOMException`
-                    //   already has the correct prototype chain out of the box
-                    //   (`Object.getPrototypeOf(DOMException) === Function.prototype`,
-                    //   not `Error`), so forcing it here isn't just unneeded but
-                    //   actively wrong -- and, because it's shared, permanently
-                    //   wrong for every later use of `DOMException` in the same
-                    //   process (e.g. a later WPT test file's own idlharness-style
-                    //   check that `DOMException` does *not* inherit from `Error`
-                    //   on the class side), not just this one shim install.
-                    if (typeof DOMException === 'undefined' || ShimDOMException !== DOMException) {
-                        Object.setPrototypeOf(ShimDOMException, Error);
-                        Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
-                    }
+                Object.setPrototypeOf(shimIDBDatabase, ShimEventTarget);
+                Object.setPrototypeOf(shimIDBRequest, ShimEventTarget);
+                Object.setPrototypeOf(shimIDBTransaction, ShimEventTarget);
+                Object.setPrototypeOf(shimIDBVersionChangeEvent, ShimEvent);
+                // `ShimDOMException` is the real native `DOMException` when one
+                //   is available (see `DOMException.js`'s `useNativeDOMException`)
+                //   -- which, unlike the shim classes above, is a single,
+                //   process-wide singleton shared by reference across every
+                //   sandbox this library gets installed into (see
+                //   `node-idb-test.js`'s `sandboxObj`). A native `DOMException`
+                //   already has the correct prototype chain out of the box
+                //   (`Object.getPrototypeOf(DOMException) === Function.prototype`,
+                //   not `Error`), so forcing it here isn't just unneeded but
+                //   actively wrong -- and, because it's shared, permanently
+                //   wrong for every later use of `DOMException` in the same
+                //   process (e.g. a later WPT test file's own idlharness-style
+                //   check that `DOMException` does *not* inherit from `Error`
+                //   on the class side), not just this one shim install.
+                if (typeof DOMException === 'undefined' || ShimDOMException !== DOMException) {
+                    Object.setPrototypeOf(ShimDOMException, Error);
+                    Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
                 }
-                if (IDB.indexedDB && !IDB.indexedDB.toString().includes('[native code]')) {
-                    if (CFG.addNonIDBGlobals) {
-                        // As `DOMStringList` exists per IDL (and Chrome) in the global
-                        //   thread (but not in workers), we prefix the name to avoid
-                        //   shadowing or conflicts
-                        setNonIDBGlobals('Shim');
-                    }
-                    if (CFG.replaceNonIDBGlobals) {
-                        setNonIDBGlobals();
-                    }
+            }
+            if (IDB.indexedDB && !IDB.indexedDB.toString().includes('[native code]')) {
+                if (CFG.addNonIDBGlobals) {
+                    // As `DOMStringList` exists per IDL (and Chrome) in the global
+                    //   thread (but not in workers), we prefix the name to avoid
+                    //   shadowing or conflicts
+                    setNonIDBGlobals('Shim');
                 }
-                /* c8 ignore start -- TS guard */
-                if (!IDB.shimIndexedDB) {
-                    return;
+                if (CFG.replaceNonIDBGlobals) {
+                    setNonIDBGlobals();
                 }
-                /* c8 ignore stop -- TS guard */
-                IDB.shimIndexedDB.__setConnectionQueueOrigin();
             }
+            /* c8 ignore start -- Defensive: `IDB.shimIndexedDB` was already
+               confirmed truthy just before this function (`__useShim`) was
+               defined and immediately invoked (see the `if ('shimIndexedDB'
+               in IDB && IDB.shimIndexedDB)` guard above), and nothing in
+               this function's body reassigns or deletes it. Only reachable
+               if `IDB` is some unusual object (e.g. a Proxy) whose
+               `shimIndexedDB` property value changes between reads. */
+            if (!IDB.shimIndexedDB) {
+                return;
+            }
+            /* c8 ignore stop -- see comment above */
+            IDB.shimIndexedDB.__setConnectionQueueOrigin();
         };
 
         IDB.shimIndexedDB.__debug = /** @type {(val: boolean) => void} */ (function (val) {
@@ -382,6 +390,7 @@ function setGlobalVars (idb, initialConfig) {
                 : 4
         ) * 1024 * 1024;
     }
+
     if (!CFG.avoidAutoShim &&
         (!IDB.indexedDB || poorIndexedDbSupport) &&
         CFG.win.openDatabase !== undefined

package/src/util.js

@@ -17,12 +17,11 @@ function escapeUnmatchedSurrogates (arg) {
         function (_, unmatchedHighSurrogate, precedingLow, unmatchedLowSurrogate) {
             // Could add a corresponding surrogate for compatibility with `node-sqlite3`: https://bugs.python.org/issue12569 and https://stackoverflow.com/a/6701665/271577
             //   but Chrome having problems
-            if (unmatchedHighSurrogate) {
-                return '^2' + unmatchedHighSurrogate.codePointAt()
-                    .toString(16).padStart(4, '0');
-            }
-            return (precedingLow || '') + '^3' +
-                unmatchedLowSurrogate.codePointAt().toString(16).padStart(4, '0');
+            return unmatchedHighSurrogate
+                ? '^2' + unmatchedHighSurrogate.codePointAt()
+                    .toString(16).padStart(4, '0')
+                : (precedingLow || '') + '^3' +
+                    unmatchedLowSurrogate.codePointAt().toString(16).padStart(4, '0');
         }
     );
 }