@itwin/presentation-common 3.4.4 → 3.4.5

package/lib/esm/presentation-common/KeySet.js

@@ -1,415 +1,415 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Core
- */
-import { CompressedId64Set, Guid, Id64 } from "@itwin/core-bentley";
-import { PresentationError, PresentationStatus } from "./Error";
-import { NodeKey } from "./hierarchy/Key";
-/** @public */
-export var Key;
-(function (Key) {
-    /** Check if the supplied key is a `NodeKey` */
-    function isNodeKey(key) {
-        return key.type;
-    }
-    Key.isNodeKey = isNodeKey;
-    /** Check if the supplied key is an `InstanceKey` */
-    function isInstanceKey(key) {
-        return key.className && key.id;
-    }
-    Key.isInstanceKey = isInstanceKey;
-    /** Check if the supplied key is an `EntityProps` */
-    function isEntityProps(key) {
-        return key.classFullName && key.id;
-    }
-    Key.isEntityProps = isEntityProps;
-})(Key || (Key = {}));
-/**
- * A class that holds multiple [[Key]] objects. It's basically
- * used as a container that holds multiple keys of different types.
- *
- * @public
- */
-export class KeySet {
-    /**
-     * Creates an instance of KeySet.
-     * @param source Optional source to initialize from.
-     */
-    constructor(source) {
-        this._instanceKeys = new Map();
-        this._lowerCaseMap = new Map();
-        this._nodeKeys = new Set();
-        this.recalculateGuid();
-        if (source)
-            this.add(source);
-    }
-    recalculateGuid() {
-        // empty keyset should have empty guid, otherwise use a random guid value
-        this._guid = this.isEmpty ? Guid.empty : Guid.createValue();
-    }
-    /**
-     * Get a GUID that identifies changes in this keyset. The value
-     * does not uniquely identify contents of the keyset, but it can be
-     * used to check whether keyset has changed.
-     */
-    get guid() { return this._guid; }
-    /**
-     * Get a map of instance keys stored in this KeySet
-     *
-     * **Warning**: getting instance keys might be expensive for
-     * large KeySets.
-     */
-    get instanceKeys() {
-        const map = new Map();
-        for (const entry of this._instanceKeys)
-            map.set(this._lowerCaseMap.get(entry["0"]), new Set([...entry["1"]].map((key) => Id64.fromJSON(key))));
-        return map;
-    }
-    /**
-     * Get instance keys count
-     */
-    get instanceKeysCount() {
-        let count = 0;
-        this._instanceKeys.forEach((set) => count += set.size);
-        return count;
-    }
-    /**
-     * Get a set of node keys stored in this KeySet
-     *
-     * **Warning**: getting node keys might be expensive for
-     * large KeySets.
-     */
-    get nodeKeys() {
-        const set = new Set();
-        for (const serialized of this._nodeKeys) {
-            const key = NodeKey.fromJSON(JSON.parse(serialized));
-            set.add(key);
-        }
-        return set;
-    }
-    /**
-     * Get node keys count
-     */
-    get nodeKeysCount() {
-        return this._nodeKeys.size;
-    }
-    isKeySet(set) {
-        return set._nodeKeys && set._instanceKeys;
-    }
-    isKeysArray(keys) {
-        return Array.isArray(keys);
-    }
-    /**
-     * Clear this KeySet.
-     * @returns itself
-     */
-    clear() {
-        if (this.isEmpty)
-            return this;
-        this._instanceKeys = new Map();
-        this._lowerCaseMap = new Map();
-        this._nodeKeys = new Set();
-        this.recalculateGuid();
-        return this;
-    }
-    addKeySet(keyset, pred) {
-        for (const key of keyset._nodeKeys) {
-            if (!pred || pred(NodeKey.fromJSON(JSON.parse(key))))
-                this._nodeKeys.add(key);
-        }
-        for (const entry of keyset._instanceKeys) {
-            let set = this._instanceKeys.get(entry["0"]);
-            const className = keyset._lowerCaseMap.get(entry["0"]);
-            if (!set) {
-                set = new Set();
-                this._instanceKeys.set(entry["0"], set);
-                this._lowerCaseMap.set(entry["0"], className);
-            }
-            entry["1"].forEach((id) => {
-                if (!pred || pred({ className, id }))
-                    set.add(id);
-            });
-        }
-    }
-    addKeySetJSON(keyset) {
-        for (const key of keyset.nodeKeys)
-            this._nodeKeys.add(JSON.stringify(key));
-        for (const entry of keyset.instanceKeys) {
-            const lcClassName = entry["0"].toLowerCase();
-            const ids = entry["1"] === Id64.invalid ? new Set([Id64.invalid]) : CompressedId64Set.decompressSet(entry["1"]);
-            this._instanceKeys.set(lcClassName, ids);
-            this._lowerCaseMap.set(lcClassName, entry["0"]);
-        }
-    }
-    /**
-     * Add a key or keys to this KeySet.
-     * @param value A key or keys to add.
-     * @param pred An optional predicate function that indicates whether a key should be added
-     * @returns itself
-     */
-    add(value, pred) {
-        if (!value)
-            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
-        const sizeBefore = this.size;
-        if (this.isKeySet(value)) {
-            this.addKeySet(value, pred);
-        }
-        else if (this.isKeysArray(value)) {
-            value.forEach((key) => this.add(key, pred));
-        }
-        else if (!pred || pred(value)) {
-            if (Key.isEntityProps(value)) {
-                this.add({ className: value.classFullName, id: Id64.fromJSON(value.id) });
-            }
-            else if (Key.isInstanceKey(value)) {
-                const lcClassName = value.className.toLowerCase();
-                if (!this._instanceKeys.has(lcClassName)) {
-                    this._instanceKeys.set(lcClassName, new Set());
-                    this._lowerCaseMap.set(lcClassName, value.className);
-                }
-                this._lowerCaseMap.set(lcClassName, value.className);
-                this._instanceKeys.get(lcClassName).add(value.id);
-            }
-            else if (Key.isNodeKey(value)) {
-                this._nodeKeys.add(JSON.stringify(value));
-            }
-            else {
-                throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
-            }
-        }
-        if (this.size !== sizeBefore)
-            this.recalculateGuid();
-        return this;
-    }
-    deleteKeySet(keyset) {
-        for (const key of keyset._nodeKeys)
-            this._nodeKeys.delete(key);
-        for (const entry of keyset._instanceKeys) {
-            const set = this._instanceKeys.get(entry["0"].toLowerCase());
-            if (set) {
-                entry["1"].forEach((key) => {
-                    set.delete(key);
-                });
-            }
-        }
-    }
-    /**
-     * Deletes a key or keys from this KeySet.
-     * @param value A key or keys to delete.
-     * @returns itself
-     */
-    delete(value) {
-        if (!value)
-            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
-        const sizeBefore = this.size;
-        if (this.isKeySet(value)) {
-            this.deleteKeySet(value);
-        }
-        else if (this.isKeysArray(value)) {
-            for (const key of value)
-                this.delete(key);
-        }
-        else if (Key.isEntityProps(value)) {
-            this.delete({ className: value.classFullName, id: value.id });
-        }
-        else if (Key.isInstanceKey(value)) {
-            const set = this._instanceKeys.get(value.className.toLowerCase());
-            if (set)
-                set.delete(value.id);
-        }
-        else if (Key.isNodeKey(value)) {
-            this._nodeKeys.delete(JSON.stringify(value));
-        }
-        else {
-            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
-        }
-        if (this.size !== sizeBefore)
-            this.recalculateGuid();
-        return this;
-    }
-    /**
-     * Check if this KeySet contains the specified key.
-     * @param value The key to check.
-     */
-    has(value) {
-        if (!value)
-            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
-        if (Key.isEntityProps(value))
-            return this.has({ className: value.classFullName, id: value.id });
-        if (Key.isInstanceKey(value)) {
-            const set = this._instanceKeys.get(value.className.toLowerCase());
-            return !!(set && set.has(value.id));
-        }
-        if (Key.isNodeKey(value))
-            return this._nodeKeys.has(JSON.stringify(value));
-        throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
-    }
-    hasKeySet(readonlyKeys, checkType) {
-        // note: cast-away read-onlyness to access private members...
-        const keys = readonlyKeys;
-        if (checkType === "all") {
-            if (this._nodeKeys.size < keys._nodeKeys.size || this._instanceKeys.size < keys._instanceKeys.size)
-                return false;
-            if ([...keys._nodeKeys].some((key) => !this._nodeKeys.has(key)))
-                return false;
-            for (const otherEntry of keys._instanceKeys) {
-                const thisEntryKeys = this._instanceKeys.get(otherEntry["0"].toLowerCase());
-                if (!thisEntryKeys || thisEntryKeys.size < otherEntry["1"].size)
-                    return false;
-                if ([...otherEntry["1"]].some((key) => !thisEntryKeys.has(key)))
-                    return false;
-            }
-            return true;
-        }
-        // "any" check type
-        if ([...keys._nodeKeys].some((key) => this._nodeKeys.has(key)))
-            return true;
-        for (const otherEntry of keys._instanceKeys) {
-            const thisEntryKeys = this._instanceKeys.get(otherEntry["0"].toLowerCase());
-            if (thisEntryKeys && [...otherEntry["1"]].some((key) => thisEntryKeys.has(key)))
-                return true;
-        }
-        return false;
-    }
-    hasKeysArray(keys, checkType) {
-        if (checkType === "all") {
-            if (this.size < keys.length)
-                return false;
-            for (const key of keys) {
-                if (!this.has(key))
-                    return false;
-            }
-            return true;
-        }
-        // "any" check type
-        for (const key of keys) {
-            if (this.has(key))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Check if this KeySet contains all the specified keys.
-     * @param keys The keys to check.
-     */
-    hasAll(keys) {
-        if (!keys)
-            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${keys}`);
-        if (this.isKeySet(keys))
-            return this.hasKeySet(keys, "all");
-        if (this.isKeysArray(keys))
-            return this.hasKeysArray(keys, "all");
-        throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: keys = ${keys}`);
-    }
-    /**
-     * Check if this KeySet contains any of the specified keys.
-     * @param keys The keys to check.
-     */
-    hasAny(keys) {
-        if (!keys)
-            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${keys}`);
-        if (this.isKeySet(keys))
-            return this.hasKeySet(keys, "any");
-        if (this.isKeysArray(keys))
-            return this.hasKeysArray(keys, "any");
-        throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: keys = ${keys}`);
-    }
-    /**
-     * Get the number of keys stored in this KeySet.
-     */
-    get size() {
-        const nodeKeysCount = this._nodeKeys.size;
-        let instanceIdsCount = 0;
-        for (const set of this._instanceKeys.values())
-            instanceIdsCount += set.size;
-        return nodeKeysCount + instanceIdsCount;
-    }
-    /**
-     * Is this KeySet currently empty.
-     */
-    get isEmpty() {
-        return 0 === this.size;
-    }
-    /** Iterate over all keys in this keyset. */
-    some(callback) {
-        for (const entry of this._instanceKeys) {
-            const className = this._lowerCaseMap.get(entry["0"].toLowerCase());
-            if (some(entry[1], (id) => callback({ className, id })))
-                return true;
-        }
-        return some(this._nodeKeys, (serializedKey) => callback(NodeKey.fromJSON(JSON.parse(serializedKey))));
-    }
-    /** Iterate over all keys in this keyset. */
-    forEach(callback) {
-        let index = 0;
-        this._instanceKeys.forEach((ids, className) => {
-            const recentClassName = this._lowerCaseMap.get(className.toLowerCase());
-            ids.forEach((id) => callback({ className: recentClassName, id }, index++));
-        });
-        this._nodeKeys.forEach((serializedKey) => {
-            callback(NodeKey.fromJSON(JSON.parse(serializedKey)), index++);
-        });
-    }
-    /** Iterate over all keys in this keyset in batches */
-    forEachBatch(batchSize, callback) {
-        const size = this.size;
-        const count = Math.ceil(size / batchSize);
-        if (1 === count) {
-            callback(this, 0);
-            return;
-        }
-        let batch = new KeySet();
-        let batchIndex = 0;
-        let currBatchSize = 0;
-        this.forEach((key, index) => {
-            batch.add(key);
-            ++currBatchSize;
-            if (currBatchSize === batchSize || index === (size - 1)) {
-                callback(batch, batchIndex++);
-                batch = new KeySet();
-                currBatchSize = 0;
-            }
-        });
-    }
-    /**
-     * Serializes this KeySet to JSON
-     * @public
-     */
-    toJSON() {
-        const instanceKeys = [];
-        for (const entry of this._instanceKeys.entries()) {
-            if (entry["1"].size > 0) {
-                const className = this._lowerCaseMap.get(entry["0"].toLowerCase());
-                const compressedIds = CompressedId64Set.sortAndCompress(entry["1"]);
-                instanceKeys.push([className, compressedIds.length > 0 ? compressedIds : Id64.invalid]);
-            }
-        }
-        const nodeKeys = [];
-        for (const serializedKey of this._nodeKeys.values())
-            nodeKeys.push(JSON.parse(serializedKey));
-        return {
-            instanceKeys,
-            nodeKeys,
-        };
-    }
-    /**
-     * Creates a KeySet from JSON
-     * @public
-     */
-    static fromJSON(json) {
-        const keyset = new KeySet();
-        keyset.addKeySetJSON(json);
-        return keyset;
-    }
-}
-const some = (set, cb) => {
-    for (const item of set) {
-        if (cb(item))
-            return true;
-    }
-    return false;
-};
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Core
+ */
+import { CompressedId64Set, Guid, Id64 } from "@itwin/core-bentley";
+import { PresentationError, PresentationStatus } from "./Error";
+import { NodeKey } from "./hierarchy/Key";
+/** @public */
+export var Key;
+(function (Key) {
+    /** Check if the supplied key is a `NodeKey` */
+    function isNodeKey(key) {
+        return key.type;
+    }
+    Key.isNodeKey = isNodeKey;
+    /** Check if the supplied key is an `InstanceKey` */
+    function isInstanceKey(key) {
+        return key.className && key.id;
+    }
+    Key.isInstanceKey = isInstanceKey;
+    /** Check if the supplied key is an `EntityProps` */
+    function isEntityProps(key) {
+        return key.classFullName && key.id;
+    }
+    Key.isEntityProps = isEntityProps;
+})(Key || (Key = {}));
+/**
+ * A class that holds multiple [[Key]] objects. It's basically
+ * used as a container that holds multiple keys of different types.
+ *
+ * @public
+ */
+export class KeySet {
+    /**
+     * Creates an instance of KeySet.
+     * @param source Optional source to initialize from.
+     */
+    constructor(source) {
+        this._instanceKeys = new Map();
+        this._lowerCaseMap = new Map();
+        this._nodeKeys = new Set();
+        this.recalculateGuid();
+        if (source)
+            this.add(source);
+    }
+    recalculateGuid() {
+        // empty keyset should have empty guid, otherwise use a random guid value
+        this._guid = this.isEmpty ? Guid.empty : Guid.createValue();
+    }
+    /**
+     * Get a GUID that identifies changes in this keyset. The value
+     * does not uniquely identify contents of the keyset, but it can be
+     * used to check whether keyset has changed.
+     */
+    get guid() { return this._guid; }
+    /**
+     * Get a map of instance keys stored in this KeySet
+     *
+     * **Warning**: getting instance keys might be expensive for
+     * large KeySets.
+     */
+    get instanceKeys() {
+        const map = new Map();
+        for (const entry of this._instanceKeys)
+            map.set(this._lowerCaseMap.get(entry["0"]), new Set([...entry["1"]].map((key) => Id64.fromJSON(key))));
+        return map;
+    }
+    /**
+     * Get instance keys count
+     */
+    get instanceKeysCount() {
+        let count = 0;
+        this._instanceKeys.forEach((set) => count += set.size);
+        return count;
+    }
+    /**
+     * Get a set of node keys stored in this KeySet
+     *
+     * **Warning**: getting node keys might be expensive for
+     * large KeySets.
+     */
+    get nodeKeys() {
+        const set = new Set();
+        for (const serialized of this._nodeKeys) {
+            const key = NodeKey.fromJSON(JSON.parse(serialized));
+            set.add(key);
+        }
+        return set;
+    }
+    /**
+     * Get node keys count
+     */
+    get nodeKeysCount() {
+        return this._nodeKeys.size;
+    }
+    isKeySet(set) {
+        return set._nodeKeys && set._instanceKeys;
+    }
+    isKeysArray(keys) {
+        return Array.isArray(keys);
+    }
+    /**
+     * Clear this KeySet.
+     * @returns itself
+     */
+    clear() {
+        if (this.isEmpty)
+            return this;
+        this._instanceKeys = new Map();
+        this._lowerCaseMap = new Map();
+        this._nodeKeys = new Set();
+        this.recalculateGuid();
+        return this;
+    }
+    addKeySet(keyset, pred) {
+        for (const key of keyset._nodeKeys) {
+            if (!pred || pred(NodeKey.fromJSON(JSON.parse(key))))
+                this._nodeKeys.add(key);
+        }
+        for (const entry of keyset._instanceKeys) {
+            let set = this._instanceKeys.get(entry["0"]);
+            const className = keyset._lowerCaseMap.get(entry["0"]);
+            if (!set) {
+                set = new Set();
+                this._instanceKeys.set(entry["0"], set);
+                this._lowerCaseMap.set(entry["0"], className);
+            }
+            entry["1"].forEach((id) => {
+                if (!pred || pred({ className, id }))
+                    set.add(id);
+            });
+        }
+    }
+    addKeySetJSON(keyset) {
+        for (const key of keyset.nodeKeys)
+            this._nodeKeys.add(JSON.stringify(key));
+        for (const entry of keyset.instanceKeys) {
+            const lcClassName = entry["0"].toLowerCase();
+            const ids = entry["1"] === Id64.invalid ? new Set([Id64.invalid]) : CompressedId64Set.decompressSet(entry["1"]);
+            this._instanceKeys.set(lcClassName, ids);
+            this._lowerCaseMap.set(lcClassName, entry["0"]);
+        }
+    }
+    /**
+     * Add a key or keys to this KeySet.
+     * @param value A key or keys to add.
+     * @param pred An optional predicate function that indicates whether a key should be added
+     * @returns itself
+     */
+    add(value, pred) {
+        if (!value)
+            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
+        const sizeBefore = this.size;
+        if (this.isKeySet(value)) {
+            this.addKeySet(value, pred);
+        }
+        else if (this.isKeysArray(value)) {
+            value.forEach((key) => this.add(key, pred));
+        }
+        else if (!pred || pred(value)) {
+            if (Key.isEntityProps(value)) {
+                this.add({ className: value.classFullName, id: Id64.fromJSON(value.id) });
+            }
+            else if (Key.isInstanceKey(value)) {
+                const lcClassName = value.className.toLowerCase();
+                if (!this._instanceKeys.has(lcClassName)) {
+                    this._instanceKeys.set(lcClassName, new Set());
+                    this._lowerCaseMap.set(lcClassName, value.className);
+                }
+                this._lowerCaseMap.set(lcClassName, value.className);
+                this._instanceKeys.get(lcClassName).add(value.id);
+            }
+            else if (Key.isNodeKey(value)) {
+                this._nodeKeys.add(JSON.stringify(value));
+            }
+            else {
+                throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
+            }
+        }
+        if (this.size !== sizeBefore)
+            this.recalculateGuid();
+        return this;
+    }
+    deleteKeySet(keyset) {
+        for (const key of keyset._nodeKeys)
+            this._nodeKeys.delete(key);
+        for (const entry of keyset._instanceKeys) {
+            const set = this._instanceKeys.get(entry["0"].toLowerCase());
+            if (set) {
+                entry["1"].forEach((key) => {
+                    set.delete(key);
+                });
+            }
+        }
+    }
+    /**
+     * Deletes a key or keys from this KeySet.
+     * @param value A key or keys to delete.
+     * @returns itself
+     */
+    delete(value) {
+        if (!value)
+            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
+        const sizeBefore = this.size;
+        if (this.isKeySet(value)) {
+            this.deleteKeySet(value);
+        }
+        else if (this.isKeysArray(value)) {
+            for (const key of value)
+                this.delete(key);
+        }
+        else if (Key.isEntityProps(value)) {
+            this.delete({ className: value.classFullName, id: value.id });
+        }
+        else if (Key.isInstanceKey(value)) {
+            const set = this._instanceKeys.get(value.className.toLowerCase());
+            if (set)
+                set.delete(value.id);
+        }
+        else if (Key.isNodeKey(value)) {
+            this._nodeKeys.delete(JSON.stringify(value));
+        }
+        else {
+            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
+        }
+        if (this.size !== sizeBefore)
+            this.recalculateGuid();
+        return this;
+    }
+    /**
+     * Check if this KeySet contains the specified key.
+     * @param value The key to check.
+     */
+    has(value) {
+        if (!value)
+            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
+        if (Key.isEntityProps(value))
+            return this.has({ className: value.classFullName, id: value.id });
+        if (Key.isInstanceKey(value)) {
+            const set = this._instanceKeys.get(value.className.toLowerCase());
+            return !!(set && set.has(value.id));
+        }
+        if (Key.isNodeKey(value))
+            return this._nodeKeys.has(JSON.stringify(value));
+        throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${value}`);
+    }
+    hasKeySet(readonlyKeys, checkType) {
+        // note: cast-away read-onlyness to access private members...
+        const keys = readonlyKeys;
+        if (checkType === "all") {
+            if (this._nodeKeys.size < keys._nodeKeys.size || this._instanceKeys.size < keys._instanceKeys.size)
+                return false;
+            if ([...keys._nodeKeys].some((key) => !this._nodeKeys.has(key)))
+                return false;
+            for (const otherEntry of keys._instanceKeys) {
+                const thisEntryKeys = this._instanceKeys.get(otherEntry["0"].toLowerCase());
+                if (!thisEntryKeys || thisEntryKeys.size < otherEntry["1"].size)
+                    return false;
+                if ([...otherEntry["1"]].some((key) => !thisEntryKeys.has(key)))
+                    return false;
+            }
+            return true;
+        }
+        // "any" check type
+        if ([...keys._nodeKeys].some((key) => this._nodeKeys.has(key)))
+            return true;
+        for (const otherEntry of keys._instanceKeys) {
+            const thisEntryKeys = this._instanceKeys.get(otherEntry["0"].toLowerCase());
+            if (thisEntryKeys && [...otherEntry["1"]].some((key) => thisEntryKeys.has(key)))
+                return true;
+        }
+        return false;
+    }
+    hasKeysArray(keys, checkType) {
+        if (checkType === "all") {
+            if (this.size < keys.length)
+                return false;
+            for (const key of keys) {
+                if (!this.has(key))
+                    return false;
+            }
+            return true;
+        }
+        // "any" check type
+        for (const key of keys) {
+            if (this.has(key))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Check if this KeySet contains all the specified keys.
+     * @param keys The keys to check.
+     */
+    hasAll(keys) {
+        if (!keys)
+            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${keys}`);
+        if (this.isKeySet(keys))
+            return this.hasKeySet(keys, "all");
+        if (this.isKeysArray(keys))
+            return this.hasKeysArray(keys, "all");
+        throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: keys = ${keys}`);
+    }
+    /**
+     * Check if this KeySet contains any of the specified keys.
+     * @param keys The keys to check.
+     */
+    hasAny(keys) {
+        if (!keys)
+            throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: value = ${keys}`);
+        if (this.isKeySet(keys))
+            return this.hasKeySet(keys, "any");
+        if (this.isKeysArray(keys))
+            return this.hasKeysArray(keys, "any");
+        throw new PresentationError(PresentationStatus.InvalidArgument, `Invalid argument: keys = ${keys}`);
+    }
+    /**
+     * Get the number of keys stored in this KeySet.
+     */
+    get size() {
+        const nodeKeysCount = this._nodeKeys.size;
+        let instanceIdsCount = 0;
+        for (const set of this._instanceKeys.values())
+            instanceIdsCount += set.size;
+        return nodeKeysCount + instanceIdsCount;
+    }
+    /**
+     * Is this KeySet currently empty.
+     */
+    get isEmpty() {
+        return 0 === this.size;
+    }
+    /** Iterate over all keys in this keyset. */
+    some(callback) {
+        for (const entry of this._instanceKeys) {
+            const className = this._lowerCaseMap.get(entry["0"].toLowerCase());
+            if (some(entry[1], (id) => callback({ className, id })))
+                return true;
+        }
+        return some(this._nodeKeys, (serializedKey) => callback(NodeKey.fromJSON(JSON.parse(serializedKey))));
+    }
+    /** Iterate over all keys in this keyset. */
+    forEach(callback) {
+        let index = 0;
+        this._instanceKeys.forEach((ids, className) => {
+            const recentClassName = this._lowerCaseMap.get(className.toLowerCase());
+            ids.forEach((id) => callback({ className: recentClassName, id }, index++));
+        });
+        this._nodeKeys.forEach((serializedKey) => {
+            callback(NodeKey.fromJSON(JSON.parse(serializedKey)), index++);
+        });
+    }
+    /** Iterate over all keys in this keyset in batches */
+    forEachBatch(batchSize, callback) {
+        const size = this.size;
+        const count = Math.ceil(size / batchSize);
+        if (1 === count) {
+            callback(this, 0);
+            return;
+        }
+        let batch = new KeySet();
+        let batchIndex = 0;
+        let currBatchSize = 0;
+        this.forEach((key, index) => {
+            batch.add(key);
+            ++currBatchSize;
+            if (currBatchSize === batchSize || index === (size - 1)) {
+                callback(batch, batchIndex++);
+                batch = new KeySet();
+                currBatchSize = 0;
+            }
+        });
+    }
+    /**
+     * Serializes this KeySet to JSON
+     * @public
+     */
+    toJSON() {
+        const instanceKeys = [];
+        for (const entry of this._instanceKeys.entries()) {
+            if (entry["1"].size > 0) {
+                const className = this._lowerCaseMap.get(entry["0"].toLowerCase());
+                const compressedIds = CompressedId64Set.sortAndCompress(entry["1"]);
+                instanceKeys.push([className, compressedIds.length > 0 ? compressedIds : Id64.invalid]);
+            }
+        }
+        const nodeKeys = [];
+        for (const serializedKey of this._nodeKeys.values())
+            nodeKeys.push(JSON.parse(serializedKey));
+        return {
+            instanceKeys,
+            nodeKeys,
+        };
+    }
+    /**
+     * Creates a KeySet from JSON
+     * @public
+     */
+    static fromJSON(json) {
+        const keyset = new KeySet();
+        keyset.addKeySetJSON(json);
+        return keyset;
+    }
+}
+const some = (set, cb) => {
+    for (const item of set) {
+        if (cb(item))
+            return true;
+    }
+    return false;
+};
 //# sourceMappingURL=KeySet.js.map