indexeddbshim 12.0.0 → 13.0.0

package/src/IDBKeyRange.js

@@ -2,25 +2,40 @@ import {createDOMException} from './DOMException.js';
 import * as Key from './Key.js';
 import * as util from './util.js';
 
-const readonlyProperties = ['lower', 'upper', 'lowerOpen', 'upperOpen'];
+const readonlyProperties = /** @type {const} */ (['lower', 'upper', 'lowerOpen', 'upperOpen']);
+
+/**
+ * @typedef {globalThis.IDBKeyRange & {
+*   __lowerCached: string|null|false,
+*   __upperCached: string|null|false,
+*   __lowerOpen: boolean,
+* }} IDBKeyRangeFull
+*/
 
-/* eslint-disable jsdoc/check-param-names */
 /**
  * The IndexedDB KeyRange object.
  * @see http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#dfn-key-range
- * @param {Object} lower
- * @param {Object} upper
- * @param {Object} lowerOpen
- * @param {Object} upperOpen
  * @throws {TypeError}
  * @class
  */
 function IDBKeyRange () {
-    /* eslint-enable jsdoc/check-param-names */
+    this.__lowerOpen = false;
+    this.__upperOpen = false;
     throw new TypeError('Illegal constructor');
 }
 const IDBKeyRangeAlias = IDBKeyRange;
+
+/**
+ * @param {import('./Key.js').Key|null} lower
+ * @param {import('./Key.js').Key|null} upper
+ * @param {boolean} lowerOpen
+ * @param {boolean} upperOpen
+ * @returns {import('./IDBKeyRange.js').IDBKeyRangeFull}
+ */
 IDBKeyRange.__createInstance = function (lower, upper, lowerOpen, upperOpen) {
+    /**
+     * @class
+     */
     function IDBKeyRange () {
         this[Symbol.toStringTag] = 'IDBKeyRange';
         if (lower === undefined && upper === undefined) {
@@ -36,7 +51,10 @@ IDBKeyRange.__createInstance = function (lower, upper, lowerOpen, upperOpen) {
             Key.convertValueToKeyRethrowingAndIfInvalid(upper);
         }
         if (lower !== undefined && upper !== undefined && lower !== upper) {
-            if (Key.encode(lower) > Key.encode(upper)) {
+            if (
+                /** @type {string} */ (Key.encode(lower)) >
+                /** @type {string} */ (Key.encode(upper))
+            ) {
                 throw createDOMException('DataError', '`lower` must not be greater than `upper` argument in `bound()` call.');
             }
         }
@@ -47,8 +65,16 @@ IDBKeyRange.__createInstance = function (lower, upper, lowerOpen, upperOpen) {
         this.__upperOpen = Boolean(upperOpen);
     }
     IDBKeyRange.prototype = IDBKeyRangeAlias.prototype;
+
+    // @ts-expect-error Properties added by `defineProperty/ies`
     return new IDBKeyRange();
 };
+
+/**
+ * @param {import('./Key.js').Key} key
+ * @this {IDBKeyRangeFull}
+ * @returns {boolean}
+ */
 IDBKeyRange.prototype.includes = function (key) {
     // We can't do a regular instanceof check as it will create a loop given our hasInstance implementation
     if (!util.isObj(this) || typeof this.__lowerOpen !== 'boolean') {
@@ -61,6 +87,10 @@ IDBKeyRange.prototype.includes = function (key) {
     return Key.isKeyInRange(key, this);
 };
 
+/**
+ * @param {import('./Key.js').Value} value
+ * @returns {import('./IDBKeyRange.js').IDBKeyRangeFull}
+ */
 IDBKeyRange.only = function (value) {
     if (!arguments.length) {
         throw new TypeError('IDBKeyRange.only requires a value argument');
@@ -68,20 +98,35 @@ IDBKeyRange.only = function (value) {
     return IDBKeyRange.__createInstance(value, value, false, false);
 };
 
-IDBKeyRange.lowerBound = function (value /*, open */) {
+/**
+ * @param {import('./Key.js').Value} value
+ * @returns {globalThis.IDBKeyRange}
+ */
+IDBKeyRange.lowerBound = function (value /* , open */) {
     if (!arguments.length) {
         throw new TypeError('IDBKeyRange.lowerBound requires a value argument');
     }
     // eslint-disable-next-line prefer-rest-params
     return IDBKeyRange.__createInstance(value, undefined, arguments[1], true);
 };
-IDBKeyRange.upperBound = function (value /*, open */) {
+
+/**
+ * @param {import('./Key.js').Value} value
+ * @returns {globalThis.IDBKeyRange}
+ */
+IDBKeyRange.upperBound = function (value /* , open */) {
     if (!arguments.length) {
         throw new TypeError('IDBKeyRange.upperBound requires a value argument');
     }
     // eslint-disable-next-line prefer-rest-params
     return IDBKeyRange.__createInstance(undefined, value, true, arguments[1]);
 };
+
+/**
+ * @param {import('./Key.js').Value} lower
+ * @param {import('./Key.js').Value} upper
+ * @returns {globalThis.IDBKeyRange}
+ */
 IDBKeyRange.bound = function (lower, upper /* , lowerOpen, upperOpen */) {
     if (arguments.length <= 1) {
         throw new TypeError('IDBKeyRange.bound requires lower and upper arguments');
@@ -99,6 +144,9 @@ readonlyProperties.forEach((prop) => {
     });
     // Ensure for proper interface testing that "get <name>" is the function name
     const o = {
+        /**
+         * @returns {import('./Key.js').Key|null|boolean}
+         */
         get [prop] () {
             // We can't do a regular instanceof check as it will create a loop given our hasInstance implementation
             if (!util.isObj(this) || typeof this.__lowerOpen !== 'boolean') {
@@ -107,23 +155,42 @@ readonlyProperties.forEach((prop) => {
             return this['__' + prop];
         }
     };
-    const desc = Object.getOwnPropertyDescriptor(o, prop);
+    const desc = /** @type {PropertyDescriptor} */ (
+        Object.getOwnPropertyDescriptor(o, prop)
+    );
     // desc.enumerable = true; // Default
     // desc.configurable = true; // Default
     Object.defineProperty(IDBKeyRange.prototype, prop, desc);
 });
 
 Object.defineProperty(IDBKeyRange, Symbol.hasInstance, {
-    value: (obj) => util.isObj(obj) && 'upper' in obj && typeof obj.lowerOpen === 'boolean'
+    value:
+        /**
+         * @param {object} obj
+         * @returns {boolean}
+         */
+        (obj) => util.isObj(obj) && 'upper' in obj && 'lowerOpen' in obj &&
+            typeof obj.lowerOpen === 'boolean'
 });
 
 Object.defineProperty(IDBKeyRange, 'prototype', {
     writable: false
 });
 
-function setSQLForKeyRange (range, quotedKeyColumnName, sql, sqlValues, addAnd, checkCached) {
+/**
+ * @param {IDBKeyRangeFull|undefined} range
+ * @param {string} quotedKeyColumnName
+ * @param {string[]} sql
+ * @param {string[]} sqlValues
+ * @param {boolean} [addAnd]
+ * @param {boolean} [checkCached]
+ * @returns {void}
+ */
+function setSQLForKeyRange (
+    range, quotedKeyColumnName, sql, sqlValues, addAnd, checkCached
+) {
     if (range && (range.lower !== undefined || range.upper !== undefined)) {
-        if (addAnd) sql.push('AND');
+        if (addAnd) { sql.push('AND'); }
         let encodedLowerKey, encodedUpperKey;
         const hasLower = range.lower !== undefined;
         const hasUpper = range.upper !== undefined;
@@ -134,21 +201,27 @@ function setSQLForKeyRange (range, quotedKeyColumnName, sql, sqlValues, addAnd,
             encodedUpperKey = checkCached ? range.__upperCached : Key.encode(range.upper);
         }
         if (hasLower) {
-            sqlValues.push(util.escapeSQLiteStatement(encodedLowerKey));
+            sqlValues.push(util.escapeSQLiteStatement(/** @type {string} */ (encodedLowerKey)));
             if (hasUpper && encodedLowerKey === encodedUpperKey && !range.lowerOpen && !range.upperOpen) {
                 sql.push(quotedKeyColumnName, '=', '?');
                 return;
             }
             sql.push(quotedKeyColumnName, (range.lowerOpen ? '>' : '>='), '?');
         }
-        (hasLower && hasUpper) && sql.push('AND');
+        if (hasLower && hasUpper) { sql.push('AND'); }
         if (hasUpper) {
             sql.push(quotedKeyColumnName, (range.upperOpen ? '<' : '<='), '?');
-            sqlValues.push(util.escapeSQLiteStatement(encodedUpperKey));
+            sqlValues.push(util.escapeSQLiteStatement(/** @type {string} */ (encodedUpperKey)));
         }
     }
 }
 
+/**
+ * @param {import('./Key.js').Value} value
+ * @param {boolean} [nullDisallowed]
+ * @throws {DOMException}
+ * @returns {import('./IDBKeyRange.js').IDBKeyRangeFull|undefined}
+ */
 function convertValueToKeyRange (value, nullDisallowed) {
     if (util.instanceOf(value, IDBKeyRange)) {
         // We still need to validate IDBKeyRange-like objects (the above check is based on loose duck-typing)