@itwin/presentation-frontend 5.0.0-dev.8 → 5.0.0-dev.82

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

@@ -2,11 +2,64 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
+/* eslint-disable @typescript-eslint/no-deprecated */
 /** @packageDocumentation
  * @module UnifiedSelection
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { defer, EMPTY, mergeMap, of, Subject, takeUntil, tap } from "rxjs";
-import { Id64, using } from "@itwin/core-bentley";
+import { Id64 } from "@itwin/core-bentley";
 import { IModelConnection, SelectionSetEventType } from "@itwin/core-frontend";
 import { AsyncTasksTracker, KeySet, NodeKey } from "@itwin/presentation-common";
 import { createStorage, TRANSIENT_ELEMENT_CLASSNAME, } from "@itwin/unified-selection";
@@ -17,42 +70,62 @@ import { createSelectionScopeProps } from "./SelectionScopesManager";
 /**
  * The selection manager which stores the overall selection.
  * @public
+ * @deprecated in 5.0. Use `SelectionStorage` from [@itwin/unified-selection](https://github.com/iTwin/presentation/blob/master/packages/unified-selection/README.md) package instead.
  */
 export class SelectionManager {
+    _imodelKeyFactory;
+    _imodelToolSelectionSyncHandlers = new Map();
+    _hiliteSetProviders = new Map();
+    _ownsStorage;
+    _knownIModels = new Set();
+    _currentSelection = new CurrentSelectionStorage();
+    _selectionChanges = new Subject();
+    _selectionEventsSubscription;
+    _listeners = [];
+    /**
+     * Underlying selection storage used by this selection manager. Ideally, consumers should use
+     * the storage directly instead of using this manager to manipulate selection.
+     */
+    selectionStorage;
+    /** An event which gets broadcasted on selection changes */
+    selectionChange;
+    /** Manager for [selection scopes]($docs/presentation/unified-selection/index#selection-scopes) */
+    scopes;
     /**
      * Creates an instance of SelectionManager.
      */
     constructor(props) {
-        this._imodelToolSelectionSyncHandlers = new Map();
-        this._hiliteSetProviders = new Map();
-        this._knownIModels = new Map();
-        this._currentSelection = new CurrentSelectionStorage();
-        this._selectionChanges = new Subject();
-        this._listeners = [];
         this.selectionChange = new SelectionChangeEvent();
         this.scopes = props.scopes;
-        this._selectionStorage = props.selectionStorage ?? createStorage();
+        this.selectionStorage = props.selectionStorage ?? createStorage();
+        this._imodelKeyFactory = props.imodelKeyFactory ?? ((imodel) => (imodel.key.length ? imodel.key : imodel.name));
         this._ownsStorage = props.selectionStorage === undefined;
-        this._selectionStorage.selectionChangeEvent.addListener((args) => this._selectionChanges.next(args));
+        this.selectionStorage.selectionChangeEvent.addListener((args) => this._selectionChanges.next(args));
         this._selectionEventsSubscription = this.streamSelectionEvents();
         this._listeners.push(IModelConnection.onOpen.addListener((imodel) => {
-            this._knownIModels.set(imodel.key, imodel);
+            this._knownIModels.add(imodel);
         }));
         this._listeners.push(IModelConnection.onClose.addListener((imodel) => {
             this.onConnectionClose(imodel);
         }));
     }
-    dispose() {
+    [Symbol.dispose]() {
         this._selectionEventsSubscription.unsubscribe();
         this._listeners.forEach((dispose) => dispose());
     }
+    /** @deprecated in 5.0. Use [Symbol.dispose] instead. */
+    // istanbul ignore next
+    dispose() {
+        this[Symbol.dispose]();
+    }
     onConnectionClose(imodel) {
+        const imodelKey = this._imodelKeyFactory(imodel);
         this._hiliteSetProviders.delete(imodel);
-        this._knownIModels.delete(imodel.key);
-        this._currentSelection.clear(imodel.key);
+        this._knownIModels.delete(imodel);
+        this._currentSelection.clear(imodelKey);
         if (this._ownsStorage) {
             this.clearSelection("Connection Close Event", imodel);
-            this._selectionStorage.clearStorage({ iModelKey: imodel.key });
+            this.selectionStorage.clearStorage({ imodelKey });
         }
     }
     /** @internal */
@@ -81,27 +154,30 @@ export class SelectionManager {
                 }
                 else {
                     this._imodelToolSelectionSyncHandlers.delete(imodel);
-                    registration.handler.dispose();
+                    registration.handler[Symbol.dispose]();
                 }
             }
         }
     }
     /**
-     * Temporarily suspends tool selection synchronization until the returned `IDisposable`
+     * Temporarily suspends tool selection synchronization until the returned `Disposable`
      * is disposed.
      */
     suspendIModelToolSelectionSync(imodel) {
         const registration = this._imodelToolSelectionSyncHandlers.get(imodel);
         if (!registration) {
-            return { dispose: () => { } };
+            const noop = () => { };
+            return { [Symbol.dispose]: noop, dispose: noop };
         }
         const wasSuspended = registration.handler.isSuspended;
         registration.handler.isSuspended = true;
-        return { dispose: () => (registration.handler.isSuspended = wasSuspended) };
+        const doDispose = () => (registration.handler.isSuspended = wasSuspended);
+        return { [Symbol.dispose]: doDispose, dispose: doDispose };
     }
     /** Get the selection levels currently stored in this manager for the specified imodel */
     getSelectionLevels(imodel) {
-        return this._selectionStorage.getSelectionLevels({ iModelKey: imodel.key });
+        const imodelKey = this._imodelKeyFactory(imodel);
+        return this.selectionStorage.getSelectionLevels({ imodelKey });
     }
     /**
      * Get the selection currently stored in this manager
@@ -111,39 +187,39 @@ export class SelectionManager {
      * latest selection after changes.
      */
     getSelection(imodel, level = 0) {
-        return this._currentSelection.getSelection(imodel.key, level);
+        const imodelKey = this._imodelKeyFactory(imodel);
+        return this._currentSelection.getSelection(imodelKey, level);
     }
     handleEvent(evt) {
-        if (!this._knownIModels.has(evt.imodel.key)) {
-            this._knownIModels.set(evt.imodel.key, evt.imodel);
-        }
+        const imodelKey = this._imodelKeyFactory(evt.imodel);
+        this._knownIModels.add(evt.imodel);
         switch (evt.changeType) {
             case SelectionChangeType.Add:
-                this._selectionStorage.addToSelection({
-                    iModelKey: evt.imodel.key,
+                this.selectionStorage.addToSelection({
+                    imodelKey,
                     source: evt.source,
                     level: evt.level,
                     selectables: keysToSelectable(evt.imodel, evt.keys),
                 });
                 break;
             case SelectionChangeType.Remove:
-                this._selectionStorage.removeFromSelection({
-                    iModelKey: evt.imodel.key,
+                this.selectionStorage.removeFromSelection({
+                    imodelKey,
                     source: evt.source,
                     level: evt.level,
                     selectables: keysToSelectable(evt.imodel, evt.keys),
                 });
                 break;
             case SelectionChangeType.Replace:
-                this._selectionStorage.replaceSelection({
-                    iModelKey: evt.imodel.key,
+                this.selectionStorage.replaceSelection({
+                    imodelKey,
                     source: evt.source,
                     level: evt.level,
                     selectables: keysToSelectable(evt.imodel, evt.keys),
                 });
                 break;
             case SelectionChangeType.Clear:
-                this._selectionStorage.clearSelection({ iModelKey: evt.imodel.key, source: evt.source, level: evt.level });
+                this.selectionStorage.clearSelection({ imodelKey, source: evt.source, level: evt.level });
                 break;
         }
     }
@@ -290,9 +366,9 @@ export class SelectionManager {
     streamSelectionEvents() {
         return this._selectionChanges
             .pipe(mergeMap((args) => {
-            const currentSelectables = this._selectionStorage.getSelection({ iModelKey: args.imodelKey, level: args.level });
+            const currentSelectables = this.selectionStorage.getSelection({ imodelKey: args.imodelKey, level: args.level });
             return this._currentSelection.computeSelection(args.imodelKey, args.level, currentSelectables, args.selectables).pipe(mergeMap(({ level, changedSelection }) => {
-                const imodel = this._knownIModels.get(args.imodelKey);
+                const imodel = findIModel(this._knownIModels, this._imodelKeyFactory, args.imodelKey);
                 // istanbul ignore if
                 if (!imodel) {
                     return EMPTY;
@@ -314,12 +390,37 @@ export class SelectionManager {
         });
     }
 }
+function findIModel(set, imodelKeyFactory, key) {
+    for (const imodel of set) {
+        if (imodelKeyFactory(imodel) === key) {
+            return imodel;
+        }
+    }
+    return undefined;
+}
 /** @internal */
 export class ToolSelectionSyncHandler {
+    _selectionSourceName = "Tool";
+    _logicalSelection;
+    _imodel;
+    _imodelToolSelectionListenerDisposeFunc;
+    _asyncsTracker = new AsyncTasksTracker();
+    isSuspended;
     constructor(imodel, logicalSelection) {
-        this._selectionSourceName = "Tool";
-        this._asyncsTracker = new AsyncTasksTracker();
-        this.onToolSelectionChanged = async (ev) => {
+        this._imodel = imodel;
+        this._logicalSelection = logicalSelection;
+        this._imodelToolSelectionListenerDisposeFunc = imodel.selectionSet.onChanged.addListener(this.onToolSelectionChanged);
+    }
+    [Symbol.dispose]() {
+        this._imodelToolSelectionListenerDisposeFunc();
+    }
+    /** note: used only it tests */
+    get pendingAsyncs() {
+        return this._asyncsTracker.pendingAsyncs;
+    }
+    onToolSelectionChanged = async (ev) => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
             // ignore selection change event if the handler is suspended
             if (this.isSuspended) {
                 return;
@@ -335,13 +436,13 @@ export class ToolSelectionSyncHandler {
             let ids;
             switch (ev.type) {
                 case SelectionSetEventType.Add:
-                    ids = ev.added;
+                    ids = ev.additions;
                     break;
                 case SelectionSetEventType.Replace:
-                    ids = ev.set.elements;
+                    ids = ev.set.active;
                     break;
                 default:
-                    ids = ev.removed;
+                    ids = ev.removals;
                     break;
             }
             // we're always using scoped selection changer even if the scope is set to "element" - that
@@ -349,39 +450,32 @@ export class ToolSelectionSyncHandler {
             // 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 _r = __addDisposableResource(env_1, this._asyncsTracker.trackAsyncTask(), false);
+            switch (ev.type) {
+                case SelectionSetEventType.Add:
+                    await changer.add(ids, selectionLevel);
+                    break;
+                case SelectionSetEventType.Replace:
+                    await changer.replace(ids, selectionLevel);
+                    break;
+                case SelectionSetEventType.Remove:
+                    await changer.remove(ids, selectionLevel);
+                    break;
+                case SelectionSetEventType.Clear:
+                    await changer.clear(selectionLevel);
+                    break;
             }
-            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;
-    }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    };
 }
-const parseIds = (ids) => {
+const parseElementIds = (ids) => {
     let allPersistent = true;
     let allTransient = true;
     for (const id of Id64.iterable(ids)) {
@@ -416,13 +510,16 @@ const parseIds = (ids) => {
     }
     return { persistent: persistentElementIds, transient: transientElementIds };
 };
-function addTransientKeys(transientIds, keys) {
-    for (const id of Id64.iterable(transientIds)) {
-        keys.add({ className: TRANSIENT_ELEMENT_CLASSNAME, id });
+function addKeys(target, className, ids) {
+    for (const id of Id64.iterable(ids)) {
+        target.add({ className, id });
     }
 }
-/** @internal */
 class ScopedSelectionChanger {
+    name;
+    imodel;
+    manager;
+    scope;
     constructor(name, imodel, manager, scope) {
         this.name = name;
         this.imodel = imodel;
@@ -432,27 +529,37 @@ class ScopedSelectionChanger {
     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);
+    async add(ids, level) {
+        const keys = await this.#computeSelection(ids);
         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);
+    async remove(ids, level) {
+        const keys = await this.#computeSelection(ids);
         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);
+    async replace(ids, level) {
+        const keys = await this.#computeSelection(ids);
         this.manager.replaceSelection(this.name, this.imodel, keys, level);
     }
+    async #computeSelection(ids) {
+        let keys = new KeySet();
+        if (ids.elements) {
+            const { persistent, transient } = parseElementIds(ids.elements);
+            keys = await this.manager.scopes.computeSelection(this.imodel, persistent, this.scope);
+            addKeys(keys, TRANSIENT_ELEMENT_CLASSNAME, transient);
+        }
+        if (ids.models) {
+            addKeys(keys, "BisCore.Model", ids.models);
+        }
+        if (ids.subcategories) {
+            addKeys(keys, "BisCore.SubCategory", ids.subcategories);
+        }
+        return keys;
+    }
 }
 /** Stores current selection in `KeySet` format per iModel.  */
 class CurrentSelectionStorage {
-    constructor() {
-        this._currentSelection = new Map();
-    }
+    _currentSelection = new Map();
     getCurrentSelectionStorage(imodelKey) {
         let storage = this._currentSelection.get(imodelKey);
         if (!storage) {
@@ -476,9 +583,7 @@ class CurrentSelectionStorage {
  * It always stores result of latest resolved call to `computeSelection`.
  */
 class IModelSelectionStorage {
-    constructor() {
-        this._currentSelection = new Map();
-    }
+    _currentSelection = new Map();
     getSelection(level) {
         let entry = this._currentSelection.get(level);
         if (!entry) {