indexeddbshim 12.0.0 → 13.0.0

package/src/Sca.js

@@ -8,13 +8,24 @@ import {createDOMException, ShimDOMException} from './DOMException.js';
 
 let typeson = new Typeson().register(structuredCloningThrowing);
 
+/**
+ * @param {(preset: import('typeson-registry').Preset) =>
+ *   import('typeson-registry').Preset} func
+ * @returns {void}
+ */
 function register (func) {
     typeson = new Typeson().register(func(structuredCloningThrowing));
 }
 
-// We are keeping the callback approach for now in case we wish to reexpose
-//   `Blob`, `File`, `FileList` asynchronously (though in such a case, we
-//   should probably refactor as a Promise)
+/**
+ * We are keeping the callback approach for now in case we wish to reexpose
+ * `Blob`, `File`, `FileList` asynchronously (though in such a case, we
+ * should probably refactor as a Promise).
+ * @param {AnyValue} obj
+ * @param {(str: string) => void} [func]
+ * @throws {Error}
+ * @returns {string}
+ */
 function encode (obj, func) {
     let ret;
     try {
@@ -34,14 +45,28 @@ function encode (obj, func) {
         //  throwing getters (as in the W3C test, key-conversion-exceptions.htm)
         throw err;
     }
-    if (func) func(ret);
+    if (func) {
+        func(ret);
+    }
     return ret;
 }
 
+/**
+ * @typedef {any} AnyValue
+ */
+
+/**
+ * @param {string} obj
+ * @returns {AnyValue}
+ */
 function decode (obj) {
     return typeson.parse(obj);
 }
 
+/**
+ * @param {AnyValue} val
+ * @returns {AnyValue}
+ */
 function clone (val) {
     // We don't return the intermediate `encode` as we'll need to reencode
     //   the clone as it may differ

package/src/browser-UnicodeIdentifiers.js

@@ -1,5 +1,5 @@
 /* eslint-env browser, worker */
-/* global shimIndexedDB */
+/* globals shimIndexedDB */
 import * as UnicodeIdentifiers from './UnicodeIdentifiers.js';
 
 // BEGIN: Same code as in browser.js
@@ -14,6 +14,10 @@ setGlobalVars();
 const __setUnicodeIdentifiers = shimIndexedDB.__setUnicodeIdentifiers.bind(
     shimIndexedDB
 );
+
+/**
+ * @returns {void}
+ */
 shimIndexedDB.__setUnicodeIdentifiers = function () {
     __setUnicodeIdentifiers(UnicodeIdentifiers);
 };

package/src/cmp.js

@@ -3,13 +3,13 @@ import {encode as keyEncode, decode as keyDecode} from './Key.js';
 
 /**
  * Compares two keys.
- * @param first
- * @param second
- * @returns {number}
+ * @param {import('./Key.js').Key} first
+ * @param {import('./Key.js').Key} second
+ * @returns {0|1|-1}
  */
 function cmp (first, second) {
-    const encodedKey1 = keyEncode(first);
-    const encodedKey2 = keyEncode(second);
+    const encodedKey1 = /** @type {string} */ (keyEncode(first));
+    const encodedKey2 = /** @type {string} */ (keyEncode(second));
     const result = encodedKey1 > encodedKey2
         ? 1
         : encodedKey1 === encodedKey2 ? 0 : -1;

package/src/node-UnicodeIdentifiers.js

@@ -7,8 +7,17 @@ import * as UnicodeIdentifiers from './UnicodeIdentifiers.js';
 
 CFG.win = {openDatabase: nodeWebSQL};
 
+/**
+ * @param {import('./setGlobalVars.js').ShimmedObject} idb
+ * @param {import('./CFG.js').default} initialConfig
+ * @returns {{}|Window}
+ */
 const __setGlobalVars = function (idb, initialConfig = {}) {
     const obj = setGlobalVars(idb, {fs, ...initialConfig});
+    /* istanbul ignore next -- TS guard */
+    if (!obj.shimIndexedDB) {
+        return obj;
+    }
     obj.shimIndexedDB.__setUnicodeIdentifiers(UnicodeIdentifiers);
 
     return obj;

package/src/node.js

@@ -6,6 +6,11 @@ import CFG from './CFG.js';
 
 CFG.win = {openDatabase: nodeWebSQL};
 
+/**
+ * @param {import('./setGlobalVars.js').ShimmedObject} idb
+ * @param {import('./CFG.js').default} initialConfig
+ * @returns {{}|Window}
+ */
 const __setGlobalVars = function (idb, initialConfig = {}) {
     return setGlobalVars(idb, {fs, ...initialConfig});
 };

package/src/nodeWebSQL.js

@@ -1,20 +1,26 @@
-import customOpenDatabase from 'websql/custom/index.js';
-import SQLiteDatabase from 'websql/lib/sqlite/SQLiteDatabase.js';
+import customOpenDatabase from 'websql-configurable/custom/index.js';
+import SQLiteDatabase from 'websql-configurable/lib/sqlite/SQLiteDatabase.js';
 import CFG from './CFG.js';
 
+/**
+ * @param {string} name
+ * @returns {SQLiteDatabase}
+ */
 function wrappedSQLiteDatabase (name) {
-    const db = new SQLiteDatabase(name);
+    const db = new SQLiteDatabase(name, {});
     if (CFG.sqlBusyTimeout) {
-        db._db.configure('busyTimeout', CFG.sqlBusyTimeout); // Default is 1000
+        db._db.configure('busyTimeout', /** @type {number} */ (CFG.sqlBusyTimeout)); // Default is 1000
     }
     if (CFG.sqlTrace) {
+        // @ts-expect-error native API?
         db._db.configure('trace', CFG.sqlTrace);
     }
     if (CFG.sqlProfile) {
+        // @ts-expect-error native API?
         db._db.configure('profile', CFG.sqlProfile);
     }
     return db;
 }
 
-const nodeWebSQL = customOpenDatabase(wrappedSQLiteDatabase);
+const nodeWebSQL = customOpenDatabase(wrappedSQLiteDatabase, {});
 export default nodeWebSQL;

package/src/setGlobalVars.js

@@ -1,4 +1,3 @@
-/* globals self */
 import {setPrototypeOfCustomEvent} from 'eventtargeter';
 import shimIDBVersionChangeEvent from './IDBVersionChangeEvent.js';
 import {IDBCursor as shimIDBCursor, IDBCursorWithValue as shimIDBCursorWithValue} from './IDBCursor.js';
@@ -16,37 +15,135 @@ import shimIDBDatabase from './IDBDatabase.js';
 import CFG from './CFG.js';
 import {isNullish} from './util.js';
 
+/**
+ * @typedef {any} AnyValue
+ */
+
+/**
+ * @callback SetConfig
+ * @param {import('./CFG.js').KeyofConfigValues|
+ *   Partial<import('./CFG.js').ConfigValues>} prop
+ * @param {AnyValue} [val]
+ * @throws {Error}
+ * @returns {void}
+ */
+
+/** @type {SetConfig} */
 function setConfig (prop, val) {
     if (prop && typeof prop === 'object') {
         Object.entries(prop).forEach(([p, val]) => {
-            setConfig(p, val);
+            setConfig(
+                /** @type {import('./CFG.js').KeyofConfigValues} */
+                (p),
+                val
+            );
         });
         return;
     }
     if (!(prop in CFG)) {
         throw new Error(prop + ' is not a valid configuration property');
     }
+    // @ts-expect-error Should not be `never` here!
     CFG[prop] = val;
     if (prop === 'registerSCA' && typeof val === 'function') {
-        register(val);
+        register(
+            /**
+             * @type {(
+             *   preset: import('typeson').Preset
+             * ) => import('typeson').Preset}
+             */ (
+                val
+            )
+        );
     }
 }
 
+/**
+ * @typedef {(
+ *   prop: import('./CFG.js').KeyofConfigValues
+ * ) => import('../src/CFG.js').ConfigValue} GetConfig
+ */
+
+/**
+ * @typedef {(cfg: {
+ *   UnicodeIDStart: string,
+ *   UnicodeIDContinue: string
+ * }) => void} SetUnicodeIdentifiers
+ */
+
+/**
+ * @typedef {(IDBFactory|object) & {
+ *     __useShim: () => void,
+ *     __debug: (val: boolean) => void,
+ *     __setConfig: SetConfig,
+ *     __getConfig: GetConfig,
+ *     __setUnicodeIdentifiers: SetUnicodeIdentifiers,
+ *     __setConnectionQueueOrigin: (origin?: string) => void
+ *   }} ShimIndexedDB
+ */
+
+/**
+ * @typedef {number} Integer
+ */
+
+/**
+ * @typedef {(typeof globalThis|object) & {
+ *   indexedDB?: Partial<IDBFactory>,
+ *   IDBFactory: typeof IDBFactory,
+ *   IDBOpenDBRequest: typeof IDBOpenDBRequest,
+ *   IDBRequest: typeof IDBRequest,
+ *   IDBCursorWithValue: typeof IDBCursorWithValue,
+ *   IDBCursor: typeof IDBCursor,
+ *   IDBDatabase: typeof IDBDatabase,
+ *   IDBTransaction: typeof IDBTransaction,
+ *   IDBKeyRange: typeof IDBKeyRange,
+ *   shimIndexedDB?: ShimIndexedDB
+ * }} ShimmedObject
+ */
+
+/**
+ *
+ * @param {ShimmedObject} [idb]
+ * @param {import('./CFG.js').ConfigValues} [initialConfig]
+ * @returns {ShimmedObject}
+ */
 function setGlobalVars (idb, initialConfig) {
     if (initialConfig) {
         setConfig(initialConfig);
     }
-    const IDB = idb || (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : (typeof global !== 'undefined' ? global : {})));
+    const IDB = idb || globalThis || {};
+    /**
+     * @typedef {any} AnyClass
+     */
+    /**
+     * @typedef {any} AnyValue
+     */
+    /**
+     * @typedef {Function} AnyFunction
+     */
+    /**
+     * @param {string} name
+     * @param {AnyClass} value
+     * @param {PropertyDescriptor & {
+     *   shimNS?: object
+     * }|undefined} [propDesc]
+     * @returns {void}
+     */
     function shim (name, value, propDesc) {
         if (!propDesc || !Object.defineProperty) {
             try {
                 // Try setting the property. This will fail if the property is read-only.
+                // @ts-expect-error It's ok
                 IDB[name] = value;
             } catch (e) {
                 console.log(e);
             }
         }
-        if (IDB[name] !== value && Object.defineProperty) {
+        if (
+            // @ts-expect-error It's ok
+            IDB[name] !== value &&
+            Object.defineProperty
+        ) {
             // Setting a read-only property failed, so try re-defining the property
             try {
                 let desc = propDesc || {};
@@ -59,11 +156,20 @@ function setGlobalVars (idb, initialConfig) {
                     }
                 } else {
                     const o = {
+                        /**
+                         * @returns {AnyValue}
+                         */
                         get [name] () {
-                            return propDesc.get.call(this);
+                            return /** @type {AnyFunction} */ (
+                                /** @type {PropertyDescriptor} */ (
+                                    propDesc
+                                ).get
+                            ).call(this);
                         }
                     };
-                    desc = Object.getOwnPropertyDescriptor(o, name);
+                    desc = /** @type {PropertyDescriptor} */ (
+                        Object.getOwnPropertyDescriptor(o, name)
+                    );
                 }
                 Object.defineProperty(IDB, name, desc);
             } catch (e) {
@@ -72,8 +178,12 @@ function setGlobalVars (idb, initialConfig) {
                 //  get here since no WebSQL to use for shimming)
             }
         }
+
+        // @ts-expect-error It's ok
         if (IDB[name] !== value) {
-            typeof console !== 'undefined' && console.warn && console.warn('Unable to shim ' + name);
+            if (typeof console !== 'undefined' && console.warn) {
+                console.warn('Unable to shim ' + name);
+            }
         }
     }
     if (CFG.win.openDatabase !== undefined) {
@@ -82,8 +192,13 @@ function setGlobalVars (idb, initialConfig) {
             configurable: true
         });
     }
-    if (IDB.shimIndexedDB) {
+    if ('shimIndexedDB' in IDB && IDB.shimIndexedDB) {
         IDB.shimIndexedDB.__useShim = function () {
+            /**
+             *
+             * @param {"Shim"|""} [prefix]
+             * @returns {void}
+             */
             function setNonIDBGlobals (prefix = '') {
                 shim(prefix + 'DOMException', ShimDOMException);
                 shim(prefix + 'DOMStringList', DOMStringList, {
@@ -125,7 +240,8 @@ function setGlobalVars (idb, initialConfig) {
                         return shimIndexedDB;
                     }
                 });
-                [
+                /** @type {[string, any][]} */
+                ([
                     ['IDBFactory', shimIDBFactory],
                     ['IDBDatabase', shimIDBDatabase],
                     ['IDBObjectStore', shimIDBObjectStore],
@@ -137,7 +253,7 @@ function setGlobalVars (idb, initialConfig) {
                     ['IDBRequest', shimIDBRequest],
                     ['IDBOpenDBRequest', shimIDBOpenDBRequest],
                     ['IDBVersionChangeEvent', shimIDBVersionChangeEvent]
-                ].forEach(([prop, obj]) => {
+                ]).forEach(([prop, obj]) => {
                     shim(prop, obj, {
                         enumerable: false,
                         configurable: true
@@ -172,6 +288,10 @@ function setGlobalVars (idb, initialConfig) {
                         setNonIDBGlobals();
                     }
                 }
+                /* istanbul ignore next -- TS guard */
+                if (!IDB.shimIndexedDB) {
+                    return;
+                }
                 IDB.shimIndexedDB.__setConnectionQueueOrigin();
             }
         };
@@ -180,22 +300,31 @@ function setGlobalVars (idb, initialConfig) {
             CFG.DEBUG = val;
         };
         IDB.shimIndexedDB.__setConfig = setConfig;
+
+        /** @type {GetConfig} */
         IDB.shimIndexedDB.__getConfig = function (prop) {
             if (!(prop in CFG)) {
                 throw new Error(prop + ' is not a valid configuration property');
             }
             return CFG[prop];
         };
-        IDB.shimIndexedDB.__setUnicodeIdentifiers = function ({UnicodeIDStart, UnicodeIDContinue}) {
+
+        /** @type {SetUnicodeIdentifiers} */
+        IDB.shimIndexedDB.__setUnicodeIdentifiers = function ({
+            UnicodeIDStart, UnicodeIDContinue
+        }) {
             setConfig({UnicodeIDStart, UnicodeIDContinue});
         };
     } else {
         // We no-op the harmless set-up properties and methods with a warning; the `IDBFactory` methods,
         //    however (including our non-standard methods), are not stubbed as they ought
         //    to fail earlier rather than potentially having side effects.
-        IDB.shimIndexedDB = {};
-        ['__useShim', '__debug', '__setConfig', '__getConfig', '__setUnicodeIdentifiers'].forEach((prop) => {
-            IDB.shimIndexedDB[prop] = function () {
+        IDB.shimIndexedDB = /** @type {ShimIndexedDB} */ ({});
+        /** @type {const} */ ([
+            '__useShim', '__debug', '__setConfig',
+            '__getConfig', '__setUnicodeIdentifiers'
+        ]).forEach((prop) => {
+            /** @type {ShimIndexedDB} */ (IDB.shimIndexedDB)[prop] = /** @type {() => any} */ function () {
                 console.warn('This browser does not have WebSQL to shim.');
             };
         });
@@ -203,7 +332,11 @@ function setGlobalVars (idb, initialConfig) {
 
     // Workaround to prevent an error in Firefox
     if (!('indexedDB' in IDB) && typeof window !== 'undefined') { // 2nd condition avoids problems in Node
-        IDB.indexedDB = IDB.indexedDB || IDB.webkitIndexedDB || IDB.mozIndexedDB || IDB.oIndexedDB || IDB.msIndexedDB;
+        IDB.indexedDB = /** @type {IDBFactory} */ (IDB.indexedDB ||
+            ('webkitIndexedDB' in IDB && IDB.webkitIndexedDB) ||
+            ('mozIndexedDB' in IDB && IDB.mozIndexedDB) ||
+            ('oIndexedDB' in IDB && IDB.oIndexedDB) ||
+            ('msIndexedDB' in IDB && IDB.msIndexedDB));
     }
 
     // Detect browsers with known IndexedDB issues (e.g. Android pre-4.4)
@@ -224,7 +357,7 @@ function setGlobalVars (idb, initialConfig) {
                 // Detect iOS: http://stackoverflow.com/questions/9038625/detect-if-device-is-ios/9039885#9039885
                 // and detect version 9: http://stackoverflow.com/a/26363560/271577
                 (/(iPad|iPhone|iPod).* os 9_/ui).test(navigator.userAgent) &&
-                !window.MSStream // But avoid IE11
+                !('MSStream' in window) // But avoid IE11
             )
         )
     ) {
@@ -251,12 +384,16 @@ function setGlobalVars (idb, initialConfig) {
     ) {
         IDB.shimIndexedDB.__useShim();
     } else {
-        IDB.IDBDatabase = IDB.IDBDatabase || IDB.webkitIDBDatabase;
-        IDB.IDBTransaction = IDB.IDBTransaction || IDB.webkitIDBTransaction || {};
-        IDB.IDBCursor = IDB.IDBCursor || IDB.webkitIDBCursor;
-        IDB.IDBKeyRange = IDB.IDBKeyRange || IDB.webkitIDBKeyRange;
+        IDB.IDBDatabase = IDB.IDBDatabase ||
+            ('webkitIDBDatabase' in IDB && IDB.webkitIDBDatabase);
+        IDB.IDBTransaction = IDB.IDBTransaction ||
+            ('webkitIDBTransaction' in IDB && IDB.webkitIDBTransaction) || {};
+        IDB.IDBCursor = IDB.IDBCursor ||
+            ('webkitIDBCursor' in IDB && IDB.webkitIDBCursor);
+        IDB.IDBKeyRange = IDB.IDBKeyRange ||
+            ('webkitIDBKeyRange' in IDB && IDB.webkitIDBKeyRange);
     }
-    return IDB;
+    return /** @type {ShimmedObject} */ (IDB);
 }
 
 // Expose for ease in simulating such exceptions during testing

package/src/unicode-regex.js

@@ -1,3 +1,5 @@
+// @ts-nocheck
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }