@itwin/core-frontend 5.0.0-dev.4 → 5.0.0-dev.41

package/lib/cjs/SelectionSet.js

@@ -1,10 +1,10 @@
 "use strict";
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectionSet = exports.HiliteSet = exports.SelectionSetEventType = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
 /** @packageDocumentation
  * @module SelectionSet
  */
@@ -16,85 +16,38 @@ const IModelApp_1 = require("./IModelApp");
  */
 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 || (exports.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 core_bentley_1.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_1.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.
@@ -116,8 +69,9 @@ class HilitedElementIds extends HilitedIds {
  * @extensions
  */
 class HiliteSet {
-    /** The set of hilited elements. */
-    get elements() { return this._elements; }
+    #mode;
+    #selectionChangesListener;
+    #changing;
     /** 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.
@@ -125,189 +79,491 @@ class HiliteSet {
      * [[elements]] is always hilited regardless of its model or subcategories.
      */
     get modelSubCategoryMode() {
-        return this._mode;
+        return this.#mode;
     }
     set modelSubCategoryMode(mode) {
-        if (mode === this._mode)
+        if (mode === this.#mode) {
             return;
+        }
         this.onModelSubCategoryModeChanged.raiseEvent(mode);
-        this._mode = mode;
+        this.#mode = mode;
     }
     /** 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) {
         this.iModel = iModel;
-        this._mode = "union";
+        this.#mode = "union";
+        this.#changing = false;
         /** Event raised just before changing the value of [[modelSubCategoryMode]]. */
         this.onModelSubCategoryModeChanged = new core_bentley_1.BeEvent();
-        this._elements = new HilitedElementIds(iModel, syncWithSelectionSet);
-        this.subcategories = new HilitedIds(iModel);
-        this.models = new HilitedIds(iModel);
+        this.elements = new HilitedIds((func) => this.#change(func));
+        this.subcategories = new HilitedIds((func) => this.#change(func));
+        this.models = new HilitedIds((func) => this.#change(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 !!this.#selectionChangesListener;
+    }
+    set wantSyncWithSelectionSet(want) {
+        if (want === this.wantSyncWithSelectionSet) {
+            return;
+        }
+        if (want) {
+            const set = this.iModel.selectionSet;
+            this.#selectionChangesListener = set.onChanged.addListener((ev) => this.#processSelectionSetEvent(ev));
+            this.add(set.active);
+        }
+        else {
+            this.#selectionChangesListener();
+            this.#selectionChangesListener = undefined;
+        }
+    }
+    #onChanged() {
+        if (!this.#changing) {
+            IModelApp_1.IModelApp.viewManager.onSelectionSetChanged(this.iModel);
+        }
+    }
+    #change(func) {
+        const changing = this.#changing;
+        this.#changing = true;
+        try {
+            func();
+        }
+        finally {
+            this.#changing = changing;
+        }
+        this.#onChanged();
+    }
+    #processSelectionSetEvent(ev) {
+        switch (ev.type) {
+            case SelectionSetEventType.Add:
+                return this.add(ev.additions);
+            case SelectionSetEventType.Replace:
+                return this.#change(() => {
+                    this.add(ev.additions);
+                    this.remove(ev.removals);
+                });
+            case SelectionSetEventType.Remove:
+            case SelectionSetEventType.Clear:
+                return this.remove(ev.removals);
+        }
+    }
+    /** Adds a collection of geometric element, model and subcategory ids to this hilite set. */
+    add(additions) {
+        this.#change(() => {
+            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) {
+        this.#change(() => {
+            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) {
+        this.#change(() => {
+            this.clear();
+            this.add(ids);
+        });
+    }
     /** Remove all elements from the hilited set. */
     clear() {
-        this.elements.clear();
-        this.subcategories.clear();
-        this.models.clear();
+        this.#change(() => {
+            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 core_bentley_1.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_1.IModelApp.viewManager.onSelectionSetChanged(this.iModel);
     }
 }
 exports.HiliteSet = HiliteSet;
-/** A set of *currently selected* elements for an IModelConnection.
- * Selected elements are displayed with a customizable hilite effect within a [[Viewport]].
+/** 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
  */
 class SelectionSet {
+    #selection;
     /** 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 this.#selection.elements;
+    }
+    /** The IDs of the selected models.
+     * @note Do not modify this set directly. Instead, use methods like [[SelectionSet.add]].
+     */
+    get models() {
+        return this.#selection.models;
+    }
+    /** The IDs of the selected subcategories.
+     * @note Do not modify this set directly. Instead, use methods like [[SelectionSet.add]].
+     */
+    get subcategories() {
+        return this.#selection.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 { ...this.#selection };
+    }
     constructor(iModel) {
         this.iModel = iModel;
-        this._elements = new Set();
-        /** Called whenever elements are added or removed from this SelectionSet */
+        /** Called whenever ids are added or removed from this `SelectionSet` */
         this.onChanged = new core_bentley_1.BeEvent();
+        this.#selection = {
+            elements: new Set(),
+            models: new Set(),
+            subcategories: new Set(),
+        };
     }
-    sendChangedEvent(ev) {
+    #sendChangedEvent(ev) {
         IModelApp_1.IModelApp.viewManager.onSelectionSetChanged(this.iModel);
         this.onChanged.raiseEvent(ev);
     }
     /** 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 = this.#selection;
+        this.#selection = {
+            elements: new Set(),
+            models: new Set(),
+            subcategories: new Set(),
+        };
+        this.#sendChangedEvent({ 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 core_bentley_1.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 !!this.#add(adds);
+    }
+    #add(adds, sendEvent = true) {
+        const oldSize = this.size;
+        const additions = {};
+        forEachSelectableType({
+            ids: adds,
+            elements: (elementIds) => addIds({
+                target: this.#selection.elements,
+                ids: elementIds,
+                onAdd: (id) => (additions.elements ??= []).push(id),
+            }),
+            models: (modelIds) => addIds({
+                target: this.#selection.models,
+                ids: modelIds,
+                onAdd: (id) => (additions.models ??= []).push(id),
+            }),
+            subcategories: (subcategoryIds) => addIds({
+                target: this.#selection.subcategories,
+                ids: subcategoryIds,
+                onAdd: (id) => (additions.subcategories ??= []).push(id),
+            }),
+        });
+        const changed = oldSize !== this.size;
+        if (!changed) {
+            return undefined;
+        }
+        if (sendEvent) {
+            this.#sendChangedEvent({
+                type: SelectionSetEventType.Add,
+                set: this,
+                additions,
+                added: additions.elements ?? [],
+            });
+        }
+        return additions;
     }
     /**
      * 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 core_bentley_1.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 !!this.#remove(removes);
+    }
+    #remove(removes, sendEvent = true) {
+        const oldSize = this.size;
+        const removals = {};
+        forEachSelectableType({
+            ids: removes,
+            elements: (elementIds) => removeIds({
+                target: this.#selection.elements,
+                ids: elementIds,
+                onRemove: (id) => (removals.elements ??= []).push(id),
+            }),
+            models: (modelIds) => removeIds({
+                target: this.#selection.models,
+                ids: modelIds,
+                onRemove: (id) => (removals.models ??= []).push(id),
+            }),
+            subcategories: (subcategoryIds) => removeIds({
+                target: this.#selection.subcategories,
+                ids: subcategoryIds,
+                onRemove: (id) => (removals.subcategories ??= []).push(id),
+            }),
+        });
+        const changed = oldSize !== this.size;
+        if (!changed) {
+            return undefined;
+        }
+        if (sendEvent) {
+            this.#sendChangedEvent({
+                type: SelectionSetEventType.Remove,
+                set: this,
+                removals,
+                removed: removals.elements ?? [],
+            });
+        }
+        return removals;
     }
     /**
      * 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 core_bentley_1.Id64.iterable(elem)) {
-            if (this.elements.has(id))
-                elementsToRemove.add(id);
-            else
-                elementsToAdd.add(id);
+        const additions = this.#add(adds, false);
+        const removals = this.#remove(removes, false);
+        const addedElements = additions?.elements ?? [];
+        const removedElements = removals?.elements ?? [];
+        if (additions && removals) {
+            this.#sendChangedEvent({
+                type: SelectionSetEventType.Replace,
+                set: this,
+                additions,
+                added: addedElements,
+                removals,
+                removed: removedElements,
+            });
+        }
+        else if (additions) {
+            this.#sendChangedEvent({
+                type: SelectionSetEventType.Add,
+                set: this,
+                additions,
+                added: addedElements,
+            });
         }
-        return this.addAndRemove(elementsToAdd, elementsToRemove);
+        else if (removals) {
+            this.#sendChangedEvent({
+                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 core_bentley_1.Id64.iterable(elementIds)) {
+                    ((this.elements.has(id) ? removes : adds).elements ??= new Set()).add(id);
+                }
+            },
+            models: (modelIds) => {
+                for (const id of core_bentley_1.Id64.iterable(modelIds)) {
+                    ((this.models.has(id) ? removes : adds).models ??= new Set()).add(id);
+                }
+            },
+            subcategories: (subcategoryIds) => {
+                for (const id of core_bentley_1.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 core_bentley_1.Id64.iterable(elem)) {
-                if (removed.has(id))
-                    removed.delete(id);
-            }
+    replace(ids) {
+        if (areEqual(this.#selection, ids)) {
+            return false;
         }
-        this.sendChangedEvent({ type: SelectionSetEventType.Replace, set: this, added: elem, removed });
+        const previousSelection = this.#selection;
+        this.#selection = {
+            elements: new Set(),
+            models: new Set(),
+            subcategories: new Set(),
+        };
+        this.#add(ids, false);
+        const additions = {};
+        const removals = {};
+        forEachSelectableType({
+            ids: this.#selection,
+            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;
+                }
+            },
+        });
+        this.#sendChangedEvent({
+            type: SelectionSetEventType.Replace,
+            set: this,
+            additions,
+            added: additions.elements ?? [],
+            removals,
+            removed: removals.elements ?? [],
+        });
+        return true;
     }
 }
 exports.SelectionSet = SelectionSet;
+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 = core_bentley_1.Id64.toIdSet(rhs);
-    if (lhs.size !== core_bentley_1.Id64.sizeOf(rhs))
+    }
+    if (lhs.size !== core_bentley_1.Id64.sizeOf(rhs)) {
         return false;
-    for (const id of core_bentley_1.Id64.iterable(rhs))
-        if (!lhs.has(id))
+    }
+    for (const id of core_bentley_1.Id64.iterable(rhs)) {
+        if (!lhs.has(id)) {
             return false;
+        }
+    }
     return true;
 }
+function addIds({ target, ids, onAdd }) {
+    let size = target.size;
+    for (const id of core_bentley_1.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 core_bentley_1.Id64.iterable(ids)) {
+        target.delete(id);
+        const newSize = target.size;
+        if (newSize !== size) {
+            onRemove?.(id);
+        }
+        else {
+            onNotFound?.(id);
+        }
+        size = newSize;
+    }
+}
 //# sourceMappingURL=SelectionSet.js.map