@itwin/presentation-frontend 4.5.0-dev.9 → 4.5.1

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

@@ -1,16 +1,19 @@
 "use strict";
 /*---------------------------------------------------------------------------------------------
-* 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.
+ *--------------------------------------------------------------------------------------------*/
 /** @packageDocumentation
  * @module UnifiedSelection
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolSelectionSyncHandler = exports.TRANSIENT_ELEMENT_CLASSNAME = exports.SelectionManager = void 0;
+const rxjs_1 = require("rxjs");
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_frontend_1 = require("@itwin/core-frontend");
 const presentation_common_1 = require("@itwin/presentation-common");
+const unified_selection_1 = require("@itwin/unified-selection");
+const Presentation_1 = require("../Presentation");
 const HiliteSetProvider_1 = require("./HiliteSetProvider");
 const SelectionChangeEvent_1 = require("./SelectionChangeEvent");
 const SelectionScopesManager_1 = require("./SelectionScopesManager");
@@ -23,31 +26,43 @@ class SelectionManager {
      * Creates an instance of SelectionManager.
      */
     constructor(props) {
-        this._selectionContainerMap = new Map();
         this._imodelToolSelectionSyncHandlers = new Map();
         this._hiliteSetProviders = new Map();
+        this._knownIModels = new Map();
+        this._currentSelection = new CurrentSelectionStorage();
+        this._selectionChanges = new rxjs_1.Subject();
+        this._listeners = [];
         this.selectionChange = new SelectionChangeEvent_1.SelectionChangeEvent();
         this.scopes = props.scopes;
-        core_frontend_1.IModelConnection.onClose.addListener((imodel) => {
+        this._selectionStorage = props.selectionStorage ?? (0, unified_selection_1.createStorage)();
+        this._ownsStorage = props.selectionStorage === undefined;
+        this._selectionStorage.selectionChangeEvent.addListener((args) => this._selectionChanges.next(args));
+        this._selectionEventsSubscription = this.streamSelectionEvents();
+        this._listeners.push(core_frontend_1.IModelConnection.onOpen.addListener((imodel) => {
+            this._knownIModels.set(imodel.key, imodel);
+        }));
+        this._listeners.push(core_frontend_1.IModelConnection.onClose.addListener((imodel) => {
             this.onConnectionClose(imodel);
-        });
+        }));
+    }
+    dispose() {
+        this._selectionEventsSubscription.unsubscribe();
+        this._listeners.forEach((dispose) => dispose());
     }
     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);
+        this._knownIModels.delete(imodel.key);
+        this._currentSelection.clear(imodel.key);
+        if (this._ownsStorage) {
+            this.clearSelection("Connection Close Event", imodel);
+            this._selectionStorage.clearStorage({ iModelKey: imodel.key });
         }
-        return selectionContainer;
     }
     /** @internal */
     // istanbul ignore next
-    getToolSelectionSyncHandler(imodel) { return this._imodelToolSelectionSyncHandlers.get(imodel)?.handler; }
+    getToolSelectionSyncHandler(imodel) {
+        return this._imodelToolSelectionSyncHandlers.get(imodel)?.handler;
+    }
     /**
      * Request the manager to sync with imodel's tool selection (see `IModelConnection.selectionSet`).
      */
@@ -80,46 +95,57 @@ class SelectionManager {
      */
     suspendIModelToolSelectionSync(imodel) {
         const registration = this._imodelToolSelectionSyncHandlers.get(imodel);
-        if (!registration)
+        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();
+        return this._selectionStorage.getSelectionLevels({ iModelKey: imodel.key });
     }
-    /** Get the selection currently stored in this manager */
+    /**
+     * Get the selection currently stored in this manager
+     *
+     * @note Calling immediately after `add*`|`replace*`|`remove*`|`clear*` method call does not guarantee
+     * that returned `KeySet` will include latest changes. Listen for `selectionChange` event to get the
+     * latest selection after changes.
+     */
     getSelection(imodel, level = 0) {
-        return this.getContainer(imodel).getSelection(level);
+        return this._currentSelection.getSelection(imodel.key, level);
     }
     handleEvent(evt) {
-        const container = this.getContainer(evt.imodel);
-        const selectedItemsSet = container.getSelection(evt.level);
-        const guidBefore = selectedItemsSet.guid;
         switch (evt.changeType) {
             case SelectionChangeEvent_1.SelectionChangeType.Add:
-                selectedItemsSet.add(evt.keys);
+                this._selectionStorage.addToSelection({
+                    iModelKey: evt.imodel.key,
+                    source: evt.source,
+                    level: evt.level,
+                    selectables: keysToSelectable(evt.imodel, evt.keys),
+                });
                 break;
             case SelectionChangeEvent_1.SelectionChangeType.Remove:
-                selectedItemsSet.delete(evt.keys);
+                this._selectionStorage.removeFromSelection({
+                    iModelKey: evt.imodel.key,
+                    source: evt.source,
+                    level: evt.level,
+                    selectables: keysToSelectable(evt.imodel, evt.keys),
+                });
                 break;
             case SelectionChangeEvent_1.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);
-                }
+                this._selectionStorage.replaceSelection({
+                    iModelKey: evt.imodel.key,
+                    source: evt.source,
+                    level: evt.level,
+                    selectables: keysToSelectable(evt.imodel, evt.keys),
+                });
                 break;
             case SelectionChangeEvent_1.SelectionChangeType.Clear:
-                selectedItemsSet.clear();
+                this._selectionStorage.clearSelection({ iModelKey: evt.imodel.key, source: evt.source, level: evt.level });
                 break;
         }
-        if (selectedItemsSet.guid === guidBefore)
-            return;
-        container.clear(evt.level + 1);
-        this.selectionChange.raiseEvent(evt, this);
     }
     /**
      * Add keys to the selection
@@ -261,39 +287,33 @@ class SelectionManager {
         }
         return provider;
     }
-}
-exports.SelectionManager = SelectionManager;
-/** @internal */
-class SelectionContainer {
-    constructor() {
-        this._selectedItemsSetMap = new Map();
-    }
-    getSelection(level) {
-        let selectedItemsSet = this._selectedItemsSetMap.get(level);
-        if (!selectedItemsSet) {
-            selectedItemsSet = new presentation_common_1.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();
-            }
-        }
+    streamSelectionEvents() {
+        return this._selectionChanges
+            .pipe((0, rxjs_1.mergeMap)((args) => {
+            const currentSelectables = this._selectionStorage.getSelection({ iModelKey: args.iModelKey, level: args.level });
+            return this._currentSelection.computeSelection(args.iModelKey, args.level, currentSelectables, args.selectables).pipe((0, rxjs_1.mergeMap)(({ level, changedSelection }) => {
+                const imodel = this._knownIModels.get(args.iModelKey);
+                if (!imodel) {
+                    return rxjs_1.EMPTY;
+                }
+                return (0, rxjs_1.of)({
+                    imodel,
+                    keys: changedSelection,
+                    level,
+                    source: args.source,
+                    timestamp: args.timestamp,
+                    changeType: getChangeType(args.changeType),
+                });
+            }));
+        }))
+            .subscribe({
+            next: (args) => {
+                this.selectionChange.raiseEvent(args, this);
+            },
+        });
     }
 }
+exports.SelectionManager = SelectionManager;
 /** @internal */
 exports.TRANSIENT_ELEMENT_CLASSNAME = "/TRANSIENT";
 /** @internal */
@@ -304,12 +324,14 @@ class ToolSelectionSyncHandler {
         // eslint-disable-next-line @typescript-eslint/naming-convention
         this.onToolSelectionChanged = async (ev) => {
             // ignore selection change event if the handler is suspended
-            if (this.isSuspended)
+            if (this.isSuspended) {
                 return;
+            }
             // this component only cares about its own imodel
             const imodel = ev.set.iModel;
-            if (imodel !== this._imodel)
+            if (imodel !== this._imodel) {
                 return;
+            }
             // determine the level of selection changes
             // wip: may want to allow selecting at different levels?
             const selectionLevel = 0;
@@ -358,19 +380,24 @@ class ToolSelectionSyncHandler {
         this._imodelToolSelectionListenerDisposeFunc();
     }
     /** note: used only it tests */
-    get pendingAsyncs() { return this._asyncsTracker.pendingAsyncs; }
+    get pendingAsyncs() {
+        return this._asyncsTracker.pendingAsyncs;
+    }
 }
 exports.ToolSelectionSyncHandler = ToolSelectionSyncHandler;
 const parseIds = (ids) => {
     let allPersistent = true;
     let allTransient = true;
     for (const id of core_bentley_1.Id64.iterable(ids)) {
-        if (core_bentley_1.Id64.isTransient(id))
+        if (core_bentley_1.Id64.isTransient(id)) {
             allPersistent = false;
-        else
+        }
+        else {
             allTransient = false;
-        if (!allPersistent && !allTransient)
+        }
+        if (!allPersistent && !allTransient) {
             break;
+        }
     }
     // avoid making a copy if ids are only persistent or only transient
     if (allPersistent) {
@@ -384,16 +411,19 @@ const parseIds = (ids) => {
     const persistentElementIds = [];
     const transientElementIds = [];
     for (const id of core_bentley_1.Id64.iterable(ids)) {
-        if (core_bentley_1.Id64.isTransient(id))
+        if (core_bentley_1.Id64.isTransient(id)) {
             transientElementIds.push(id);
-        else
+        }
+        else {
             persistentElementIds.push(id);
+        }
     }
     return { persistent: persistentElementIds, transient: transientElementIds };
 };
 function addTransientKeys(transientIds, keys) {
-    for (const id of core_bentley_1.Id64.iterable(transientIds))
+    for (const id of core_bentley_1.Id64.iterable(transientIds)) {
         keys.add({ className: exports.TRANSIENT_ELEMENT_CLASSNAME, id });
+    }
 }
 /** @internal */
 class ScopedSelectionChanger {
@@ -422,4 +452,194 @@ class ScopedSelectionChanger {
         this.manager.replaceSelection(this.name, this.imodel, keys, level);
     }
 }
+/** Stores current selection in `KeySet` format per iModel.  */
+class CurrentSelectionStorage {
+    constructor() {
+        this._currentSelection = new Map();
+    }
+    getCurrentSelectionStorage(imodelKey) {
+        let storage = this._currentSelection.get(imodelKey);
+        if (!storage) {
+            storage = new IModelSelectionStorage();
+            this._currentSelection.set(imodelKey, storage);
+        }
+        return storage;
+    }
+    getSelection(imodelKey, level) {
+        return this.getCurrentSelectionStorage(imodelKey).getSelection(level);
+    }
+    clear(imodelKey) {
+        this._currentSelection.delete(imodelKey);
+    }
+    computeSelection(imodelKey, level, currSelectables, changedSelectables) {
+        return this.getCurrentSelectionStorage(imodelKey).computeSelection(level, currSelectables, changedSelectables);
+    }
+}
+/**
+ * Computes and stores current selection in `KeySet` format.
+ * It always stores result of latest resolved call to `computeSelection`.
+ */
+class IModelSelectionStorage {
+    constructor() {
+        this._currentSelection = new Map();
+    }
+    getSelection(level) {
+        let entry = this._currentSelection.get(level);
+        if (!entry) {
+            entry = { value: new presentation_common_1.KeySet(), ongoingComputationDisposers: new Set() };
+            this._currentSelection.set(level, entry);
+        }
+        return entry.value;
+    }
+    clearSelections(level) {
+        const clearedLevels = [];
+        for (const [storedLevel] of this._currentSelection.entries()) {
+            if (storedLevel > level) {
+                clearedLevels.push(storedLevel);
+            }
+        }
+        clearedLevels.forEach((storedLevel) => {
+            const entry = this._currentSelection.get(storedLevel);
+            // istanbul ignore if
+            if (!entry) {
+                return;
+            }
+            for (const disposer of entry.ongoingComputationDisposers) {
+                disposer.next();
+            }
+            this._currentSelection.delete(storedLevel);
+        });
+    }
+    addDisposer(level, disposer) {
+        const entry = this._currentSelection.get(level);
+        if (!entry) {
+            this._currentSelection.set(level, { value: new presentation_common_1.KeySet(), ongoingComputationDisposers: new Set([disposer]) });
+            return;
+        }
+        entry.ongoingComputationDisposers.add(disposer);
+    }
+    setSelection(level, keys, disposer) {
+        const currEntry = this._currentSelection.get(level);
+        // istanbul ignore else
+        if (currEntry) {
+            currEntry.ongoingComputationDisposers.delete(disposer);
+        }
+        this._currentSelection.set(level, {
+            value: keys,
+            ongoingComputationDisposers: currEntry?.ongoingComputationDisposers ?? /* istanbul ignore next */ new Set(),
+        });
+    }
+    computeSelection(level, currSelectables, changedSelectables) {
+        this.clearSelections(level);
+        const prevComputationsDisposers = [...(this._currentSelection.get(level)?.ongoingComputationDisposers ?? [])];
+        const currDisposer = new rxjs_1.Subject();
+        this.addDisposer(level, currDisposer);
+        return (0, rxjs_1.defer)(async () => {
+            const convertedSelectables = [];
+            const [current, changed] = await Promise.all([
+                selectablesToKeys(currSelectables, convertedSelectables),
+                selectablesToKeys(changedSelectables, convertedSelectables),
+            ]);
+            const currentSelection = new presentation_common_1.KeySet([...current.keys, ...current.selectableKeys.flatMap((selectable) => selectable.keys)]);
+            const changedSelection = new presentation_common_1.KeySet([...changed.keys, ...changed.selectableKeys.flatMap((selectable) => selectable.keys)]);
+            return {
+                level,
+                currentSelection,
+                changedSelection,
+            };
+        }).pipe((0, rxjs_1.takeUntil)(currDisposer), (0, rxjs_1.tap)({
+            next: (val) => {
+                prevComputationsDisposers.forEach((disposer) => disposer.next());
+                this.setSelection(val.level, val.currentSelection, currDisposer);
+            },
+        }));
+    }
+}
+function keysToSelectable(imodel, keys) {
+    const selectables = [];
+    keys.forEach((key) => {
+        if ("id" in key) {
+            selectables.push(key);
+            return;
+        }
+        const customSelectable = {
+            identifier: key.pathFromRoot.join("/"),
+            data: key,
+            loadInstanceKeys: () => createInstanceKeysIterator(imodel, key),
+        };
+        selectables.push(customSelectable);
+    });
+    return selectables;
+}
+async function selectablesToKeys(selectables, convertedList) {
+    const keys = [];
+    const selectableKeys = [];
+    for (const [className, ids] of selectables.instanceKeys) {
+        for (const id of ids) {
+            keys.push({ id, className });
+        }
+    }
+    for (const [_, selectable] of selectables.custom) {
+        if (isNodeKey(selectable.data)) {
+            selectableKeys.push({ identifier: selectable.identifier, keys: [selectable.data] });
+            continue;
+        }
+        const converted = convertedList.find((con) => con.identifier === selectable.identifier);
+        if (converted) {
+            selectableKeys.push(converted);
+            continue;
+        }
+        const newConverted = { identifier: selectable.identifier, keys: [] };
+        convertedList.push(newConverted);
+        for await (const instanceKey of selectable.loadInstanceKeys()) {
+            newConverted.keys.push(instanceKey);
+        }
+        selectableKeys.push(newConverted);
+    }
+    return { keys, selectableKeys };
+}
+async function* createInstanceKeysIterator(imodel, nodeKey) {
+    if (presentation_common_1.NodeKey.isInstancesNodeKey(nodeKey)) {
+        for (const key of nodeKey.instanceKeys) {
+            yield key;
+        }
+        return;
+    }
+    const content = await Presentation_1.Presentation.presentation.getContentInstanceKeys({
+        imodel,
+        keys: new presentation_common_1.KeySet([nodeKey]),
+        rulesetOrId: {
+            id: "grouped-instances",
+            rules: [
+                {
+                    ruleType: "Content",
+                    specifications: [
+                        {
+                            specType: "SelectedNodeInstances",
+                        },
+                    ],
+                },
+            ],
+        },
+    });
+    for await (const key of content.items()) {
+        yield key;
+    }
+}
+function isNodeKey(data) {
+    const key = data;
+    return key.pathFromRoot !== undefined && key.type !== undefined;
+}
+function getChangeType(type) {
+    switch (type) {
+        case "add":
+            return SelectionChangeEvent_1.SelectionChangeType.Add;
+        case "remove":
+            return SelectionChangeEvent_1.SelectionChangeType.Remove;
+        case "replace":
+            return SelectionChangeEvent_1.SelectionChangeType.Replace;
+        case "clear":
+            return SelectionChangeEvent_1.SelectionChangeType.Clear;
+    }
+}
 //# sourceMappingURL=SelectionManager.js.map