@itwin/core-frontend 5.0.0-dev.22 → 5.0.0-dev.24

package/lib/esm/SelectionSet.js

@@ -1,7 +1,19 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _HiliteSet_instances, _HiliteSet_mode, _HiliteSet_selectionChangesListener, _HiliteSet_changing, _HiliteSet_onChanged, _HiliteSet_change, _HiliteSet_processSelectionSetEvent, _SelectionSet_instances, _SelectionSet_selection, _SelectionSet_sendChangedEvent, _SelectionSet_add, _SelectionSet_remove;
 /** @packageDocumentation
  * @module SelectionSet
  */
@@ -13,85 +25,38 @@ import { IModelApp } from "./IModelApp";
  */
 export var SelectionSetEventType;
 (function (SelectionSetEventType) {
-    /** Elements have been added to the set. */
+    /** Ids have been added to the set. */
     SelectionSetEventType[SelectionSetEventType["Add"] = 0] = "Add";
-    /** Elements have been removed from the set. */
+    /** Ids have been removed from the set. */
     SelectionSetEventType[SelectionSetEventType["Remove"] = 1] = "Remove";
-    /** Some elements have been added to the set and others have been removed. */
+    /** Some ids have been added to the set and others have been removed. */
     SelectionSetEventType[SelectionSetEventType["Replace"] = 2] = "Replace";
-    /** All elements are about to be removed from the set. */
+    /** All ids have been removed from the set. */
     SelectionSetEventType[SelectionSetEventType["Clear"] = 3] = "Clear";
 })(SelectionSetEventType || (SelectionSetEventType = {}));
-/** Tracks a set of hilited entities. When the set changes, notifies ViewManager so that symbology overrides can be updated in active Viewports.
+/** Holds a set of hilited entities and makes any changes to the set by passing the change
+ * function to given `change` callback.
  * @internal
  */
 class HilitedIds extends Id64.Uint32Set {
-    constructor(iModel) {
+    constructor(_change) {
         super();
-        this._changing = false;
-        this._iModel = iModel;
+        this._change = _change;
     }
     add(low, high) {
-        super.add(low, high);
-        this.onChanged();
+        this._change(() => super.add(low, high));
     }
     delete(low, high) {
-        super.delete(low, high);
-        this.onChanged();
+        this._change(() => super.delete(low, high));
     }
     clear() {
-        super.clear();
-        this.onChanged();
+        this._change(() => super.clear());
     }
     addIds(ids) {
-        this.change(() => super.addIds(ids));
+        this._change(() => super.addIds(ids));
     }
     deleteIds(ids) {
-        this.change(() => super.deleteIds(ids));
-    }
-    onChanged() {
-        if (!this._changing)
-            IModelApp.viewManager.onSelectionSetChanged(this._iModel);
-    }
-    change(func) {
-        const changing = this._changing;
-        this._changing = false;
-        func();
-        this._changing = changing;
-        this.onChanged();
-    }
-}
-/** Keeps the set of hilited elements in sync with the selection set.
- * @internal
- */
-class HilitedElementIds extends HilitedIds {
-    constructor(iModel, syncWithSelectionSet = true) {
-        super(iModel);
-        this.wantSyncWithSelectionSet = syncWithSelectionSet;
-    }
-    get wantSyncWithSelectionSet() { return undefined !== this._removeListener; }
-    set wantSyncWithSelectionSet(want) {
-        if (want === this.wantSyncWithSelectionSet)
-            return;
-        if (want) {
-            const set = this._iModel.selectionSet;
-            this._removeListener = set.onChanged.addListener((ev) => this.change(() => this.processSelectionSetEvent(ev)));
-            this.processSelectionSetEvent({
-                set,
-                type: SelectionSetEventType.Add,
-                added: set.elements,
-            });
-        }
-        else {
-            this._removeListener();
-            this._removeListener = undefined;
-        }
-    }
-    processSelectionSetEvent(ev) {
-        if (SelectionSetEventType.Add !== ev.type)
-            this.deleteIds(ev.removed);
-        if (ev.type === SelectionSetEventType.Add || ev.type === SelectionSetEventType.Replace)
-            this.addIds(ev.added);
+        this._change(() => super.deleteIds(ids));
     }
 }
 /** A set of *hilited* elements for an [[IModelConnection]], by element id.
@@ -113,8 +78,6 @@ class HilitedElementIds extends HilitedIds {
  * @extensions
  */
 export class HiliteSet {
-    /** The set of hilited elements. */
-    get elements() { return this._elements; }
     /** Controls how the sets of hilited [[models]] and [[subcategories]] interact with one another.
      * By default they are treated as a union: a [Feature]($common) is hilited if either its model **or** its subcategory is hilited.
      * This can be changed to an intersection such that a [Feature]($common) is hilited only if both its model **and** subcategory are hilited.
@@ -122,60 +85,133 @@ export class HiliteSet {
      * [[elements]] is always hilited regardless of its model or subcategories.
      */
     get modelSubCategoryMode() {
-        return this._mode;
+        return __classPrivateFieldGet(this, _HiliteSet_mode, "f");
     }
     set modelSubCategoryMode(mode) {
-        if (mode === this._mode)
+        if (mode === __classPrivateFieldGet(this, _HiliteSet_mode, "f")) {
             return;
+        }
         this.onModelSubCategoryModeChanged.raiseEvent(mode);
-        this._mode = mode;
+        __classPrivateFieldSet(this, _HiliteSet_mode, mode, "f");
     }
     /** Construct a HiliteSet
      * @param iModel The iModel containing the entities to be hilited.
-     * @param syncWithSelectionSet If true, the contents of the `elements` set will be synchronized with those in the `iModel`'s [[SelectionSet]].
+     * @param syncWithSelectionSet If true, the hilite set contents will be synchronized with those in the `iModel`'s [[SelectionSet]].
      */
     constructor(iModel, syncWithSelectionSet = true) {
+        _HiliteSet_instances.add(this);
         this.iModel = iModel;
-        this._mode = "union";
+        _HiliteSet_mode.set(this, "union");
+        _HiliteSet_selectionChangesListener.set(this, void 0);
+        _HiliteSet_changing.set(this, false);
         /** Event raised just before changing the value of [[modelSubCategoryMode]]. */
         this.onModelSubCategoryModeChanged = new BeEvent();
-        this._elements = new HilitedElementIds(iModel, syncWithSelectionSet);
-        this.subcategories = new HilitedIds(iModel);
-        this.models = new HilitedIds(iModel);
+        this.elements = new HilitedIds((func) => __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, func));
+        this.subcategories = new HilitedIds((func) => __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, func));
+        this.models = new HilitedIds((func) => __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, func));
+        this.wantSyncWithSelectionSet = syncWithSelectionSet;
     }
-    /** Control whether the hilited elements will be synchronized with the contents of the [[SelectionSet]].
+    /** Control whether the hilite set will be synchronized with the contents of the [[SelectionSet]].
      * By default they are synchronized. Applications that override this take responsibility for managing the set of hilited entities.
      * When turning synchronization off, the contents of the HiliteSet will remain unchanged.
      * When turning synchronization on, the current contents of the HiliteSet will be preserved, and the contents of the selection set will be added to them.
      */
-    get wantSyncWithSelectionSet() { return this._elements.wantSyncWithSelectionSet; }
-    set wantSyncWithSelectionSet(want) { this._elements.wantSyncWithSelectionSet = want; }
+    get wantSyncWithSelectionSet() {
+        return !!__classPrivateFieldGet(this, _HiliteSet_selectionChangesListener, "f");
+    }
+    set wantSyncWithSelectionSet(want) {
+        if (want === this.wantSyncWithSelectionSet) {
+            return;
+        }
+        if (want) {
+            const set = this.iModel.selectionSet;
+            __classPrivateFieldSet(this, _HiliteSet_selectionChangesListener, set.onChanged.addListener((ev) => __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_processSelectionSetEvent).call(this, ev)), "f");
+            this.add(set.active);
+        }
+        else {
+            __classPrivateFieldGet(this, _HiliteSet_selectionChangesListener, "f")();
+            __classPrivateFieldSet(this, _HiliteSet_selectionChangesListener, undefined, "f");
+        }
+    }
+    /** Adds a collection of geometric element, model and subcategory ids to this hilite set. */
+    add(additions) {
+        __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, () => {
+            additions.elements && this.elements.addIds(additions.elements);
+            additions.models && this.models.addIds(additions.models);
+            additions.subcategories && this.subcategories.addIds(additions.subcategories);
+        });
+    }
+    /** Removes a collection of geometric element, model and subcategory ids from this hilite set. */
+    remove(removals) {
+        __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, () => {
+            removals.elements && this.elements.deleteIds(removals.elements);
+            removals.models && this.models.deleteIds(removals.models);
+            removals.subcategories && this.subcategories.deleteIds(removals.subcategories);
+        });
+    }
+    /** Replaces ids currently in the hilite set with the given collection. */
+    replace(ids) {
+        __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, () => {
+            this.clear();
+            this.add(ids);
+        });
+    }
     /** Remove all elements from the hilited set. */
     clear() {
-        this.elements.clear();
-        this.subcategories.clear();
-        this.models.clear();
+        __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, () => {
+            this.elements.clear();
+            this.models.clear();
+            this.subcategories.clear();
+        });
     }
     /** Returns true if nothing is hilited. */
-    get isEmpty() { return this.elements.isEmpty && this.subcategories.isEmpty && this.models.isEmpty; }
+    get isEmpty() {
+        return this.elements.isEmpty && this.subcategories.isEmpty && this.models.isEmpty;
+    }
     /** Toggle the hilited state of one or more elements.
      * @param arg the ID(s) of the elements whose state is to be toggled.
      * @param onOff True to add the elements to the hilited set, false to remove them.
+     * @deprecated in 5.0. Use [[add]], [[remove]], [[replace]] instead.
      */
     setHilite(arg, onOff) {
-        const oldSize = this.elements.size;
-        for (const id of Id64.iterable(arg)) {
-            if (onOff)
-                this.elements.addId(id);
-            else
-                this.elements.deleteId(id);
+        if (onOff) {
+            this.add({ elements: arg });
+        }
+        else {
+            this.remove({ elements: arg });
         }
-        if (oldSize !== this.elements.size)
-            IModelApp.viewManager.onSelectionSetChanged(this.iModel);
     }
 }
-/** A set of *currently selected* elements for an IModelConnection.
- * Selected elements are displayed with a customizable hilite effect within a [[Viewport]].
+_HiliteSet_mode = new WeakMap(), _HiliteSet_selectionChangesListener = new WeakMap(), _HiliteSet_changing = new WeakMap(), _HiliteSet_instances = new WeakSet(), _HiliteSet_onChanged = function _HiliteSet_onChanged() {
+    if (!__classPrivateFieldGet(this, _HiliteSet_changing, "f")) {
+        IModelApp.viewManager.onSelectionSetChanged(this.iModel);
+    }
+}, _HiliteSet_change = function _HiliteSet_change(func) {
+    const changing = __classPrivateFieldGet(this, _HiliteSet_changing, "f");
+    __classPrivateFieldSet(this, _HiliteSet_changing, true, "f");
+    try {
+        func();
+    }
+    finally {
+        __classPrivateFieldSet(this, _HiliteSet_changing, changing, "f");
+    }
+    __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_onChanged).call(this);
+}, _HiliteSet_processSelectionSetEvent = function _HiliteSet_processSelectionSetEvent(ev) {
+    switch (ev.type) {
+        case SelectionSetEventType.Add:
+            return this.add(ev.additions);
+        case SelectionSetEventType.Replace:
+            return __classPrivateFieldGet(this, _HiliteSet_instances, "m", _HiliteSet_change).call(this, () => {
+                this.add(ev.additions);
+                this.remove(ev.removals);
+            });
+        case SelectionSetEventType.Remove:
+        case SelectionSetEventType.Clear:
+            return this.remove(ev.removals);
+    }
+};
+/** A set of *currently selected* geometric elements, models and subcategories for an `IModelConnection`.
+ * Generally, selected elements are displayed with a customizable hilite effect within a [[Viewport]], see [[HiliteSet]].
  * @see [Hilite.Settings]($common) for customization of the hilite effect.
  * @public
  * @extensions
@@ -184,125 +220,353 @@ export class SelectionSet {
     /** The IDs of the selected elements.
      * @note Do not modify this set directly. Instead, use methods like [[SelectionSet.add]].
      */
-    get elements() { return this._elements; }
+    get elements() {
+        return __classPrivateFieldGet(this, _SelectionSet_selection, "f").elements;
+    }
+    /** The IDs of the selected models.
+     * @note Do not modify this set directly. Instead, use methods like [[SelectionSet.add]].
+     */
+    get models() {
+        return __classPrivateFieldGet(this, _SelectionSet_selection, "f").models;
+    }
+    /** The IDs of the selected subcategories.
+     * @note Do not modify this set directly. Instead, use methods like [[SelectionSet.add]].
+     */
+    get subcategories() {
+        return __classPrivateFieldGet(this, _SelectionSet_selection, "f").subcategories;
+    }
+    /** Get the active selection as a collection of geometric element, model and subcategory ids.
+     * @note Do not modify the sets in returned collection directly. Instead, use methods like [[SelectionSet.add]].
+     */
+    get active() {
+        return { ...__classPrivateFieldGet(this, _SelectionSet_selection, "f") };
+    }
     constructor(iModel) {
+        _SelectionSet_instances.add(this);
         this.iModel = iModel;
-        this._elements = new Set();
-        /** Called whenever elements are added or removed from this SelectionSet */
+        _SelectionSet_selection.set(this, void 0);
+        /** Called whenever ids are added or removed from this `SelectionSet` */
         this.onChanged = new BeEvent();
-    }
-    sendChangedEvent(ev) {
-        IModelApp.viewManager.onSelectionSetChanged(this.iModel);
-        this.onChanged.raiseEvent(ev);
+        __classPrivateFieldSet(this, _SelectionSet_selection, {
+            elements: new Set(),
+            models: new Set(),
+            subcategories: new Set(),
+        }, "f");
     }
     /** Get the number of entries in this selection set. */
-    get size() { return this.elements.size; }
-    /** Check whether there are any selected elements. */
-    get isActive() { return this.size !== 0; }
-    /** Return true if elemId is in this SelectionSet.
+    get size() {
+        return this.elements.size + this.models.size + this.subcategories.size;
+    }
+    /** Check whether there are any ids in this selection set. */
+    get isActive() {
+        return this.elements.size > 0 || this.models.size > 0 || this.subcategories.size > 0;
+    }
+    /** Return true if elemId is in this `SelectionSet`.
      * @see [[isSelected]]
+     * @deprecated in 5.0. Use `SelectionSet.elements.has(elemId)` instead.
      */
-    has(elemId) { return !!elemId && this.elements.has(elemId); }
+    has(elemId) {
+        return !!elemId && this.elements.has(elemId);
+    }
     /** Query whether an Id is in the selection set.
      * @see [[has]]
+     * @deprecated in 5.0. Use `SelectionSet.elements.has(elemId)` instead.
      */
-    isSelected(elemId) { return !!elemId && this.elements.has(elemId); }
+    isSelected(elemId) {
+        return !!elemId && this.elements.has(elemId);
+    }
     /** Clear current selection set.
      * @note raises the [[onChanged]] event with [[SelectionSetEventType.Clear]].
      */
     emptyAll() {
-        if (!this.isActive)
+        if (!this.isActive) {
             return;
-        const removed = this._elements;
-        this._elements = new Set();
-        this.sendChangedEvent({ set: this, type: SelectionSetEventType.Clear, removed });
+        }
+        const removals = __classPrivateFieldGet(this, _SelectionSet_selection, "f");
+        __classPrivateFieldSet(this, _SelectionSet_selection, {
+            elements: new Set(),
+            models: new Set(),
+            subcategories: new Set(),
+        }, "f");
+        __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, { set: this, type: SelectionSetEventType.Clear, removals, removed: removals.elements });
     }
     /**
      * Add one or more Ids to the current selection set.
      * @param elem The set of Ids to add.
      * @returns true if any elements were added.
      */
-    add(elem) {
-        return this._add(elem);
-    }
-    _add(elem, sendEvent = true) {
-        const oldSize = this.elements.size;
-        for (const id of Id64.iterable(elem))
-            this.elements.add(id);
-        const changed = oldSize !== this.elements.size;
-        if (sendEvent && changed)
-            this.sendChangedEvent({ type: SelectionSetEventType.Add, set: this, added: elem });
-        return changed;
+    add(adds) {
+        return !!__classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_add).call(this, adds);
     }
     /**
      * Remove one or more Ids from the current selection set.
      * @param elem The set of Ids to remove.
      * @returns true if any elements were removed.
      */
-    remove(elem) {
-        return this._remove(elem);
-    }
-    _remove(elem, sendEvent = true) {
-        const oldSize = this.elements.size;
-        for (const id of Id64.iterable(elem))
-            this.elements.delete(id);
-        const changed = oldSize !== this.elements.size;
-        if (sendEvent && changed)
-            this.sendChangedEvent({ type: SelectionSetEventType.Remove, set: this, removed: elem });
-        return changed;
+    remove(removes) {
+        return !!__classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_remove).call(this, removes);
     }
     /**
      * Add one set of Ids, and remove another set of Ids. Any Ids that are in both sets are removed.
      * @returns True if any Ids were either added or removed.
      */
     addAndRemove(adds, removes) {
-        const added = this._add(adds, false);
-        const removed = this._remove(removes, false);
-        if (added && removed)
-            this.sendChangedEvent({ type: SelectionSetEventType.Replace, set: this, added: adds, removed: removes });
-        else if (added)
-            this.sendChangedEvent({ type: SelectionSetEventType.Add, set: this, added: adds });
-        else if (removed)
-            this.sendChangedEvent({ type: SelectionSetEventType.Remove, set: this, removed: removes });
-        return (added || removed);
-    }
-    /** Invert the state of a set of Ids in the SelectionSet */
-    invert(elem) {
-        const elementsToAdd = new Set();
-        const elementsToRemove = new Set();
-        for (const id of Id64.iterable(elem)) {
-            if (this.elements.has(id))
-                elementsToRemove.add(id);
-            else
-                elementsToAdd.add(id);
+        const additions = __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_add).call(this, adds, false);
+        const removals = __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_remove).call(this, removes, false);
+        const addedElements = additions?.elements ?? [];
+        const removedElements = removals?.elements ?? [];
+        if (additions && removals) {
+            __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, {
+                type: SelectionSetEventType.Replace,
+                set: this,
+                additions,
+                added: addedElements,
+                removals,
+                removed: removedElements,
+            });
+        }
+        else if (additions) {
+            __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, {
+                type: SelectionSetEventType.Add,
+                set: this,
+                additions,
+                added: addedElements,
+            });
         }
-        return this.addAndRemove(elementsToAdd, elementsToRemove);
+        else if (removals) {
+            __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, {
+                type: SelectionSetEventType.Remove,
+                set: this,
+                removals,
+                removed: removedElements,
+            });
+        }
+        return !!additions || !!removals;
+    }
+    /** Invert the state of a set of Ids in the `SelectionSet` */
+    invert(ids) {
+        const adds = {};
+        const removes = {};
+        forEachSelectableType({
+            ids,
+            elements: (elementIds) => {
+                for (const id of Id64.iterable(elementIds)) {
+                    ((this.elements.has(id) ? removes : adds).elements ??= new Set()).add(id);
+                }
+            },
+            models: (modelIds) => {
+                for (const id of Id64.iterable(modelIds)) {
+                    ((this.models.has(id) ? removes : adds).models ??= new Set()).add(id);
+                }
+            },
+            subcategories: (subcategoryIds) => {
+                for (const id of Id64.iterable(subcategoryIds)) {
+                    ((this.subcategories.has(id) ? removes : adds).subcategories ??= new Set()).add(id);
+                }
+            },
+        });
+        return this.addAndRemove(adds, removes);
     }
     /** Change selection set to be the supplied set of Ids. */
-    replace(elem) {
-        if (areEqual(this.elements, elem))
-            return;
-        const removed = this._elements;
-        this._elements = new Set();
-        this._add(elem, false);
-        if (0 < removed.size) {
-            for (const id of Id64.iterable(elem)) {
-                if (removed.has(id))
-                    removed.delete(id);
-            }
+    replace(ids) {
+        if (areEqual(__classPrivateFieldGet(this, _SelectionSet_selection, "f"), ids)) {
+            return false;
         }
-        this.sendChangedEvent({ type: SelectionSetEventType.Replace, set: this, added: elem, removed });
+        const previousSelection = __classPrivateFieldGet(this, _SelectionSet_selection, "f");
+        __classPrivateFieldSet(this, _SelectionSet_selection, {
+            elements: new Set(),
+            models: new Set(),
+            subcategories: new Set(),
+        }, "f");
+        __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_add).call(this, ids, false);
+        const additions = {};
+        const removals = {};
+        forEachSelectableType({
+            ids: __classPrivateFieldGet(this, _SelectionSet_selection, "f"),
+            elements: (elementIds) => {
+                removeIds({
+                    target: previousSelection.elements,
+                    ids: elementIds,
+                    onNotFound: (id) => (additions.elements ??= new Set()).add(id),
+                });
+                if (previousSelection.elements.size > 0) {
+                    removals.elements = previousSelection.elements;
+                }
+            },
+            models: (modelIds) => {
+                removeIds({
+                    target: previousSelection.models,
+                    ids: modelIds,
+                    onNotFound: (id) => (additions.models ??= new Set()).add(id),
+                });
+                if (previousSelection.models.size > 0) {
+                    removals.models = previousSelection.models;
+                }
+            },
+            subcategories: (subcategoryIds) => {
+                removeIds({
+                    target: previousSelection.subcategories,
+                    ids: subcategoryIds,
+                    onNotFound: (id) => (additions.subcategories ??= new Set()).add(id),
+                });
+                if (previousSelection.subcategories.size > 0) {
+                    removals.subcategories = previousSelection.subcategories;
+                }
+            },
+        });
+        __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, {
+            type: SelectionSetEventType.Replace,
+            set: this,
+            additions,
+            added: additions.elements ?? [],
+            removals,
+            removed: removals.elements ?? [],
+        });
+        return true;
+    }
+}
+_SelectionSet_selection = new WeakMap(), _SelectionSet_instances = new WeakSet(), _SelectionSet_sendChangedEvent = function _SelectionSet_sendChangedEvent(ev) {
+    IModelApp.viewManager.onSelectionSetChanged(this.iModel);
+    this.onChanged.raiseEvent(ev);
+}, _SelectionSet_add = function _SelectionSet_add(adds, sendEvent = true) {
+    const oldSize = this.size;
+    const additions = {};
+    forEachSelectableType({
+        ids: adds,
+        elements: (elementIds) => addIds({
+            target: __classPrivateFieldGet(this, _SelectionSet_selection, "f").elements,
+            ids: elementIds,
+            onAdd: (id) => (additions.elements ??= []).push(id),
+        }),
+        models: (modelIds) => addIds({
+            target: __classPrivateFieldGet(this, _SelectionSet_selection, "f").models,
+            ids: modelIds,
+            onAdd: (id) => (additions.models ??= []).push(id),
+        }),
+        subcategories: (subcategoryIds) => addIds({
+            target: __classPrivateFieldGet(this, _SelectionSet_selection, "f").subcategories,
+            ids: subcategoryIds,
+            onAdd: (id) => (additions.subcategories ??= []).push(id),
+        }),
+    });
+    const changed = oldSize !== this.size;
+    if (!changed) {
+        return undefined;
+    }
+    if (sendEvent) {
+        __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, {
+            type: SelectionSetEventType.Add,
+            set: this,
+            additions,
+            added: additions.elements ?? [],
+        });
+    }
+    return additions;
+}, _SelectionSet_remove = function _SelectionSet_remove(removes, sendEvent = true) {
+    const oldSize = this.size;
+    const removals = {};
+    forEachSelectableType({
+        ids: removes,
+        elements: (elementIds) => removeIds({
+            target: __classPrivateFieldGet(this, _SelectionSet_selection, "f").elements,
+            ids: elementIds,
+            onRemove: (id) => (removals.elements ??= []).push(id),
+        }),
+        models: (modelIds) => removeIds({
+            target: __classPrivateFieldGet(this, _SelectionSet_selection, "f").models,
+            ids: modelIds,
+            onRemove: (id) => (removals.models ??= []).push(id),
+        }),
+        subcategories: (subcategoryIds) => removeIds({
+            target: __classPrivateFieldGet(this, _SelectionSet_selection, "f").subcategories,
+            ids: subcategoryIds,
+            onRemove: (id) => (removals.subcategories ??= []).push(id),
+        }),
+    });
+    const changed = oldSize !== this.size;
+    if (!changed) {
+        return undefined;
+    }
+    if (sendEvent) {
+        __classPrivateFieldGet(this, _SelectionSet_instances, "m", _SelectionSet_sendChangedEvent).call(this, {
+            type: SelectionSetEventType.Remove,
+            set: this,
+            removals,
+            removed: removals.elements ?? [],
+        });
     }
+    return removals;
+};
+function forEachSelectableType({ ids, elements, models, subcategories, }) {
+    if (typeof ids === "string" || Array.isArray(ids) || ids instanceof Set) {
+        elements(ids);
+        return { elements: ids };
+    }
+    elements(ids.elements ?? []);
+    models(ids.models ?? []);
+    subcategories(ids.subcategories ?? []);
+    return ids;
 }
 function areEqual(lhs, rhs) {
+    let result = true;
+    forEachSelectableType({
+        ids: rhs,
+        elements: (elementIds) => {
+            if (result && !areIdsEqual(lhs.elements, elementIds)) {
+                result = false;
+            }
+        },
+        models: (modelIds) => {
+            if (result && !areIdsEqual(lhs.models, modelIds)) {
+                result = false;
+            }
+        },
+        subcategories: (subcategoryIds) => {
+            if (result && !areIdsEqual(lhs.subcategories, subcategoryIds)) {
+                result = false;
+            }
+        },
+    });
+    return result;
+}
+function areIdsEqual(lhs, rhs) {
     // Size is unreliable if input can contain duplicates...
-    if (Array.isArray(rhs))
+    if (Array.isArray(rhs)) {
         rhs = Id64.toIdSet(rhs);
-    if (lhs.size !== Id64.sizeOf(rhs))
+    }
+    if (lhs.size !== Id64.sizeOf(rhs)) {
         return false;
-    for (const id of Id64.iterable(rhs))
-        if (!lhs.has(id))
+    }
+    for (const id of Id64.iterable(rhs)) {
+        if (!lhs.has(id)) {
             return false;
+        }
+    }
     return true;
 }
+function addIds({ target, ids, onAdd }) {
+    let size = target.size;
+    for (const id of Id64.iterable(ids)) {
+        target.add(id);
+        const newSize = target.size;
+        if (newSize !== size) {
+            onAdd?.(id);
+        }
+        size = newSize;
+    }
+}
+function removeIds({ target, ids, onRemove, onNotFound, }) {
+    let size = target.size;
+    for (const id of Id64.iterable(ids)) {
+        target.delete(id);
+        const newSize = target.size;
+        if (newSize !== size) {
+            onRemove?.(id);
+        }
+        else {
+            onNotFound?.(id);
+        }
+        size = newSize;
+    }
+}
 //# sourceMappingURL=SelectionSet.js.map