@itwin/presentation-frontend 4.0.0-dev.21 → 4.0.0-dev.23

package/lib/esm/presentation-frontend/selection/SelectionManager.js

@@ -1,410 +1,410 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module UnifiedSelection
- */
-import { Id64, using } from "@itwin/core-bentley";
-import { IModelConnection, SelectionSetEventType } from "@itwin/core-frontend";
-import { AsyncTasksTracker, KeySet } from "@itwin/presentation-common";
-import { HiliteSetProvider } from "./HiliteSetProvider";
-import { SelectionChangeEvent, SelectionChangeType } from "./SelectionChangeEvent";
-import { createSelectionScopeProps } from "./SelectionScopesManager";
-/**
- * The selection manager which stores the overall selection.
- * @public
- */
-export class SelectionManager {
-    /**
-     * Creates an instance of SelectionManager.
-     */
-    constructor(props) {
-        this._selectionContainerMap = new Map();
-        this._imodelToolSelectionSyncHandlers = new Map();
-        this._hiliteSetProviders = new Map();
-        this.selectionChange = new SelectionChangeEvent();
-        this.scopes = props.scopes;
-        IModelConnection.onClose.addListener((imodel) => {
-            this.onConnectionClose(imodel);
-        });
-    }
-    onConnectionClose(imodel) {
-        this.clearSelection("Connection Close Event", imodel);
-        this._selectionContainerMap.delete(imodel);
-        this._hiliteSetProviders.delete(imodel);
-    }
-    getContainer(imodel) {
-        let selectionContainer = this._selectionContainerMap.get(imodel);
-        if (!selectionContainer) {
-            selectionContainer = new SelectionContainer();
-            this._selectionContainerMap.set(imodel, selectionContainer);
-        }
-        return selectionContainer;
-    }
-    /** @internal */
-    // istanbul ignore next
-    getToolSelectionSyncHandler(imodel) { var _a; return (_a = this._imodelToolSelectionSyncHandlers.get(imodel)) === null || _a === void 0 ? void 0 : _a.handler; }
-    /**
-     * Request the manager to sync with imodel's tool selection (see `IModelConnection.selectionSet`).
-     */
-    setSyncWithIModelToolSelection(imodel, sync = true) {
-        const registration = this._imodelToolSelectionSyncHandlers.get(imodel);
-        if (sync) {
-            if (!registration || registration.requestorsCount === 0) {
-                this._imodelToolSelectionSyncHandlers.set(imodel, { requestorsCount: 1, handler: new ToolSelectionSyncHandler(imodel, this) });
-            }
-            else {
-                this._imodelToolSelectionSyncHandlers.set(imodel, { ...registration, requestorsCount: registration.requestorsCount + 1 });
-            }
-        }
-        else {
-            if (registration && registration.requestorsCount > 0) {
-                const requestorsCount = registration.requestorsCount - 1;
-                if (requestorsCount > 0) {
-                    this._imodelToolSelectionSyncHandlers.set(imodel, { ...registration, requestorsCount });
-                }
-                else {
-                    this._imodelToolSelectionSyncHandlers.delete(imodel);
-                    registration.handler.dispose();
-                }
-            }
-        }
-    }
-    /**
-     * Temporarily suspends tool selection synchronization until the returned `IDisposable`
-     * is disposed.
-     */
-    suspendIModelToolSelectionSync(imodel) {
-        const registration = this._imodelToolSelectionSyncHandlers.get(imodel);
-        if (!registration)
-            return { dispose: () => { } };
-        const wasSuspended = registration.handler.isSuspended;
-        registration.handler.isSuspended = true;
-        return { dispose: () => (registration.handler.isSuspended = wasSuspended) };
-    }
-    /** Get the selection levels currently stored in this manager for the specified imodel */
-    getSelectionLevels(imodel) {
-        return this.getContainer(imodel).getSelectionLevels();
-    }
-    /** Get the selection currently stored in this manager */
-    getSelection(imodel, level = 0) {
-        return this.getContainer(imodel).getSelection(level);
-    }
-    handleEvent(evt) {
-        const container = this.getContainer(evt.imodel);
-        const selectedItemsSet = container.getSelection(evt.level);
-        const guidBefore = selectedItemsSet.guid;
-        switch (evt.changeType) {
-            case SelectionChangeType.Add:
-                selectedItemsSet.add(evt.keys);
-                break;
-            case SelectionChangeType.Remove:
-                selectedItemsSet.delete(evt.keys);
-                break;
-            case SelectionChangeType.Replace:
-                if (selectedItemsSet.size !== evt.keys.size || !selectedItemsSet.hasAll(evt.keys)) {
-                    // note: the above check is only needed to avoid changing
-                    // guid of the keyset if we're replacing keyset with the same keys
-                    selectedItemsSet.clear().add(evt.keys);
-                }
-                break;
-            case SelectionChangeType.Clear:
-                selectedItemsSet.clear();
-                break;
-        }
-        if (selectedItemsSet.guid === guidBefore)
-            return;
-        container.clear(evt.level + 1);
-        this.selectionChange.raiseEvent(evt, this);
-    }
-    /**
-     * Add keys to the selection
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param keys Keys to add
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    addToSelection(source, imodel, keys, level = 0, rulesetId) {
-        const evt = {
-            source,
-            level,
-            imodel,
-            changeType: SelectionChangeType.Add,
-            keys: new KeySet(keys),
-            timestamp: new Date(),
-            rulesetId,
-        };
-        this.handleEvent(evt);
-    }
-    /**
-     * Remove keys from current selection
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param keys Keys to remove
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    removeFromSelection(source, imodel, keys, level = 0, rulesetId) {
-        const evt = {
-            source,
-            level,
-            imodel,
-            changeType: SelectionChangeType.Remove,
-            keys: new KeySet(keys),
-            timestamp: new Date(),
-            rulesetId,
-        };
-        this.handleEvent(evt);
-    }
-    /**
-     * Replace current selection
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param keys Keys to add
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    replaceSelection(source, imodel, keys, level = 0, rulesetId) {
-        const evt = {
-            source,
-            level,
-            imodel,
-            changeType: SelectionChangeType.Replace,
-            keys: new KeySet(keys),
-            timestamp: new Date(),
-            rulesetId,
-        };
-        this.handleEvent(evt);
-    }
-    /**
-     * Clear current selection
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    clearSelection(source, imodel, level = 0, rulesetId) {
-        const evt = {
-            source,
-            level,
-            imodel,
-            changeType: SelectionChangeType.Clear,
-            keys: new KeySet(),
-            timestamp: new Date(),
-            rulesetId,
-        };
-        this.handleEvent(evt);
-    }
-    /**
-     * Add keys to selection after applying [selection scope]($docs/presentation/unified-selection/index#selection-scopes) on them.
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param ids Element IDs to add
-     * @param scope Selection scope to apply
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    async addToSelectionWithScope(source, imodel, ids, scope, level = 0, rulesetId) {
-        const scopedKeys = await this.scopes.computeSelection(imodel, ids, scope);
-        this.addToSelection(source, imodel, scopedKeys, level, rulesetId);
-    }
-    /**
-     * Remove keys from current selection after applying [selection scope]($docs/presentation/unified-selection/index#selection-scopes) on them.
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param ids Element IDs to remove
-     * @param scope Selection scope to apply
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    async removeFromSelectionWithScope(source, imodel, ids, scope, level = 0, rulesetId) {
-        const scopedKeys = await this.scopes.computeSelection(imodel, ids, scope);
-        this.removeFromSelection(source, imodel, scopedKeys, level, rulesetId);
-    }
-    /**
-     * Replace current selection with keys after applying [selection scope]($docs/presentation/unified-selection/index#selection-scopes) on them.
-     * @param source Name of the selection source
-     * @param imodel iModel associated with the selection
-     * @param ids Element IDs to replace with
-     * @param scope Selection scope to apply
-     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
-     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
-     */
-    async replaceSelectionWithScope(source, imodel, ids, scope, level = 0, rulesetId) {
-        const scopedKeys = await this.scopes.computeSelection(imodel, ids, scope);
-        this.replaceSelection(source, imodel, scopedKeys, level, rulesetId);
-    }
-    /**
-     * Get the current hilite set for the specified imodel
-     * @public
-     */
-    async getHiliteSet(imodel) {
-        let provider = this._hiliteSetProviders.get(imodel);
-        if (!provider) {
-            provider = HiliteSetProvider.create({ imodel });
-            this._hiliteSetProviders.set(imodel, provider);
-        }
-        return provider.getHiliteSet(this.getSelection(imodel));
-    }
-}
-/** @internal */
-class SelectionContainer {
-    constructor() {
-        this._selectedItemsSetMap = new Map();
-    }
-    getSelection(level) {
-        let selectedItemsSet = this._selectedItemsSetMap.get(level);
-        if (!selectedItemsSet) {
-            selectedItemsSet = new KeySet();
-            this._selectedItemsSetMap.set(level, selectedItemsSet);
-        }
-        return selectedItemsSet;
-    }
-    getSelectionLevels() {
-        const levels = new Array();
-        for (const entry of this._selectedItemsSetMap.entries()) {
-            if (!entry[1].isEmpty)
-                levels.push(entry[0]);
-        }
-        return levels.sort();
-    }
-    clear(level) {
-        const keys = this._selectedItemsSetMap.keys();
-        for (const key of keys) {
-            if (key >= level) {
-                const selectedItemsSet = this._selectedItemsSetMap.get(key);
-                selectedItemsSet.clear();
-            }
-        }
-    }
-}
-/** @internal */
-export const TRANSIENT_ELEMENT_CLASSNAME = "/TRANSIENT";
-/** @internal */
-export class ToolSelectionSyncHandler {
-    constructor(imodel, logicalSelection) {
-        this._selectionSourceName = "Tool";
-        this._asyncsTracker = new AsyncTasksTracker();
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        this.onToolSelectionChanged = async (ev) => {
-            // ignore selection change event if the handler is suspended
-            if (this.isSuspended)
-                return;
-            // this component only cares about its own imodel
-            const imodel = ev.set.iModel;
-            if (imodel !== this._imodel)
-                return;
-            // determine the level of selection changes
-            // wip: may want to allow selecting at different levels?
-            const selectionLevel = 0;
-            let ids;
-            switch (ev.type) {
-                case SelectionSetEventType.Add:
-                    ids = ev.added;
-                    break;
-                case SelectionSetEventType.Replace:
-                    ids = ev.set.elements;
-                    break;
-                default:
-                    ids = ev.removed;
-                    break;
-            }
-            // we're always using scoped selection changer even if the scope is set to "element" - that
-            // makes sure we're adding to selection keys with concrete classes and not "BisCore:Element", which
-            // we can't because otherwise our keys compare fails (presentation components load data with
-            // concrete classes)
-            const changer = new ScopedSelectionChanger(this._selectionSourceName, this._imodel, this._logicalSelection, createSelectionScopeProps(this._logicalSelection.scopes.activeScope));
-            // we know what to do immediately on `clear` events
-            if (SelectionSetEventType.Clear === ev.type) {
-                await changer.clear(selectionLevel);
-                return;
-            }
-            const parsedIds = parseIds(ids);
-            await using(this._asyncsTracker.trackAsyncTask(), async (_r) => {
-                switch (ev.type) {
-                    case SelectionSetEventType.Add:
-                        await changer.add(parsedIds.transient, parsedIds.persistent, selectionLevel);
-                        break;
-                    case SelectionSetEventType.Replace:
-                        await changer.replace(parsedIds.transient, parsedIds.persistent, selectionLevel);
-                        break;
-                    case SelectionSetEventType.Remove:
-                        await changer.remove(parsedIds.transient, parsedIds.persistent, selectionLevel);
-                        break;
-                }
-            });
-        };
-        this._imodel = imodel;
-        this._logicalSelection = logicalSelection;
-        this._imodelToolSelectionListenerDisposeFunc = imodel.selectionSet.onChanged.addListener(this.onToolSelectionChanged);
-    }
-    dispose() {
-        this._imodelToolSelectionListenerDisposeFunc();
-    }
-    /** note: used only it tests */
-    get pendingAsyncs() { return this._asyncsTracker.pendingAsyncs; }
-}
-const parseIds = (ids) => {
-    let allPersistent = true;
-    let allTransient = true;
-    for (const id of Id64.iterable(ids)) {
-        if (Id64.isTransient(id))
-            allPersistent = false;
-        else
-            allTransient = false;
-        if (!allPersistent && !allTransient)
-            break;
-    }
-    // avoid making a copy if ids are only persistent or only transient
-    if (allPersistent) {
-        return { persistent: ids, transient: [] };
-    }
-    else if (allTransient) {
-        return { persistent: [], transient: ids };
-    }
-    // if `ids` contain mixed ids, we have to copy.. use Array instead of
-    // a Set for performance
-    const persistentElementIds = [];
-    const transientElementIds = [];
-    for (const id of Id64.iterable(ids)) {
-        if (Id64.isTransient(id))
-            transientElementIds.push(id);
-        else
-            persistentElementIds.push(id);
-    }
-    return { persistent: persistentElementIds, transient: transientElementIds };
-};
-function addTransientKeys(transientIds, keys) {
-    for (const id of Id64.iterable(transientIds))
-        keys.add({ className: TRANSIENT_ELEMENT_CLASSNAME, id });
-}
-/** @internal */
-class ScopedSelectionChanger {
-    constructor(name, imodel, manager, scope) {
-        this.name = name;
-        this.imodel = imodel;
-        this.manager = manager;
-        this.scope = scope;
-    }
-    async clear(level) {
-        this.manager.clearSelection(this.name, this.imodel, level);
-    }
-    async add(transientIds, persistentIds, level) {
-        const keys = await this.manager.scopes.computeSelection(this.imodel, persistentIds, this.scope);
-        addTransientKeys(transientIds, keys);
-        this.manager.addToSelection(this.name, this.imodel, keys, level);
-    }
-    async remove(transientIds, persistentIds, level) {
-        const keys = await this.manager.scopes.computeSelection(this.imodel, persistentIds, this.scope);
-        addTransientKeys(transientIds, keys);
-        this.manager.removeFromSelection(this.name, this.imodel, keys, level);
-    }
-    async replace(transientIds, persistentIds, level) {
-        const keys = await this.manager.scopes.computeSelection(this.imodel, persistentIds, this.scope);
-        addTransientKeys(transientIds, keys);
-        this.manager.replaceSelection(this.name, this.imodel, keys, level);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module UnifiedSelection
+ */
+import { Id64, using } from "@itwin/core-bentley";
+import { IModelConnection, SelectionSetEventType } from "@itwin/core-frontend";
+import { AsyncTasksTracker, KeySet } from "@itwin/presentation-common";
+import { HiliteSetProvider } from "./HiliteSetProvider";
+import { SelectionChangeEvent, SelectionChangeType } from "./SelectionChangeEvent";
+import { createSelectionScopeProps } from "./SelectionScopesManager";
+/**
+ * The selection manager which stores the overall selection.
+ * @public
+ */
+export class SelectionManager {
+    /**
+     * Creates an instance of SelectionManager.
+     */
+    constructor(props) {
+        this._selectionContainerMap = new Map();
+        this._imodelToolSelectionSyncHandlers = new Map();
+        this._hiliteSetProviders = new Map();
+        this.selectionChange = new SelectionChangeEvent();
+        this.scopes = props.scopes;
+        IModelConnection.onClose.addListener((imodel) => {
+            this.onConnectionClose(imodel);
+        });
+    }
+    onConnectionClose(imodel) {
+        this.clearSelection("Connection Close Event", imodel);
+        this._selectionContainerMap.delete(imodel);
+        this._hiliteSetProviders.delete(imodel);
+    }
+    getContainer(imodel) {
+        let selectionContainer = this._selectionContainerMap.get(imodel);
+        if (!selectionContainer) {
+            selectionContainer = new SelectionContainer();
+            this._selectionContainerMap.set(imodel, selectionContainer);
+        }
+        return selectionContainer;
+    }
+    /** @internal */
+    // istanbul ignore next
+    getToolSelectionSyncHandler(imodel) { var _a; return (_a = this._imodelToolSelectionSyncHandlers.get(imodel)) === null || _a === void 0 ? void 0 : _a.handler; }
+    /**
+     * Request the manager to sync with imodel's tool selection (see `IModelConnection.selectionSet`).
+     */
+    setSyncWithIModelToolSelection(imodel, sync = true) {
+        const registration = this._imodelToolSelectionSyncHandlers.get(imodel);
+        if (sync) {
+            if (!registration || registration.requestorsCount === 0) {
+                this._imodelToolSelectionSyncHandlers.set(imodel, { requestorsCount: 1, handler: new ToolSelectionSyncHandler(imodel, this) });
+            }
+            else {
+                this._imodelToolSelectionSyncHandlers.set(imodel, { ...registration, requestorsCount: registration.requestorsCount + 1 });
+            }
+        }
+        else {
+            if (registration && registration.requestorsCount > 0) {
+                const requestorsCount = registration.requestorsCount - 1;
+                if (requestorsCount > 0) {
+                    this._imodelToolSelectionSyncHandlers.set(imodel, { ...registration, requestorsCount });
+                }
+                else {
+                    this._imodelToolSelectionSyncHandlers.delete(imodel);
+                    registration.handler.dispose();
+                }
+            }
+        }
+    }
+    /**
+     * Temporarily suspends tool selection synchronization until the returned `IDisposable`
+     * is disposed.
+     */
+    suspendIModelToolSelectionSync(imodel) {
+        const registration = this._imodelToolSelectionSyncHandlers.get(imodel);
+        if (!registration)
+            return { dispose: () => { } };
+        const wasSuspended = registration.handler.isSuspended;
+        registration.handler.isSuspended = true;
+        return { dispose: () => (registration.handler.isSuspended = wasSuspended) };
+    }
+    /** Get the selection levels currently stored in this manager for the specified imodel */
+    getSelectionLevels(imodel) {
+        return this.getContainer(imodel).getSelectionLevels();
+    }
+    /** Get the selection currently stored in this manager */
+    getSelection(imodel, level = 0) {
+        return this.getContainer(imodel).getSelection(level);
+    }
+    handleEvent(evt) {
+        const container = this.getContainer(evt.imodel);
+        const selectedItemsSet = container.getSelection(evt.level);
+        const guidBefore = selectedItemsSet.guid;
+        switch (evt.changeType) {
+            case SelectionChangeType.Add:
+                selectedItemsSet.add(evt.keys);
+                break;
+            case SelectionChangeType.Remove:
+                selectedItemsSet.delete(evt.keys);
+                break;
+            case SelectionChangeType.Replace:
+                if (selectedItemsSet.size !== evt.keys.size || !selectedItemsSet.hasAll(evt.keys)) {
+                    // note: the above check is only needed to avoid changing
+                    // guid of the keyset if we're replacing keyset with the same keys
+                    selectedItemsSet.clear().add(evt.keys);
+                }
+                break;
+            case SelectionChangeType.Clear:
+                selectedItemsSet.clear();
+                break;
+        }
+        if (selectedItemsSet.guid === guidBefore)
+            return;
+        container.clear(evt.level + 1);
+        this.selectionChange.raiseEvent(evt, this);
+    }
+    /**
+     * Add keys to the selection
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param keys Keys to add
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    addToSelection(source, imodel, keys, level = 0, rulesetId) {
+        const evt = {
+            source,
+            level,
+            imodel,
+            changeType: SelectionChangeType.Add,
+            keys: new KeySet(keys),
+            timestamp: new Date(),
+            rulesetId,
+        };
+        this.handleEvent(evt);
+    }
+    /**
+     * Remove keys from current selection
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param keys Keys to remove
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    removeFromSelection(source, imodel, keys, level = 0, rulesetId) {
+        const evt = {
+            source,
+            level,
+            imodel,
+            changeType: SelectionChangeType.Remove,
+            keys: new KeySet(keys),
+            timestamp: new Date(),
+            rulesetId,
+        };
+        this.handleEvent(evt);
+    }
+    /**
+     * Replace current selection
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param keys Keys to add
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    replaceSelection(source, imodel, keys, level = 0, rulesetId) {
+        const evt = {
+            source,
+            level,
+            imodel,
+            changeType: SelectionChangeType.Replace,
+            keys: new KeySet(keys),
+            timestamp: new Date(),
+            rulesetId,
+        };
+        this.handleEvent(evt);
+    }
+    /**
+     * Clear current selection
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    clearSelection(source, imodel, level = 0, rulesetId) {
+        const evt = {
+            source,
+            level,
+            imodel,
+            changeType: SelectionChangeType.Clear,
+            keys: new KeySet(),
+            timestamp: new Date(),
+            rulesetId,
+        };
+        this.handleEvent(evt);
+    }
+    /**
+     * Add keys to selection after applying [selection scope]($docs/presentation/unified-selection/index#selection-scopes) on them.
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param ids Element IDs to add
+     * @param scope Selection scope to apply
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    async addToSelectionWithScope(source, imodel, ids, scope, level = 0, rulesetId) {
+        const scopedKeys = await this.scopes.computeSelection(imodel, ids, scope);
+        this.addToSelection(source, imodel, scopedKeys, level, rulesetId);
+    }
+    /**
+     * Remove keys from current selection after applying [selection scope]($docs/presentation/unified-selection/index#selection-scopes) on them.
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param ids Element IDs to remove
+     * @param scope Selection scope to apply
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    async removeFromSelectionWithScope(source, imodel, ids, scope, level = 0, rulesetId) {
+        const scopedKeys = await this.scopes.computeSelection(imodel, ids, scope);
+        this.removeFromSelection(source, imodel, scopedKeys, level, rulesetId);
+    }
+    /**
+     * Replace current selection with keys after applying [selection scope]($docs/presentation/unified-selection/index#selection-scopes) on them.
+     * @param source Name of the selection source
+     * @param imodel iModel associated with the selection
+     * @param ids Element IDs to replace with
+     * @param scope Selection scope to apply
+     * @param level Selection level (see [selection levels documentation section]($docs/presentation/unified-selection/index#selection-levels))
+     * @param rulesetId ID of the ruleset in case the selection was changed from a rules-driven control
+     */
+    async replaceSelectionWithScope(source, imodel, ids, scope, level = 0, rulesetId) {
+        const scopedKeys = await this.scopes.computeSelection(imodel, ids, scope);
+        this.replaceSelection(source, imodel, scopedKeys, level, rulesetId);
+    }
+    /**
+     * Get the current hilite set for the specified imodel
+     * @public
+     */
+    async getHiliteSet(imodel) {
+        let provider = this._hiliteSetProviders.get(imodel);
+        if (!provider) {
+            provider = HiliteSetProvider.create({ imodel });
+            this._hiliteSetProviders.set(imodel, provider);
+        }
+        return provider.getHiliteSet(this.getSelection(imodel));
+    }
+}
+/** @internal */
+class SelectionContainer {
+    constructor() {
+        this._selectedItemsSetMap = new Map();
+    }
+    getSelection(level) {
+        let selectedItemsSet = this._selectedItemsSetMap.get(level);
+        if (!selectedItemsSet) {
+            selectedItemsSet = new KeySet();
+            this._selectedItemsSetMap.set(level, selectedItemsSet);
+        }
+        return selectedItemsSet;
+    }
+    getSelectionLevels() {
+        const levels = new Array();
+        for (const entry of this._selectedItemsSetMap.entries()) {
+            if (!entry[1].isEmpty)
+                levels.push(entry[0]);
+        }
+        return levels.sort();
+    }
+    clear(level) {
+        const keys = this._selectedItemsSetMap.keys();
+        for (const key of keys) {
+            if (key >= level) {
+                const selectedItemsSet = this._selectedItemsSetMap.get(key);
+                selectedItemsSet.clear();
+            }
+        }
+    }
+}
+/** @internal */
+export const TRANSIENT_ELEMENT_CLASSNAME = "/TRANSIENT";
+/** @internal */
+export class ToolSelectionSyncHandler {
+    constructor(imodel, logicalSelection) {
+        this._selectionSourceName = "Tool";
+        this._asyncsTracker = new AsyncTasksTracker();
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        this.onToolSelectionChanged = async (ev) => {
+            // ignore selection change event if the handler is suspended
+            if (this.isSuspended)
+                return;
+            // this component only cares about its own imodel
+            const imodel = ev.set.iModel;
+            if (imodel !== this._imodel)
+                return;
+            // determine the level of selection changes
+            // wip: may want to allow selecting at different levels?
+            const selectionLevel = 0;
+            let ids;
+            switch (ev.type) {
+                case SelectionSetEventType.Add:
+                    ids = ev.added;
+                    break;
+                case SelectionSetEventType.Replace:
+                    ids = ev.set.elements;
+                    break;
+                default:
+                    ids = ev.removed;
+                    break;
+            }
+            // we're always using scoped selection changer even if the scope is set to "element" - that
+            // makes sure we're adding to selection keys with concrete classes and not "BisCore:Element", which
+            // we can't because otherwise our keys compare fails (presentation components load data with
+            // concrete classes)
+            const changer = new ScopedSelectionChanger(this._selectionSourceName, this._imodel, this._logicalSelection, createSelectionScopeProps(this._logicalSelection.scopes.activeScope));
+            // we know what to do immediately on `clear` events
+            if (SelectionSetEventType.Clear === ev.type) {
+                await changer.clear(selectionLevel);
+                return;
+            }
+            const parsedIds = parseIds(ids);
+            await using(this._asyncsTracker.trackAsyncTask(), async (_r) => {
+                switch (ev.type) {
+                    case SelectionSetEventType.Add:
+                        await changer.add(parsedIds.transient, parsedIds.persistent, selectionLevel);
+                        break;
+                    case SelectionSetEventType.Replace:
+                        await changer.replace(parsedIds.transient, parsedIds.persistent, selectionLevel);
+                        break;
+                    case SelectionSetEventType.Remove:
+                        await changer.remove(parsedIds.transient, parsedIds.persistent, selectionLevel);
+                        break;
+                }
+            });
+        };
+        this._imodel = imodel;
+        this._logicalSelection = logicalSelection;
+        this._imodelToolSelectionListenerDisposeFunc = imodel.selectionSet.onChanged.addListener(this.onToolSelectionChanged);
+    }
+    dispose() {
+        this._imodelToolSelectionListenerDisposeFunc();
+    }
+    /** note: used only it tests */
+    get pendingAsyncs() { return this._asyncsTracker.pendingAsyncs; }
+}
+const parseIds = (ids) => {
+    let allPersistent = true;
+    let allTransient = true;
+    for (const id of Id64.iterable(ids)) {
+        if (Id64.isTransient(id))
+            allPersistent = false;
+        else
+            allTransient = false;
+        if (!allPersistent && !allTransient)
+            break;
+    }
+    // avoid making a copy if ids are only persistent or only transient
+    if (allPersistent) {
+        return { persistent: ids, transient: [] };
+    }
+    else if (allTransient) {
+        return { persistent: [], transient: ids };
+    }
+    // if `ids` contain mixed ids, we have to copy.. use Array instead of
+    // a Set for performance
+    const persistentElementIds = [];
+    const transientElementIds = [];
+    for (const id of Id64.iterable(ids)) {
+        if (Id64.isTransient(id))
+            transientElementIds.push(id);
+        else
+            persistentElementIds.push(id);
+    }
+    return { persistent: persistentElementIds, transient: transientElementIds };
+};
+function addTransientKeys(transientIds, keys) {
+    for (const id of Id64.iterable(transientIds))
+        keys.add({ className: TRANSIENT_ELEMENT_CLASSNAME, id });
+}
+/** @internal */
+class ScopedSelectionChanger {
+    constructor(name, imodel, manager, scope) {
+        this.name = name;
+        this.imodel = imodel;
+        this.manager = manager;
+        this.scope = scope;
+    }
+    async clear(level) {
+        this.manager.clearSelection(this.name, this.imodel, level);
+    }
+    async add(transientIds, persistentIds, level) {
+        const keys = await this.manager.scopes.computeSelection(this.imodel, persistentIds, this.scope);
+        addTransientKeys(transientIds, keys);
+        this.manager.addToSelection(this.name, this.imodel, keys, level);
+    }
+    async remove(transientIds, persistentIds, level) {
+        const keys = await this.manager.scopes.computeSelection(this.imodel, persistentIds, this.scope);
+        addTransientKeys(transientIds, keys);
+        this.manager.removeFromSelection(this.name, this.imodel, keys, level);
+    }
+    async replace(transientIds, persistentIds, level) {
+        const keys = await this.manager.scopes.computeSelection(this.imodel, persistentIds, this.scope);
+        addTransientKeys(transientIds, keys);
+        this.manager.replaceSelection(this.name, this.imodel, keys, level);
+    }
+}
 //# sourceMappingURL=SelectionManager.js.map