@itwin/presentation-backend 3.0.0-dev.100

package/lib/cjs/presentation-backend/PresentationManager.js

@@ -0,0 +1,635 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeysForContentRequest = exports.PresentationManager = exports.HierarchyCacheMode = exports.PresentationManagerMode = void 0;
+const hash = __importStar(require("object-hash"));
+const path = __importStar(require("path"));
+const core_backend_1 = require("@itwin/core-backend");
+const presentation_common_1 = require("@itwin/presentation-common");
+const Constants_1 = require("./Constants");
+const ElementPropertiesHelper_1 = require("./ElementPropertiesHelper");
+const NativePlatform_1 = require("./NativePlatform");
+const RulesetManager_1 = require("./RulesetManager");
+const RulesetVariablesManager_1 = require("./RulesetVariablesManager");
+const SelectionScopesHelper_1 = require("./SelectionScopesHelper");
+const UpdatesTracker_1 = require("./UpdatesTracker");
+const Utils_1 = require("./Utils");
+/**
+ * Presentation manager working mode.
+ * @public
+ */
+var PresentationManagerMode;
+(function (PresentationManagerMode) {
+    /**
+     * Presentation manager assumes iModels are opened in read-only mode and avoids doing some work
+     * related to reacting to changes in iModels.
+     */
+    PresentationManagerMode[PresentationManagerMode["ReadOnly"] = 0] = "ReadOnly";
+    /**
+     * Presentation manager assumes iModels are opened in read-write mode and it may need to
+     * react to changes. This involves some additional work and gives slightly worse performance.
+     */
+    PresentationManagerMode[PresentationManagerMode["ReadWrite"] = 1] = "ReadWrite";
+})(PresentationManagerMode = exports.PresentationManagerMode || (exports.PresentationManagerMode = {}));
+/**
+ * Presentation hierarchy cache mode.
+ * @beta
+ */
+var HierarchyCacheMode;
+(function (HierarchyCacheMode) {
+    /**
+     * Hierarchy cache is created in memory.
+     */
+    HierarchyCacheMode["Memory"] = "memory";
+    /**
+     * Hierarchy cache is created on disk. In this mode hierarchy cache is persisted between iModel
+     * openings.
+     */
+    HierarchyCacheMode["Disk"] = "disk";
+    /**
+     * Hierarchy cache is created on disk. In this mode everything is cached in memory while creating hierarchy level
+     * and persisted in disk cache when whole hierarchy level is created.
+     */
+    HierarchyCacheMode["Hybrid"] = "hybrid";
+})(HierarchyCacheMode = exports.HierarchyCacheMode || (exports.HierarchyCacheMode = {}));
+/**
+ * Backend Presentation manager which pulls the presentation data from
+ * an iModel using native platform.
+ *
+ * @public
+ */
+class PresentationManager {
+    /**
+     * Creates an instance of PresentationManager.
+     * @param props Optional configuration properties.
+     */
+    constructor(props) {
+        var _a, _b, _c, _d, _e;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        this.onIModelOpened = (imodel) => {
+            const imodelAddon = this.getNativePlatform().getImodelAddon(imodel);
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.getNativePlatform().forceLoadSchemas(imodelAddon);
+        };
+        /** @internal */
+        this.getNativePlatform = () => {
+            if (this._isDisposed)
+                throw new presentation_common_1.PresentationError(presentation_common_1.PresentationStatus.NotInitialized, "Attempting to use Presentation manager after disposal");
+            return this._nativePlatform;
+        };
+        this._props = props !== null && props !== void 0 ? props : {};
+        this._isDisposed = false;
+        const mode = (_a = props === null || props === void 0 ? void 0 : props.mode) !== null && _a !== void 0 ? _a : PresentationManagerMode.ReadWrite;
+        const isChangeTrackingEnabled = (mode === PresentationManagerMode.ReadWrite && !!(props === null || props === void 0 ? void 0 : props.updatesPollInterval));
+        if (props && props.addon) {
+            this._nativePlatform = props.addon;
+        }
+        else {
+            const nativePlatformImpl = (0, NativePlatform_1.createDefaultNativePlatform)({
+                id: (_b = this._props.id) !== null && _b !== void 0 ? _b : "",
+                localeDirectories: createLocaleDirectoryList(props),
+                taskAllocationsMap: createTaskAllocationsMap(props),
+                mode,
+                isChangeTrackingEnabled,
+                cacheConfig: createCacheConfig((_c = this._props.caching) === null || _c === void 0 ? void 0 : _c.hierarchies),
+                contentCacheSize: (_e = (_d = this._props.caching) === null || _d === void 0 ? void 0 : _d.content) === null || _e === void 0 ? void 0 : _e.size,
+                defaultFormats: toNativeUnitFormatsMap(this._props.defaultFormats),
+                useMmap: this._props.useMmap,
+            });
+            this._nativePlatform = new nativePlatformImpl();
+        }
+        this.setupRulesetDirectories(props);
+        if (props) {
+            this.activeLocale = props.defaultLocale;
+            this.activeUnitSystem = props.defaultUnitSystem;
+        }
+        this._rulesets = new RulesetManager_1.RulesetManagerImpl(this.getNativePlatform);
+        if (this._props.enableSchemasPreload)
+            this._disposeIModelOpenedListener = core_backend_1.BriefcaseDb.onOpened.addListener(this.onIModelOpened);
+        if (core_backend_1.IpcHost.isValid && isChangeTrackingEnabled) {
+            this._updatesTracker = UpdatesTracker_1.UpdatesTracker.create({
+                nativePlatformGetter: this.getNativePlatform,
+                pollInterval: props.updatesPollInterval,
+            });
+        }
+    }
+    /**
+     * Dispose the presentation manager. Must be called to clean up native resources.
+     */
+    dispose() {
+        if (this._nativePlatform) {
+            this.getNativePlatform().dispose();
+            this._nativePlatform = undefined;
+        }
+        if (this._disposeIModelOpenedListener)
+            this._disposeIModelOpenedListener();
+        if (this._updatesTracker) {
+            this._updatesTracker.dispose();
+            this._updatesTracker = undefined;
+        }
+        this._isDisposed = true;
+    }
+    /** Properties used to initialize the manager */
+    get props() { return this._props; }
+    /**
+     * Get rulesets manager
+     */
+    rulesets() { return this._rulesets; }
+    /**
+     * Get ruleset variables manager for specific ruleset
+     * @param rulesetId Id of the ruleset to get variables manager for
+     */
+    vars(rulesetId) {
+        return new RulesetVariablesManager_1.RulesetVariablesManagerImpl(this.getNativePlatform, rulesetId);
+    }
+    setupRulesetDirectories(props) {
+        const supplementalRulesetDirectories = [path.join(getPresentationBackendAssetsRoot(props === null || props === void 0 ? void 0 : props.presentationAssetsRoot), "supplemental-presentation-rules")];
+        if (props && props.supplementalRulesetDirectories) {
+            props.supplementalRulesetDirectories.forEach((dir) => {
+                if (-1 === supplementalRulesetDirectories.indexOf(dir))
+                    supplementalRulesetDirectories.push(dir);
+            });
+        }
+        this.getNativePlatform().setupSupplementalRulesetDirectories(supplementalRulesetDirectories);
+        const primaryRulesetDirectories = [path.join(getPresentationBackendAssetsRoot(props === null || props === void 0 ? void 0 : props.presentationAssetsRoot), "primary-presentation-rules")];
+        if (props && props.rulesetDirectories) {
+            props.rulesetDirectories.forEach((dir) => {
+                if (-1 === primaryRulesetDirectories.indexOf(dir))
+                    primaryRulesetDirectories.push(dir);
+            });
+        }
+        this.getNativePlatform().setupRulesetDirectories(primaryRulesetDirectories);
+    }
+    getRulesetIdObject(rulesetOrId) {
+        if (typeof rulesetOrId === "object") {
+            const hashedId = hash.MD5(rulesetOrId);
+            return {
+                uniqueId: `${rulesetOrId.id}-${hashedId}`,
+                parts: {
+                    id: rulesetOrId.id,
+                    hash: hashedId,
+                },
+            };
+        }
+        return { uniqueId: rulesetOrId, parts: { id: rulesetOrId } };
+    }
+    /** @internal */
+    getRulesetId(rulesetOrId) {
+        return this.getRulesetIdObject(rulesetOrId).uniqueId;
+    }
+    ensureRulesetRegistered(rulesetOrId) {
+        if (typeof rulesetOrId === "object") {
+            const rulesetWithNativeId = { ...rulesetOrId, id: this.getRulesetId(rulesetOrId) };
+            return this.rulesets().add(rulesetWithNativeId).id;
+        }
+        return rulesetOrId;
+    }
+    /** Registers given ruleset and replaces the ruleset with its ID in the resulting object */
+    registerRuleset(options) {
+        const { rulesetOrId, ...strippedOptions } = options;
+        const registeredRulesetId = this.ensureRulesetRegistered(rulesetOrId);
+        return { rulesetId: registeredRulesetId, strippedOptions };
+    }
+    /**
+     * Retrieves nodes
+     * @public
+     */
+    async getNodes(requestOptions) {
+        const { rulesetId, strippedOptions: { parentKey, ...strippedOptions } } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: parentKey ? NativePlatform_1.NativePlatformRequestTypes.GetChildren : NativePlatform_1.NativePlatformRequestTypes.GetRootNodes,
+            rulesetId,
+            ...strippedOptions,
+            nodeKey: parentKey,
+        };
+        return this.request(params, presentation_common_1.Node.listReviver);
+    }
+    /**
+     * Retrieves nodes count
+     * @public
+     */
+    async getNodesCount(requestOptions) {
+        const { rulesetId, strippedOptions: { parentKey, ...strippedOptions } } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: parentKey ? NativePlatform_1.NativePlatformRequestTypes.GetChildrenCount : NativePlatform_1.NativePlatformRequestTypes.GetRootNodesCount,
+            rulesetId,
+            ...strippedOptions,
+            nodeKey: parentKey,
+        };
+        return this.request(params);
+    }
+    /**
+     * Retrieves paths from root nodes to children nodes according to specified instance key paths. Intersecting paths will be merged.
+     * TODO: Return results in pages
+     * @public
+     */
+    async getNodePaths(requestOptions) {
+        const { rulesetId, strippedOptions: { instancePaths, ...strippedOptions } } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetNodePaths,
+            rulesetId,
+            ...strippedOptions,
+            paths: instancePaths.map((p) => p.map((s) => presentation_common_1.InstanceKey.toJSON(s))),
+        };
+        return this.request(params, presentation_common_1.NodePathElement.listReviver);
+    }
+    /**
+     * Retrieves paths from root nodes to nodes containing filter text in their label.
+     * TODO: Return results in pages
+     * @public
+     */
+    async getFilteredNodePaths(requestOptions) {
+        const { rulesetId, strippedOptions } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetFilteredNodePaths,
+            rulesetId,
+            ...strippedOptions,
+        };
+        return this.request(params, presentation_common_1.NodePathElement.listReviver);
+    }
+    /** @beta */
+    async getContentSources(requestOptions) {
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetContentSources,
+            rulesetId: "ElementProperties",
+            ...requestOptions,
+        };
+        const reviver = (key, value) => {
+            return key === "" ? presentation_common_1.SelectClassInfo.listFromCompressedJSON(value.sources, value.classesMap) : value;
+        };
+        return this.request(params, reviver);
+    }
+    /**
+     * Retrieves the content descriptor which can be used to get content
+     * @public
+     */
+    async getContentDescriptor(requestOptions) {
+        const { rulesetId, strippedOptions } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetContentDescriptor,
+            rulesetId,
+            ...strippedOptions,
+            keys: getKeysForContentRequest(requestOptions.keys, (map) => bisElementInstanceKeysProcessor(requestOptions.imodel, map)),
+        };
+        const reviver = (key, value) => {
+            return key === "" ? presentation_common_1.Descriptor.fromJSON(value) : value;
+        };
+        return this.request(params, reviver);
+    }
+    /**
+     * Retrieves the content set size based on the supplied content descriptor override
+     * @public
+     */
+    async getContentSetSize(requestOptions) {
+        const { rulesetId, strippedOptions: { descriptor, ...strippedOptions } } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetContentSetSize,
+            rulesetId,
+            ...strippedOptions,
+            keys: getKeysForContentRequest(requestOptions.keys, (map) => bisElementInstanceKeysProcessor(requestOptions.imodel, map)),
+            descriptorOverrides: createContentDescriptorOverrides(descriptor),
+        };
+        return this.request(params);
+    }
+    /**
+     * Retrieves the content based on the supplied content descriptor override.
+     * @public
+     */
+    async getContent(requestOptions) {
+        const { rulesetId, strippedOptions: { descriptor, ...strippedOptions } } = this.registerRuleset(requestOptions);
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetContent,
+            rulesetId,
+            ...strippedOptions,
+            keys: getKeysForContentRequest(requestOptions.keys, (map) => bisElementInstanceKeysProcessor(requestOptions.imodel, map)),
+            descriptorOverrides: createContentDescriptorOverrides(descriptor),
+        };
+        return this.request(params, presentation_common_1.Content.reviver);
+    }
+    /**
+     * Retrieves distinct values of specific field from the content based on the supplied content descriptor override.
+     * @param requestOptions      Options for the request
+     * @return A promise object that returns either distinct values on success or an error string on error.
+     * @public
+     */
+    async getPagedDistinctValues(requestOptions) {
+        const { rulesetId, strippedOptions } = this.registerRuleset(requestOptions);
+        const { descriptor, keys, ...strippedOptionsNoDescriptorAndKeys } = strippedOptions;
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetPagedDistinctValues,
+            rulesetId,
+            ...strippedOptionsNoDescriptorAndKeys,
+            keys: getKeysForContentRequest(keys, (map) => bisElementInstanceKeysProcessor(requestOptions.imodel, map)),
+            descriptorOverrides: createContentDescriptorOverrides(descriptor),
+        };
+        const reviver = (key, value) => {
+            return key === "" ? {
+                total: value.total,
+                items: value.items.map(presentation_common_1.DisplayValueGroup.fromJSON),
+            } : value;
+        };
+        return this.request(params, reviver);
+    }
+    async getElementProperties(requestOptions) {
+        if ((0, presentation_common_1.isSingleElementPropertiesRequestOptions)(requestOptions)) {
+            const { elementId, ...optionsNoElementId } = requestOptions;
+            const content = await this.getContent({
+                ...optionsNoElementId,
+                descriptor: {
+                    displayType: presentation_common_1.DefaultContentDisplayTypes.PropertyPane,
+                    contentFlags: presentation_common_1.ContentFlags.ShowLabels,
+                },
+                rulesetOrId: "ElementProperties",
+                keys: new presentation_common_1.KeySet([{ className: "BisCore:Element", id: elementId }]),
+            });
+            const properties = (0, ElementPropertiesHelper_1.buildElementsProperties)(content);
+            return properties[0];
+        }
+        return this.getMultipleElementProperties(requestOptions);
+    }
+    async getMultipleElementProperties(requestOptions) {
+        const { elementClasses, paging, ...optionsNoElementClasses } = requestOptions;
+        const elementsCount = (0, ElementPropertiesHelper_1.getElementsCount)(requestOptions.imodel, requestOptions.elementClasses);
+        const elementIds = (0, ElementPropertiesHelper_1.getElementIdsByClass)(requestOptions.imodel, elementClasses, paging);
+        const elementProperties = [];
+        for (const entry of elementIds) {
+            const properties = await buildElementsPropertiesInPages(entry[0], entry[1], async (keys) => {
+                const content = await this.getContent({
+                    ...optionsNoElementClasses,
+                    descriptor: {
+                        displayType: presentation_common_1.DefaultContentDisplayTypes.PropertyPane,
+                        contentFlags: presentation_common_1.ContentFlags.ShowLabels,
+                    },
+                    rulesetOrId: "ElementProperties",
+                    keys,
+                });
+                return (0, ElementPropertiesHelper_1.buildElementsProperties)(content);
+            });
+            elementProperties.push(...properties);
+        }
+        return { total: elementsCount, items: elementProperties };
+    }
+    /**
+     * Retrieves display label definition of specific item
+     * @public
+     */
+    async getDisplayLabelDefinition(requestOptions) {
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.GetDisplayLabel,
+            ...requestOptions,
+            key: presentation_common_1.InstanceKey.toJSON(requestOptions.key),
+        };
+        return this.request(params, presentation_common_1.LabelDefinition.reviver);
+    }
+    /**
+     * Retrieves display label definitions of specific items
+     * @public
+     */
+    async getDisplayLabelDefinitions(requestOptions) {
+        const concreteKeys = requestOptions.keys.map((k) => {
+            if (k.className === "BisCore:Element")
+                return (0, Utils_1.getElementKey)(requestOptions.imodel, k.id);
+            return k;
+        }).filter((k) => !!k);
+        const contentRequestOptions = {
+            ...requestOptions,
+            rulesetOrId: "RulesDrivenECPresentationManager_RulesetId_DisplayLabel",
+            descriptor: {
+                displayType: presentation_common_1.DefaultContentDisplayTypes.List,
+                contentFlags: presentation_common_1.ContentFlags.ShowLabels | presentation_common_1.ContentFlags.NoFields,
+            },
+            keys: new presentation_common_1.KeySet(concreteKeys),
+        };
+        const content = await this.getContent(contentRequestOptions);
+        return concreteKeys.map((key) => {
+            const item = content ? content.contentSet.find((it) => it.primaryKeys.length > 0 && presentation_common_1.InstanceKey.compare(it.primaryKeys[0], key) === 0) : undefined;
+            if (!item)
+                return { displayValue: "", rawValue: "", typeName: "" };
+            return item.label;
+        });
+    }
+    /**
+     * Retrieves available selection scopes.
+     * @public
+     */
+    async getSelectionScopes(_requestOptions) {
+        return SelectionScopesHelper_1.SelectionScopesHelper.getSelectionScopes();
+    }
+    /**
+     * Computes selection set based on provided selection scope.
+     * @public
+     */
+    async computeSelection(requestOptions) {
+        const { ids, scopeId, ...opts } = requestOptions; // eslint-disable-line @typescript-eslint/no-unused-vars
+        return SelectionScopesHelper_1.SelectionScopesHelper.computeSelection(opts, ids, scopeId);
+    }
+    async request(params, reviver) {
+        const { requestId, imodel, locale, unitSystem, diagnostics, ...strippedParams } = params;
+        const imodelAddon = this.getNativePlatform().getImodelAddon(imodel);
+        const nativeRequestParams = {
+            requestId,
+            params: {
+                locale: normalizeLocale(locale !== null && locale !== void 0 ? locale : this.activeLocale),
+                unitSystem: toOptionalNativeUnitSystem(unitSystem !== null && unitSystem !== void 0 ? unitSystem : this.activeUnitSystem),
+                ...strippedParams,
+            },
+        };
+        let diagnosticsListener;
+        if (diagnostics) {
+            const { handler: tempDiagnosticsListener, ...diagnosticsOptions } = diagnostics;
+            diagnosticsListener = tempDiagnosticsListener;
+            nativeRequestParams.params.diagnostics = diagnosticsOptions;
+        }
+        const response = await this.getNativePlatform().handleRequest(imodelAddon, JSON.stringify(nativeRequestParams));
+        diagnosticsListener && response.diagnostics && diagnosticsListener([response.diagnostics]);
+        return JSON.parse(response.result, reviver);
+    }
+    /**
+     * Compares two hierarchies specified in the request options
+     * @public
+     */
+    async compareHierarchies(requestOptions) {
+        var _a, _b;
+        if (!requestOptions.prev.rulesetOrId && !requestOptions.prev.rulesetVariables)
+            return { changes: [] };
+        const { strippedOptions: { prev, rulesetVariables, ...options } } = this.registerRuleset(requestOptions);
+        const currRulesetId = this.getRulesetIdObject(requestOptions.rulesetOrId);
+        const prevRulesetId = prev.rulesetOrId ? this.getRulesetIdObject(prev.rulesetOrId) : currRulesetId;
+        if (prevRulesetId.parts.id !== currRulesetId.parts.id)
+            throw new presentation_common_1.PresentationError(presentation_common_1.PresentationStatus.InvalidArgument, "Can't compare rulesets with different IDs");
+        const currRulesetVariables = rulesetVariables !== null && rulesetVariables !== void 0 ? rulesetVariables : [];
+        const prevRulesetVariables = (_a = prev.rulesetVariables) !== null && _a !== void 0 ? _a : currRulesetVariables;
+        const params = {
+            requestId: NativePlatform_1.NativePlatformRequestTypes.CompareHierarchies,
+            ...options,
+            prevRulesetId: prevRulesetId.uniqueId,
+            currRulesetId: currRulesetId.uniqueId,
+            prevRulesetVariables: JSON.stringify(prevRulesetVariables),
+            currRulesetVariables: JSON.stringify(currRulesetVariables),
+            expandedNodeKeys: JSON.stringify((_b = options.expandedNodeKeys) !== null && _b !== void 0 ? _b : []),
+        };
+        return this.request(params, (key, value) => ((key === "") ? presentation_common_1.HierarchyCompareInfo.fromJSON(value) : value));
+    }
+}
+exports.PresentationManager = PresentationManager;
+function addInstanceKey(classInstancesMap, key) {
+    let set = classInstancesMap.get(key.className);
+    // istanbul ignore else
+    if (!set) {
+        set = new Set();
+        classInstancesMap.set(key.className, set);
+    }
+    set.add(key.id);
+}
+function bisElementInstanceKeysProcessor(imodel, classInstancesMap) {
+    const elementClassName = "BisCore:Element";
+    const elementIds = classInstancesMap.get(elementClassName);
+    if (elementIds) {
+        const deleteElementIds = new Array();
+        elementIds.forEach((elementId) => {
+            const concreteKey = (0, Utils_1.getElementKey)(imodel, elementId);
+            if (concreteKey && concreteKey.className !== elementClassName) {
+                deleteElementIds.push(elementId);
+                addInstanceKey(classInstancesMap, { className: concreteKey.className, id: elementId });
+            }
+        });
+        for (const id of deleteElementIds)
+            elementIds.delete(id);
+    }
+}
+/** @internal */
+function getKeysForContentRequest(keys, classInstanceKeysProcessor) {
+    const result = {
+        instanceKeys: [],
+        nodeKeys: [],
+    };
+    const classInstancesMap = new Map();
+    keys.forEach((key) => {
+        if (presentation_common_1.Key.isNodeKey(key))
+            result.nodeKeys.push(key);
+        if (presentation_common_1.Key.isInstanceKey(key))
+            addInstanceKey(classInstancesMap, key);
+    });
+    if (classInstanceKeysProcessor)
+        classInstanceKeysProcessor(classInstancesMap);
+    for (const entry of classInstancesMap) {
+        if (entry[1].size > 0)
+            result.instanceKeys.push([entry["0"], [...entry[1]]]);
+    }
+    return result;
+}
+exports.getKeysForContentRequest = getKeysForContentRequest;
+const createContentDescriptorOverrides = (descriptorOrOverrides) => {
+    if (descriptorOrOverrides instanceof presentation_common_1.Descriptor)
+        return descriptorOrOverrides.createDescriptorOverrides();
+    return descriptorOrOverrides;
+};
+const createLocaleDirectoryList = (props) => {
+    const localeDirectories = [(0, presentation_common_1.getLocalesDirectory)(getPresentationCommonAssetsRoot(props === null || props === void 0 ? void 0 : props.presentationAssetsRoot))];
+    if (props && props.localeDirectories) {
+        props.localeDirectories.forEach((dir) => {
+            if (-1 === localeDirectories.indexOf(dir))
+                localeDirectories.push(dir);
+        });
+    }
+    return localeDirectories;
+};
+const createTaskAllocationsMap = (props) => {
+    var _a;
+    const count = (_a = props === null || props === void 0 ? void 0 : props.workerThreadsCount) !== null && _a !== void 0 ? _a : 2;
+    return {
+        [Number.MAX_SAFE_INTEGER]: count,
+    };
+};
+const normalizeLocale = (locale) => {
+    if (!locale)
+        return undefined;
+    return locale.toLocaleLowerCase();
+};
+const normalizeDirectory = (directory) => {
+    return directory ? path.resolve(directory) : "";
+};
+const toNativeUnitSystem = (unitSystem) => {
+    switch (unitSystem) {
+        case "imperial": return NativePlatform_1.NativePresentationUnitSystem.BritishImperial;
+        case "metric": return NativePlatform_1.NativePresentationUnitSystem.Metric;
+        case "usCustomary": return NativePlatform_1.NativePresentationUnitSystem.UsCustomary;
+        case "usSurvey": return NativePlatform_1.NativePresentationUnitSystem.UsSurvey;
+    }
+};
+const toOptionalNativeUnitSystem = (unitSystem) => {
+    return unitSystem ? toNativeUnitSystem(unitSystem) : undefined;
+};
+const toNativeUnitFormatsMap = (map) => {
+    if (!map)
+        return undefined;
+    const nativeFormatsMap = {};
+    Object.keys(map).forEach((phenomenon) => {
+        const unitSystemsFormat = map[phenomenon];
+        nativeFormatsMap[phenomenon] = {
+            unitSystems: unitSystemsFormat.unitSystems.map(toNativeUnitSystem),
+            format: unitSystemsFormat.format,
+        };
+    });
+    return nativeFormatsMap;
+};
+const createCacheConfig = (config) => {
+    if ((config === null || config === void 0 ? void 0 : config.mode) === HierarchyCacheMode.Disk)
+        return { ...config, directory: normalizeDirectory(config.directory) };
+    if ((config === null || config === void 0 ? void 0 : config.mode) === HierarchyCacheMode.Hybrid)
+        return { ...config, disk: config.disk ? { ...config.disk, directory: normalizeDirectory(config.disk.directory) } : undefined };
+    if ((config === null || config === void 0 ? void 0 : config.mode) === HierarchyCacheMode.Memory)
+        return config;
+    return { mode: HierarchyCacheMode.Disk, directory: "" };
+};
+const getPresentationBackendAssetsRoot = (ovr) => {
+    if (typeof ovr === "string")
+        return ovr;
+    if (typeof ovr === "object")
+        return ovr.backend;
+    return Constants_1.PRESENTATION_BACKEND_ASSETS_ROOT;
+};
+const getPresentationCommonAssetsRoot = (ovr) => {
+    if (typeof ovr === "string")
+        return ovr;
+    if (typeof ovr === "object")
+        return ovr.common;
+    return Constants_1.PRESENTATION_COMMON_ASSETS_ROOT;
+};
+const ELEMENT_PROPERTIES_CONTENT_BATCH_SIZE = 100;
+async function buildElementsPropertiesInPages(className, ids, getter) {
+    const elementProperties = [];
+    const elementIds = [...ids];
+    while (elementIds.length > 0) {
+        const idsPage = elementIds.splice(0, ELEMENT_PROPERTIES_CONTENT_BATCH_SIZE);
+        const keys = new presentation_common_1.KeySet(idsPage.map((id) => ({ id, className })));
+        elementProperties.push(...(await getter(keys)));
+    }
+    return elementProperties;
+}
+//# sourceMappingURL=PresentationManager.js.map