indexeddbshim 11.0.0 → 12.0.0-pre.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,6 +178,8 @@ 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);
         }
@@ -82,8 +190,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 +238,8 @@ function setGlobalVars (idb, initialConfig) {
                         return shimIndexedDB;
                     }
                 });
-                [
+                /** @type {[string, any][]} */
+                ([
                     ['IDBFactory', shimIDBFactory],
                     ['IDBDatabase', shimIDBDatabase],
                     ['IDBObjectStore', shimIDBObjectStore],
@@ -137,7 +251,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 +286,10 @@ function setGlobalVars (idb, initialConfig) {
                         setNonIDBGlobals();
                     }
                 }
+                /* istanbul ignore next -- TS guard */
+                if (!IDB.shimIndexedDB) {
+                    return;
+                }
                 IDB.shimIndexedDB.__setConnectionQueueOrigin();
             }
         };
@@ -180,22 +298,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 +330,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 +355,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 +382,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,11 @@
+// @ts-nocheck
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 var regex=/[\xC0-\xC5\xC7-\xCF\xD1-\xD6\xD9-\xDD\xE0-\xE5\xE7-\xEF\xF1-\xF6\xF9-\xFD\xFF-\u010F\u0112-\u0125\u0128-\u0130\u0134-\u0137\u0139-\u013E\u0143-\u0148\u014C-\u0151\u0154-\u0165\u0168-\u017E\u01A0\u01A1\u01AF\u01B0\u01CD-\u01DC\u01DE-\u01E3\u01E6-\u01F0\u01F4\u01F5\u01F8-\u021B\u021E\u021F\u0226-\u0233\u0344\u0385\u0386\u0388-\u038A\u038C\u038E-\u0390\u03AA-\u03B0\u03CA-\u03CE\u03D3\u03D4\u0400\u0401\u0403\u0407\u040C-\u040E\u0419\u0439\u0450\u0451\u0453\u0457\u045C-\u045E\u0476\u0477\u04C1\u04C2\u04D0-\u04D3\u04D6\u04D7\u04DA-\u04DF\u04E2-\u04E7\u04EA-\u04F5\u04F8\u04F9\u0622-\u0626\u06C0\u06C2\u06D3\u0929\u0931\u0934\u0958-\u095F\u09CB\u09CC\u09DC\u09DD\u09DF\u0A33\u0A36\u0A59-\u0A5B\u0A5E\u0B48\u0B4B\u0B4C\u0B5C\u0B5D\u0B94\u0BCA-\u0BCC\u0C48\u0CC0\u0CC7\u0CC8\u0CCA\u0CCB\u0D4A-\u0D4C\u0DDA\u0DDC-\u0DDE\u0F43\u0F4D\u0F52\u0F57\u0F5C\u0F69\u0F73\u0F75\u0F76\u0F78\u0F81\u0F93\u0F9D\u0FA2\u0FA7\u0FAC\u0FB9\u1026\u1B06\u1B08\u1B0A\u1B0C\u1B0E\u1B12\u1B3B\u1B3D\u1B40\u1B41\u1B43\u1E00-\u1E99\u1E9B\u1EA0-\u1EF9\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FC1-\u1FC4\u1FC6-\u1FD3\u1FD6-\u1FDB\u1FDD-\u1FEE\u1FF2-\u1FF4\u1FF6-\u1FFC\u212B\u219A\u219B\u21AE\u21CD-\u21CF\u2204\u2209\u220C\u2224\u2226\u2241\u2244\u2247\u2249\u2260\u2262\u226D-\u2271\u2274\u2275\u2278\u2279\u2280\u2281\u2284\u2285\u2288\u2289\u22AC-\u22AF\u22E0-\u22E3\u22EA-\u22ED\u2ADC\u304C\u304E\u3050\u3052\u3054\u3056\u3058\u305A\u305C\u305E\u3060\u3062\u3065\u3067\u3069\u3070\u3071\u3073\u3074\u3076\u3077\u3079\u307A\u307C\u307D\u3094\u309E\u30AC\u30AE\u30B0\u30B2\u30B4\u30B6\u30B8\u30BA\u30BC\u30BE\u30C0\u30C2\u30C5\u30C7\u30C9\u30D0\u30D1\u30D3\u30D4\u30D6\u30D7\u30D9\u30DA\u30DC\u30DD\u30F4\u30F7-\u30FA\u30FE\uAC00-\uD7A3\uFB1D\uFB1F\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFB4E]|\uD804[\uDC9A\uDC9C\uDCAB\uDD2E\uDD2F\uDF4B\uDF4C]|\uD805[\uDCBB\uDCBC\uDCBE\uDDBA\uDDBB]|\uD806\uDD38|\uD834[\uDD5E-\uDD64\uDDBB-\uDDC0]/;
 
-export { regex as default };
+var regex$1 = /*@__PURE__*/getDefaultExportFromCjs(regex);
+
+export { regex$1 as default };