@itwin/presentation-frontend 4.0.0-dev.44 → 4.0.0-dev.48

package/lib/esm/presentation-frontend/PresentationManager.js

@@ -1,440 +1,434 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Core
- */
-import { BeEvent, CompressedId64Set, OrderedId64Iterable } from "@itwin/core-bentley";
-import { IModelApp, IpcApp } from "@itwin/core-frontend";
-import { Content, Descriptor, DisplayValueGroup, Item, Key, KeySet, Node, NodePathElement, PresentationIpcEvents, RpcRequestsHandler, RulesetVariable, SelectClassInfo, UpdateInfo, VariableValueTypes, } from "@itwin/presentation-common";
-import { IpcRequestsHandler } from "./IpcRequestsHandler";
-import { FrontendLocalizationHelper } from "./LocalizationHelper";
-import { RulesetManagerImpl } from "./RulesetManager";
-import { RulesetVariablesManagerImpl } from "./RulesetVariablesManager";
-import { TRANSIENT_ELEMENT_CLASSNAME } from "./selection/SelectionManager";
-import { StateTracker } from "./StateTracker";
-/**
- * Frontend Presentation manager which basically just forwards all calls to
- * the backend implementation.
- *
- * @public
- */
-export class PresentationManager {
-    constructor(props) {
-        /**
-         * An event raised when hierarchies created using specific ruleset change
-         * @alpha
-         */
-        this.onIModelHierarchyChanged = new BeEvent();
-        /**
-         * An event raised when content created using specific ruleset changes
-         * @alpha
-         */
-        this.onIModelContentChanged = new BeEvent();
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        this.onUpdate = (_evt, report) => {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.handleUpdateAsync(UpdateInfo.fromJSON(report));
-        };
-        if (props) {
-            // eslint-disable-next-line deprecation/deprecation
-            this._explicitActiveUnitSystem = props.activeUnitSystem;
-        }
-        this._requestsHandler = props?.rpcRequestsHandler ?? new RpcRequestsHandler(props ? { clientId: props.clientId, timeout: props.requestTimeout } : undefined);
-        this._rulesetVars = new Map();
-        this._rulesets = RulesetManagerImpl.create();
-        this._localizationHelper = new FrontendLocalizationHelper(props?.activeLocale);
-        this._connections = new Map();
-        if (IpcApp.isValid) {
-            // Ipc only works in ipc apps, so the `onUpdate` callback will only be called there.
-            this._clearEventListener = IpcApp.addListener(PresentationIpcEvents.Update, this.onUpdate);
-            this._ipcRequestsHandler = props?.ipcRequestsHandler ?? new IpcRequestsHandler(this._requestsHandler.clientId);
-            this._stateTracker = props?.stateTracker ?? new StateTracker(this._ipcRequestsHandler);
-        }
-    }
-    /**
-     * Get / set active unit system used to format property values with units.
-     *
-     * @deprecated in 4.0. `IModelApp.quantityFormatter` should be used to get/set the active unit system. At the moment
-     * [[PresentationManager]] allows overriding it, but returns `IModelApp.quantityFormatter.activeUnitSystem` if override
-     * is not set.
-     */
-    get activeUnitSystem() {
-        return this._explicitActiveUnitSystem ?? IModelApp.quantityFormatter.activeUnitSystem;
-    }
-    set activeUnitSystem(value) { this._explicitActiveUnitSystem = value; }
-    /** Get / set active locale used for localizing presentation data */
-    get activeLocale() { return this._localizationHelper.locale; }
-    set activeLocale(locale) { this._localizationHelper.locale = locale; }
-    dispose() {
-        if (this._clearEventListener) {
-            this._clearEventListener();
-            this._clearEventListener = undefined;
-        }
-    }
-    async onConnection(imodel) {
-        if (!this._connections.has(imodel))
-            this._connections.set(imodel, this.initializeIModel(imodel));
-        await this._connections.get(imodel);
-    }
-    async initializeIModel(imodel) {
-        imodel.onClose.addOnce(() => {
-            this._connections.delete(imodel);
-        });
-        await this.onNewiModelConnection(imodel);
-    }
-    /** @note This is only called in native apps after changes in iModels */
-    async handleUpdateAsync(report) {
-        for (const imodelKey in report) {
-            // istanbul ignore if
-            if (!report.hasOwnProperty(imodelKey))
-                continue;
-            const imodelReport = report[imodelKey];
-            for (const rulesetId in imodelReport) {
-                // istanbul ignore if
-                if (!imodelReport.hasOwnProperty(rulesetId))
-                    continue;
-                const updateInfo = imodelReport[rulesetId];
-                if (updateInfo.content)
-                    this.onIModelContentChanged.raiseEvent({ rulesetId, updateInfo: updateInfo.content, imodelKey });
-                if (updateInfo.hierarchy)
-                    this.onIModelHierarchyChanged.raiseEvent({ rulesetId, updateInfo: updateInfo.hierarchy, imodelKey });
-            }
-        }
-    }
-    /**
-     * Function that is called when a new IModelConnection is used to retrieve data.
-     * @internal
-     */
-    async onNewiModelConnection(_) { }
-    /**
-     * Create a new PresentationManager instance
-     * @param props Optional properties used to configure the manager
-     */
-    static create(props) {
-        return new PresentationManager(props);
-    }
-    /** @internal */
-    get rpcRequestsHandler() { return this._requestsHandler; }
-    /** @internal */
-    get ipcRequestsHandler() { return this._ipcRequestsHandler; }
-    /** @internal */
-    get stateTracker() { return this._stateTracker; }
-    /**
-     * Get rulesets manager
-     */
-    rulesets() { return this._rulesets; }
-    /**
-     * Get ruleset variables manager for specific ruleset
-     * @param rulesetId Id of the ruleset to get the vars manager for
-     */
-    vars(rulesetId) {
-        if (!this._rulesetVars.has(rulesetId)) {
-            const varsManager = new RulesetVariablesManagerImpl(rulesetId, this._ipcRequestsHandler);
-            this._rulesetVars.set(rulesetId, varsManager);
-        }
-        return this._rulesetVars.get(rulesetId);
-    }
-    toRpcTokenOptions(requestOptions) {
-        // 1. put default `locale` and `unitSystem`
-        // 2. put all `requestOptions` members (if `locale` or `unitSystem` are set, they'll override the defaults put at #1)
-        // 3. put `imodel` of type `IModelRpcProps` which overwrites the `imodel` from `requestOptions` put at #2
-        const defaultOptions = {};
-        if (this.activeLocale)
-            defaultOptions.locale = this.activeLocale;
-        defaultOptions.unitSystem = this.activeUnitSystem; // eslint-disable-line deprecation/deprecation
-        const { imodel, rulesetVariables, ...rpcRequestOptions } = requestOptions;
-        return {
-            ...defaultOptions,
-            ...rpcRequestOptions,
-            ...(rulesetVariables ? { rulesetVariables: rulesetVariables.map(RulesetVariable.toJSON) } : {}),
-            imodel: imodel.getRpcProps(),
-        };
-    }
-    async addRulesetAndVariablesToOptions(options) {
-        const { rulesetOrId, rulesetVariables } = options;
-        let foundRulesetOrId;
-        if (typeof rulesetOrId === "object") {
-            foundRulesetOrId = rulesetOrId;
-        }
-        else {
-            const foundRuleset = await this._rulesets.get(rulesetOrId);
-            foundRulesetOrId = foundRuleset ? foundRuleset.toJSON() : rulesetOrId;
-        }
-        const rulesetId = (typeof foundRulesetOrId === "object") ? foundRulesetOrId.id : foundRulesetOrId;
-        // All Id64Array variable values must be sorted for serialization to JSON to work. RulesetVariablesManager
-        // sorts them before storing, so that part is taken care of, but we need to ensure that variables coming from
-        // request options are also sorted.
-        const variables = (rulesetVariables ?? []).map((variable) => {
-            if (variable.type === VariableValueTypes.Id64Array)
-                return { ...variable, value: OrderedId64Iterable.sortArray(variable.value) };
-            return variable;
-        });
-        if (!this._ipcRequestsHandler) {
-            // only need to add variables from variables manager if there's no IPC
-            // handler - if there is one, the variables are already known by the backend
-            variables.push(...this.vars(rulesetId).getAllVariables());
-        }
-        return { ...options, rulesetOrId: foundRulesetOrId, rulesetVariables: variables };
-    }
-    /** Retrieves nodes */
-    async getNodes(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({ ...options });
-        const result = await buildPagedArrayResponse(options.paging, async (partialPageOptions) => this._requestsHandler.getPagedNodes({ ...rpcOptions, paging: partialPageOptions }));
-        // eslint-disable-next-line deprecation/deprecation
-        return this._localizationHelper.getLocalizedNodes(result.items.map(Node.fromJSON));
-    }
-    /** Retrieves nodes count. */
-    async getNodesCount(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({ ...options });
-        return this._requestsHandler.getNodesCount(rpcOptions);
-    }
-    /** Retrieves total nodes count and a single page of nodes. */
-    async getNodesAndCount(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({ ...options });
-        const result = await buildPagedArrayResponse(options.paging, async (partialPageOptions) => this._requestsHandler.getPagedNodes({ ...rpcOptions, paging: partialPageOptions }));
-        return {
-            count: result.total,
-            // eslint-disable-next-line deprecation/deprecation
-            nodes: this._localizationHelper.getLocalizedNodes(result.items.map(Node.fromJSON)),
-        };
-    }
-    /**
-     * Retrieves hierarchy level descriptor.
-     * @beta
-     */
-    async getNodesDescriptor(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({ ...options });
-        const result = await this._requestsHandler.getNodesDescriptor(rpcOptions);
-        return Descriptor.fromJSON(result);
-    }
-    /** Retrieves paths from root nodes to children nodes according to specified keys. Intersecting paths will be merged. */
-    async getNodePaths(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({ ...options });
-        const result = await this._requestsHandler.getNodePaths(rpcOptions);
-        // eslint-disable-next-line deprecation/deprecation
-        return result.map(NodePathElement.fromJSON);
-    }
-    /** Retrieves paths from root nodes to nodes containing filter text in their label. */
-    async getFilteredNodePaths(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const result = await this._requestsHandler.getFilteredNodePaths(this.toRpcTokenOptions(options));
-        // eslint-disable-next-line deprecation/deprecation
-        return result.map(NodePathElement.fromJSON);
-    }
-    /**
-     * Get information about the sources of content when building it for specific ECClasses. Sources involve classes of the primary select instance,
-     * its related instances for loading related and navigation properties.
-     * @public
-     */
-    async getContentSources(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const rpcOptions = this.toRpcTokenOptions(requestOptions);
-        const result = await this._requestsHandler.getContentSources(rpcOptions);
-        return SelectClassInfo.listFromCompressedJSON(result.sources, result.classesMap);
-    }
-    /** Retrieves the content descriptor which describes the content and can be used to customize it. */
-    async getContentDescriptor(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({
-            ...options,
-            keys: stripTransientElementKeys(options.keys).toJSON(),
-        });
-        const result = await this._requestsHandler.getContentDescriptor(rpcOptions);
-        return Descriptor.fromJSON(result);
-    }
-    /** Retrieves overall content set size. */
-    async getContentSetSize(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({
-            ...options,
-            descriptor: getDescriptorOverrides(requestOptions.descriptor),
-            keys: stripTransientElementKeys(requestOptions.keys).toJSON(),
-        });
-        return this._requestsHandler.getContentSetSize(rpcOptions);
-    }
-    /** Retrieves content which consists of a content descriptor and a page of records. */
-    async getContent(requestOptions) {
-        return (await this.getContentAndSize(requestOptions))?.content;
-    }
-    /** Retrieves content set size and content which consists of a content descriptor and a page of records. */
-    async getContentAndSize(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = this.toRpcTokenOptions({
-            ...options,
-            descriptor: getDescriptorOverrides(requestOptions.descriptor),
-            keys: stripTransientElementKeys(requestOptions.keys).toJSON(),
-        });
-        let descriptor = (requestOptions.descriptor instanceof Descriptor) ? requestOptions.descriptor : undefined;
-        const result = await buildPagedArrayResponse(options.paging, async (partialPageOptions, requestIndex) => {
-            if (0 === requestIndex && !descriptor) {
-                const content = await this._requestsHandler.getPagedContent({ ...rpcOptions, paging: partialPageOptions });
-                if (content) {
-                    descriptor = Descriptor.fromJSON(content.descriptor);
-                    return content.contentSet;
-                }
-                return { total: 0, items: [] };
-            }
-            return this._requestsHandler.getPagedContentSet({ ...rpcOptions, paging: partialPageOptions });
-        });
-        if (!descriptor)
-            return undefined;
-        const items = result.items.map((itemJson) => Item.fromJSON(itemJson)).filter((item) => (item !== undefined));
-        return {
-            size: result.total,
-            content: this._localizationHelper.getLocalizedContent(new Content(descriptor, items)),
-        };
-    }
-    /** Retrieves distinct values of specific field from the content. */
-    async getPagedDistinctValues(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = {
-            ...this.toRpcTokenOptions(options),
-            descriptor: getDescriptorOverrides(options.descriptor),
-            keys: stripTransientElementKeys(options.keys).toJSON(),
-        };
-        const result = await buildPagedArrayResponse(requestOptions.paging, async (partialPageOptions) => this._requestsHandler.getPagedDistinctValues({ ...rpcOptions, paging: partialPageOptions }));
-        return {
-            ...result,
-            // eslint-disable-next-line deprecation/deprecation
-            items: result.items.map(DisplayValueGroup.fromJSON),
-        };
-    }
-    /**
-     * Retrieves property data in a simplified format for a single element specified by ID.
-     * @public
-     */
-    async getElementProperties(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const results = await this._requestsHandler.getElementProperties(this.toRpcTokenOptions(requestOptions));
-        // istanbul ignore if
-        if (!results)
-            return undefined;
-        return this._localizationHelper.getLocalizedElementProperties(results);
-    }
-    /**
-     * Retrieves content item instance keys.
-     * @public
-     */
-    async getContentInstanceKeys(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
-        const rpcOptions = {
-            ...this.toRpcTokenOptions(options),
-            keys: stripTransientElementKeys(options.keys).toJSON(),
-        };
-        const props = {
-            page: requestOptions.paging,
-            get: async (page) => {
-                const keys = await this._requestsHandler.getContentInstanceKeys({ ...rpcOptions, paging: page });
-                return {
-                    total: keys.total,
-                    items: keys.items.instanceKeys.reduce((instanceKeys, entry) => {
-                        for (const id of CompressedId64Set.iterable(entry[1])) {
-                            instanceKeys.push({ className: entry[0], id });
-                        }
-                        return instanceKeys;
-                    }, new Array()),
-                };
-            },
-        };
-        return createPagedGeneratorResponse(props);
-    }
-    /** Retrieves display label definition of specific item. */
-    async getDisplayLabelDefinition(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const rpcOptions = this.toRpcTokenOptions({ ...requestOptions });
-        const result = await this._requestsHandler.getDisplayLabelDefinition(rpcOptions);
-        return this._localizationHelper.getLocalizedLabelDefinition(result);
-    }
-    /** Retrieves display label definition of specific items. */
-    async getDisplayLabelDefinitions(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
-        const rpcOptions = this.toRpcTokenOptions({ ...requestOptions });
-        const result = await buildPagedArrayResponse(undefined, async (partialPageOptions) => {
-            const partialKeys = (!partialPageOptions.start) ? rpcOptions.keys : rpcOptions.keys.slice(partialPageOptions.start);
-            return this._requestsHandler.getPagedDisplayLabelDefinitions({ ...rpcOptions, keys: partialKeys });
-        });
-        return this._localizationHelper.getLocalizedLabelDefinitions(result.items);
-    }
-}
-const getDescriptorOverrides = (descriptorOrOverrides) => {
-    if (descriptorOrOverrides instanceof Descriptor)
-        return descriptorOrOverrides.createDescriptorOverrides();
-    return descriptorOrOverrides;
-};
-async function createPagedGeneratorResponse(props) {
-    let pageStart = props.page?.start ?? 0;
-    let pageSize = props.page?.size ?? 0;
-    let requestIndex = 0;
-    const firstPage = await props.get({ start: pageStart, size: pageSize }, requestIndex++);
-    return {
-        total: firstPage.total,
-        async *items() {
-            let partialResult = firstPage;
-            while (true) {
-                for (const item of partialResult.items) {
-                    yield item;
-                }
-                const receivedItemsCount = partialResult.items.length;
-                if (partialResult.total !== 0 && receivedItemsCount === 0) {
-                    if (pageStart >= partialResult.total)
-                        throw new Error(`Requested page with start index ${pageStart} is out of bounds. Total number of items: ${partialResult.total}`);
-                    throw new Error("Paged request returned non zero total count but no items");
-                }
-                if (pageSize !== 0 && receivedItemsCount >= pageSize || receivedItemsCount >= (partialResult.total - pageStart))
-                    break;
-                if (pageSize !== 0)
-                    pageSize -= receivedItemsCount;
-                pageStart += receivedItemsCount;
-                partialResult = await props.get({ start: pageStart, size: pageSize }, requestIndex++);
-            }
-        },
-    };
-}
-/** @internal */
-export const buildPagedArrayResponse = async (requestedPage, getter) => {
-    try {
-        const items = new Array();
-        const gen = await createPagedGeneratorResponse({ page: requestedPage, get: getter });
-        for await (const item of gen.items()) {
-            items.push(item);
-        }
-        return { total: gen.total, items };
-    }
-    catch {
-        // FIXME: we should propagate the error...
-        return { total: 0, items: [] };
-    }
-};
-const stripTransientElementKeys = (keys) => {
-    if (!keys.some((key) => Key.isInstanceKey(key) && key.className === TRANSIENT_ELEMENT_CLASSNAME))
-        return keys;
-    const copy = new KeySet();
-    copy.add(keys, (key) => {
-        // the callback is not going to be called with EntityProps as KeySet converts them
-        // to InstanceKeys, but we want to keep the EntityProps case for correctness
-        // istanbul ignore next
-        const isTransient = Key.isInstanceKey(key) && key.className === TRANSIENT_ELEMENT_CLASSNAME
-            || Key.isEntityProps(key) && key.classFullName === TRANSIENT_ELEMENT_CLASSNAME;
-        return !isTransient;
-    });
-    return copy;
-};
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Core
+ */
+import { BeEvent, CompressedId64Set, OrderedId64Iterable } from "@itwin/core-bentley";
+import { IModelApp, IpcApp } from "@itwin/core-frontend";
+import { Content, Descriptor, DisplayValueGroup, Item, Key, KeySet, Node, NodePathElement, PresentationIpcEvents, RpcRequestsHandler, RulesetVariable, SelectClassInfo, UpdateInfo, VariableValueTypes, } from "@itwin/presentation-common";
+import { IpcRequestsHandler } from "./IpcRequestsHandler";
+import { FrontendLocalizationHelper } from "./LocalizationHelper";
+import { RulesetManagerImpl } from "./RulesetManager";
+import { RulesetVariablesManagerImpl } from "./RulesetVariablesManager";
+import { TRANSIENT_ELEMENT_CLASSNAME } from "./selection/SelectionManager";
+import { StateTracker } from "./StateTracker";
+/**
+ * Frontend Presentation manager which basically just forwards all calls to
+ * the backend implementation.
+ *
+ * @public
+ */
+export class PresentationManager {
+    constructor(props) {
+        /**
+         * An event raised when hierarchies created using specific ruleset change
+         * @alpha
+         */
+        this.onIModelHierarchyChanged = new BeEvent();
+        /**
+         * An event raised when content created using specific ruleset changes
+         * @alpha
+         */
+        this.onIModelContentChanged = new BeEvent();
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        this.onUpdate = (_evt, report) => {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.handleUpdateAsync(UpdateInfo.fromJSON(report));
+        };
+        if (props) {
+            // eslint-disable-next-line deprecation/deprecation
+            this._explicitActiveUnitSystem = props.activeUnitSystem;
+        }
+        this._requestsHandler = props?.rpcRequestsHandler ?? new RpcRequestsHandler(props ? { clientId: props.clientId, timeout: props.requestTimeout } : undefined);
+        this._rulesetVars = new Map();
+        this._rulesets = RulesetManagerImpl.create();
+        this._localizationHelper = new FrontendLocalizationHelper(props?.activeLocale);
+        this._connections = new Map();
+        if (IpcApp.isValid) {
+            // Ipc only works in ipc apps, so the `onUpdate` callback will only be called there.
+            this._clearEventListener = IpcApp.addListener(PresentationIpcEvents.Update, this.onUpdate);
+            this._ipcRequestsHandler = props?.ipcRequestsHandler ?? new IpcRequestsHandler(this._requestsHandler.clientId);
+            this._stateTracker = props?.stateTracker ?? new StateTracker(this._ipcRequestsHandler);
+        }
+    }
+    /**
+     * Get / set active unit system used to format property values with units.
+     *
+     * @deprecated in 4.0. `IModelApp.quantityFormatter` should be used to get/set the active unit system. At the moment
+     * [[PresentationManager]] allows overriding it, but returns `IModelApp.quantityFormatter.activeUnitSystem` if override
+     * is not set.
+     */
+    get activeUnitSystem() {
+        return this._explicitActiveUnitSystem ?? IModelApp.quantityFormatter.activeUnitSystem;
+    }
+    set activeUnitSystem(value) { this._explicitActiveUnitSystem = value; }
+    /** Get / set active locale used for localizing presentation data */
+    get activeLocale() { return this._localizationHelper.locale; }
+    set activeLocale(locale) { this._localizationHelper.locale = locale; }
+    dispose() {
+        if (this._clearEventListener) {
+            this._clearEventListener();
+            this._clearEventListener = undefined;
+        }
+    }
+    async onConnection(imodel) {
+        if (!this._connections.has(imodel))
+            this._connections.set(imodel, this.initializeIModel(imodel));
+        await this._connections.get(imodel);
+    }
+    async initializeIModel(imodel) {
+        imodel.onClose.addOnce(() => {
+            this._connections.delete(imodel);
+        });
+        await this.onNewiModelConnection(imodel);
+    }
+    /** @note This is only called in native apps after changes in iModels */
+    async handleUpdateAsync(report) {
+        for (const imodelKey in report) {
+            // istanbul ignore if
+            if (!report.hasOwnProperty(imodelKey))
+                continue;
+            const imodelReport = report[imodelKey];
+            for (const rulesetId in imodelReport) {
+                // istanbul ignore if
+                if (!imodelReport.hasOwnProperty(rulesetId))
+                    continue;
+                const updateInfo = imodelReport[rulesetId];
+                if (updateInfo.content)
+                    this.onIModelContentChanged.raiseEvent({ rulesetId, updateInfo: updateInfo.content, imodelKey });
+                if (updateInfo.hierarchy)
+                    this.onIModelHierarchyChanged.raiseEvent({ rulesetId, updateInfo: updateInfo.hierarchy, imodelKey });
+            }
+        }
+    }
+    /**
+     * Function that is called when a new IModelConnection is used to retrieve data.
+     * @internal
+     */
+    async onNewiModelConnection(_) { }
+    /**
+     * Create a new PresentationManager instance
+     * @param props Optional properties used to configure the manager
+     */
+    static create(props) {
+        return new PresentationManager(props);
+    }
+    /** @internal */
+    get rpcRequestsHandler() { return this._requestsHandler; }
+    /** @internal */
+    get ipcRequestsHandler() { return this._ipcRequestsHandler; }
+    /** @internal */
+    get stateTracker() { return this._stateTracker; }
+    /**
+     * Get rulesets manager
+     */
+    rulesets() { return this._rulesets; }
+    /**
+     * Get ruleset variables manager for specific ruleset
+     * @param rulesetId Id of the ruleset to get the vars manager for
+     */
+    vars(rulesetId) {
+        if (!this._rulesetVars.has(rulesetId)) {
+            const varsManager = new RulesetVariablesManagerImpl(rulesetId, this._ipcRequestsHandler);
+            this._rulesetVars.set(rulesetId, varsManager);
+        }
+        return this._rulesetVars.get(rulesetId);
+    }
+    toRpcTokenOptions(requestOptions) {
+        // 1. put default `locale` and `unitSystem`
+        // 2. put all `requestOptions` members (if `locale` or `unitSystem` are set, they'll override the defaults put at #1)
+        // 3. put `imodel` of type `IModelRpcProps` which overwrites the `imodel` from `requestOptions` put at #2
+        const defaultOptions = {};
+        if (this.activeLocale)
+            defaultOptions.locale = this.activeLocale;
+        defaultOptions.unitSystem = this.activeUnitSystem; // eslint-disable-line deprecation/deprecation
+        const { imodel, rulesetVariables, ...rpcRequestOptions } = requestOptions;
+        return {
+            ...defaultOptions,
+            ...rpcRequestOptions,
+            ...(rulesetVariables ? { rulesetVariables: rulesetVariables.map(RulesetVariable.toJSON) } : {}),
+            imodel: imodel.getRpcProps(),
+        };
+    }
+    async addRulesetAndVariablesToOptions(options) {
+        const { rulesetOrId, rulesetVariables } = options;
+        let foundRulesetOrId;
+        if (typeof rulesetOrId === "object") {
+            foundRulesetOrId = rulesetOrId;
+        }
+        else {
+            const foundRuleset = await this._rulesets.get(rulesetOrId);
+            foundRulesetOrId = foundRuleset ? foundRuleset.toJSON() : rulesetOrId;
+        }
+        const rulesetId = (typeof foundRulesetOrId === "object") ? foundRulesetOrId.id : foundRulesetOrId;
+        // All Id64Array variable values must be sorted for serialization to JSON to work. RulesetVariablesManager
+        // sorts them before storing, so that part is taken care of, but we need to ensure that variables coming from
+        // request options are also sorted.
+        const variables = (rulesetVariables ?? []).map((variable) => {
+            if (variable.type === VariableValueTypes.Id64Array)
+                return { ...variable, value: OrderedId64Iterable.sortArray(variable.value) };
+            return variable;
+        });
+        if (!this._ipcRequestsHandler) {
+            // only need to add variables from variables manager if there's no IPC
+            // handler - if there is one, the variables are already known by the backend
+            variables.push(...this.vars(rulesetId).getAllVariables());
+        }
+        return { ...options, rulesetOrId: foundRulesetOrId, rulesetVariables: variables };
+    }
+    /** Retrieves nodes */
+    async getNodes(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({ ...options });
+        const result = await buildPagedArrayResponse(options.paging, async (partialPageOptions) => this._requestsHandler.getPagedNodes({ ...rpcOptions, paging: partialPageOptions }));
+        // eslint-disable-next-line deprecation/deprecation
+        return this._localizationHelper.getLocalizedNodes(result.items.map(Node.fromJSON));
+    }
+    /** Retrieves nodes count. */
+    async getNodesCount(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({ ...options });
+        return this._requestsHandler.getNodesCount(rpcOptions);
+    }
+    /** Retrieves total nodes count and a single page of nodes. */
+    async getNodesAndCount(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({ ...options });
+        const result = await buildPagedArrayResponse(options.paging, async (partialPageOptions) => this._requestsHandler.getPagedNodes({ ...rpcOptions, paging: partialPageOptions }));
+        return {
+            count: result.total,
+            // eslint-disable-next-line deprecation/deprecation
+            nodes: this._localizationHelper.getLocalizedNodes(result.items.map(Node.fromJSON)),
+        };
+    }
+    /**
+     * Retrieves hierarchy level descriptor.
+     * @beta
+     */
+    async getNodesDescriptor(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({ ...options });
+        const result = await this._requestsHandler.getNodesDescriptor(rpcOptions);
+        return Descriptor.fromJSON(result);
+    }
+    /** Retrieves paths from root nodes to children nodes according to specified keys. Intersecting paths will be merged. */
+    async getNodePaths(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({ ...options });
+        const result = await this._requestsHandler.getNodePaths(rpcOptions);
+        // eslint-disable-next-line deprecation/deprecation
+        return result.map(NodePathElement.fromJSON);
+    }
+    /** Retrieves paths from root nodes to nodes containing filter text in their label. */
+    async getFilteredNodePaths(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const result = await this._requestsHandler.getFilteredNodePaths(this.toRpcTokenOptions(options));
+        // eslint-disable-next-line deprecation/deprecation
+        return result.map(NodePathElement.fromJSON);
+    }
+    /**
+     * Get information about the sources of content when building it for specific ECClasses. Sources involve classes of the primary select instance,
+     * its related instances for loading related and navigation properties.
+     * @public
+     */
+    async getContentSources(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const rpcOptions = this.toRpcTokenOptions(requestOptions);
+        const result = await this._requestsHandler.getContentSources(rpcOptions);
+        return SelectClassInfo.listFromCompressedJSON(result.sources, result.classesMap);
+    }
+    /** Retrieves the content descriptor which describes the content and can be used to customize it. */
+    async getContentDescriptor(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({
+            ...options,
+            keys: stripTransientElementKeys(options.keys).toJSON(),
+        });
+        const result = await this._requestsHandler.getContentDescriptor(rpcOptions);
+        return Descriptor.fromJSON(result);
+    }
+    /** Retrieves overall content set size. */
+    async getContentSetSize(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({
+            ...options,
+            descriptor: getDescriptorOverrides(requestOptions.descriptor),
+            keys: stripTransientElementKeys(requestOptions.keys).toJSON(),
+        });
+        return this._requestsHandler.getContentSetSize(rpcOptions);
+    }
+    /** Retrieves content which consists of a content descriptor and a page of records. */
+    async getContent(requestOptions) {
+        return (await this.getContentAndSize(requestOptions))?.content;
+    }
+    /** Retrieves content set size and content which consists of a content descriptor and a page of records. */
+    async getContentAndSize(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = this.toRpcTokenOptions({
+            ...options,
+            descriptor: getDescriptorOverrides(requestOptions.descriptor),
+            keys: stripTransientElementKeys(requestOptions.keys).toJSON(),
+        });
+        let descriptor = (requestOptions.descriptor instanceof Descriptor) ? requestOptions.descriptor : undefined;
+        const result = await buildPagedArrayResponse(options.paging, async (partialPageOptions, requestIndex) => {
+            if (0 === requestIndex && !descriptor) {
+                const content = await this._requestsHandler.getPagedContent({ ...rpcOptions, paging: partialPageOptions });
+                if (content) {
+                    descriptor = Descriptor.fromJSON(content.descriptor);
+                    return content.contentSet;
+                }
+                return { total: 0, items: [] };
+            }
+            return this._requestsHandler.getPagedContentSet({ ...rpcOptions, paging: partialPageOptions });
+        });
+        if (!descriptor)
+            return undefined;
+        const items = result.items.map((itemJson) => Item.fromJSON(itemJson)).filter((item) => (item !== undefined));
+        return {
+            size: result.total,
+            content: this._localizationHelper.getLocalizedContent(new Content(descriptor, items)),
+        };
+    }
+    /** Retrieves distinct values of specific field from the content. */
+    async getPagedDistinctValues(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = {
+            ...this.toRpcTokenOptions(options),
+            descriptor: getDescriptorOverrides(options.descriptor),
+            keys: stripTransientElementKeys(options.keys).toJSON(),
+        };
+        const result = await buildPagedArrayResponse(requestOptions.paging, async (partialPageOptions) => this._requestsHandler.getPagedDistinctValues({ ...rpcOptions, paging: partialPageOptions }));
+        return {
+            ...result,
+            // eslint-disable-next-line deprecation/deprecation
+            items: result.items.map(DisplayValueGroup.fromJSON),
+        };
+    }
+    /**
+     * Retrieves property data in a simplified format for a single element specified by ID.
+     * @public
+     */
+    async getElementProperties(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const results = await this._requestsHandler.getElementProperties(this.toRpcTokenOptions(requestOptions));
+        // istanbul ignore if
+        if (!results)
+            return undefined;
+        return this._localizationHelper.getLocalizedElementProperties(results);
+    }
+    /**
+     * Retrieves content item instance keys.
+     * @public
+     */
+    async getContentInstanceKeys(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+        const rpcOptions = {
+            ...this.toRpcTokenOptions(options),
+            keys: stripTransientElementKeys(options.keys).toJSON(),
+        };
+        const props = {
+            page: requestOptions.paging,
+            get: async (page) => {
+                const keys = await this._requestsHandler.getContentInstanceKeys({ ...rpcOptions, paging: page });
+                return {
+                    total: keys.total,
+                    items: keys.items.instanceKeys.reduce((instanceKeys, entry) => {
+                        for (const id of CompressedId64Set.iterable(entry[1])) {
+                            instanceKeys.push({ className: entry[0], id });
+                        }
+                        return instanceKeys;
+                    }, new Array()),
+                };
+            },
+        };
+        return createPagedGeneratorResponse(props);
+    }
+    /** Retrieves display label definition of specific item. */
+    async getDisplayLabelDefinition(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const rpcOptions = this.toRpcTokenOptions({ ...requestOptions });
+        const result = await this._requestsHandler.getDisplayLabelDefinition(rpcOptions);
+        return this._localizationHelper.getLocalizedLabelDefinition(result);
+    }
+    /** Retrieves display label definition of specific items. */
+    async getDisplayLabelDefinitions(requestOptions) {
+        await this.onConnection(requestOptions.imodel);
+        const rpcOptions = this.toRpcTokenOptions({ ...requestOptions });
+        const result = await buildPagedArrayResponse(undefined, async (partialPageOptions) => {
+            const partialKeys = (!partialPageOptions.start) ? rpcOptions.keys : rpcOptions.keys.slice(partialPageOptions.start);
+            return this._requestsHandler.getPagedDisplayLabelDefinitions({ ...rpcOptions, keys: partialKeys });
+        });
+        return this._localizationHelper.getLocalizedLabelDefinitions(result.items);
+    }
+}
+const getDescriptorOverrides = (descriptorOrOverrides) => {
+    if (descriptorOrOverrides instanceof Descriptor)
+        return descriptorOrOverrides.createDescriptorOverrides();
+    return descriptorOrOverrides;
+};
+async function createPagedGeneratorResponse(props) {
+    let pageStart = props.page?.start ?? 0;
+    let pageSize = props.page?.size ?? 0;
+    let requestIndex = 0;
+    const firstPage = await props.get({ start: pageStart, size: pageSize }, requestIndex++);
+    return {
+        total: firstPage.total,
+        async *items() {
+            let partialResult = firstPage;
+            while (true) {
+                for (const item of partialResult.items) {
+                    yield item;
+                }
+                const receivedItemsCount = partialResult.items.length;
+                if (partialResult.total !== 0 && receivedItemsCount === 0) {
+                    if (pageStart >= partialResult.total)
+                        throw new Error(`Requested page with start index ${pageStart} is out of bounds. Total number of items: ${partialResult.total}`);
+                    throw new Error("Paged request returned non zero total count but no items");
+                }
+                if (pageSize !== 0 && receivedItemsCount >= pageSize || receivedItemsCount >= (partialResult.total - pageStart))
+                    break;
+                if (pageSize !== 0)
+                    pageSize -= receivedItemsCount;
+                pageStart += receivedItemsCount;
+                partialResult = await props.get({ start: pageStart, size: pageSize }, requestIndex++);
+            }
+        },
+    };
+}
+/** @internal */
+export const buildPagedArrayResponse = async (requestedPage, getter) => {
+    const items = new Array();
+    const gen = await createPagedGeneratorResponse({ page: requestedPage, get: getter });
+    for await (const item of gen.items()) {
+        items.push(item);
+    }
+    return { total: gen.total, items };
+};
+const stripTransientElementKeys = (keys) => {
+    if (!keys.some((key) => Key.isInstanceKey(key) && key.className === TRANSIENT_ELEMENT_CLASSNAME))
+        return keys;
+    const copy = new KeySet();
+    copy.add(keys, (key) => {
+        // the callback is not going to be called with EntityProps as KeySet converts them
+        // to InstanceKeys, but we want to keep the EntityProps case for correctness
+        // istanbul ignore next
+        const isTransient = Key.isInstanceKey(key) && key.className === TRANSIENT_ELEMENT_CLASSNAME
+            || Key.isEntityProps(key) && key.classFullName === TRANSIENT_ELEMENT_CLASSNAME;
+        return !isTransient;
+    });
+    return copy;
+};
 //# sourceMappingURL=PresentationManager.js.map