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

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

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------------------------------------------
-* 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 Core
  */
@@ -13,6 +13,7 @@ import { FrontendLocalizationHelper } from "./LocalizationHelper";
 import { RulesetManagerImpl } from "./RulesetManager";
 import { RulesetVariablesManagerImpl } from "./RulesetVariablesManager";
 import { TRANSIENT_ELEMENT_CLASSNAME } from "./selection/SelectionManager";
+import { StreamedResponseGenerator } from "./StreamedResponseGenerator";
 /**
  * Frontend Presentation manager which basically just forwards all calls to
  * the backend implementation.
@@ -30,7 +31,9 @@ export class PresentationManager {
     get activeUnitSystem() {
         return this._explicitActiveUnitSystem ?? IModelApp.quantityFormatter.activeUnitSystem;
     }
-    set activeUnitSystem(value) { this._explicitActiveUnitSystem = value; }
+    set activeUnitSystem(value) {
+        this._explicitActiveUnitSystem = value;
+    }
     constructor(props) {
         /**
          * An event raised when hierarchies created using specific ruleset change
@@ -51,11 +54,11 @@ export class PresentationManager {
             // 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._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();
         this._schemaContextProvider = props?.schemaContextProvider;
         this._defaultFormats = props?.defaultFormats;
         if (IpcApp.isValid) {
@@ -65,41 +68,38 @@ export class PresentationManager {
         }
     }
     /** Get / set active locale used for localizing presentation data */
-    get activeLocale() { return this._localizationHelper.locale; }
-    set activeLocale(locale) { this._localizationHelper.locale = locale; }
+    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))
+            if (!report.hasOwnProperty(imodelKey)) {
                 continue;
+            }
             const imodelReport = report[imodelKey];
             for (const rulesetId in imodelReport) {
                 // istanbul ignore if
-                if (!imodelReport.hasOwnProperty(rulesetId))
+                if (!imodelReport.hasOwnProperty(rulesetId)) {
                     continue;
+                }
                 const updateInfo = imodelReport[rulesetId];
-                if (updateInfo.content)
+                if (updateInfo.content) {
                     this.onIModelContentChanged.raiseEvent({ rulesetId, updateInfo: updateInfo.content, imodelKey });
-                if (updateInfo.hierarchy)
+                }
+                if (updateInfo.hierarchy) {
                     this.onIModelHierarchyChanged.raiseEvent({ rulesetId, updateInfo: updateInfo.hierarchy, imodelKey });
+                }
             }
         }
     }
@@ -107,7 +107,13 @@ export class PresentationManager {
      * Function that is called when a new IModelConnection is used to retrieve data.
      * @internal
      */
-    async onNewiModelConnection(_) { }
+    startIModelInitialization(_) { }
+    /**
+     * Function that should be called to finish initialization that was started at [[PresentationManager.startIModelInitialization]].
+     * Can be removed when [[FavoritePropertiesManager.has]] and [[FavoritePropertiesManager.sortFields]] are removed.
+     * @internal
+     */
+    async ensureIModelInitialized(_) { }
     /**
      * Create a new PresentationManager instance
      * @param props Optional properties used to configure the manager
@@ -116,13 +122,19 @@ export class PresentationManager {
         return new PresentationManager(props);
     }
     /** @internal */
-    get rpcRequestsHandler() { return this._requestsHandler; }
+    get rpcRequestsHandler() {
+        return this._requestsHandler;
+    }
     /** @internal */
-    get ipcRequestsHandler() { return this._ipcRequestsHandler; }
+    get ipcRequestsHandler() {
+        return this._ipcRequestsHandler;
+    }
     /**
      * Get rulesets manager
      */
-    rulesets() { return this._rulesets; }
+    rulesets() {
+        return this._rulesets;
+    }
     /**
      * Get ruleset variables manager for specific ruleset
      * @param rulesetId Id of the ruleset to get the vars manager for
@@ -139,8 +151,9 @@ export class PresentationManager {
         // 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)
+        if (this.activeLocale) {
             defaultOptions.locale = this.activeLocale;
+        }
         defaultOptions.unitSystem = this.activeUnitSystem; // eslint-disable-line deprecation/deprecation
         const { imodel, rulesetVariables, ...rpcRequestOptions } = requestOptions;
         return {
@@ -160,13 +173,14 @@ export class PresentationManager {
             const foundRuleset = await this._rulesets.get(rulesetOrId);
             foundRulesetOrId = foundRuleset ? foundRuleset.toJSON() : rulesetOrId;
         }
-        const rulesetId = (typeof foundRulesetOrId === "object") ? foundRulesetOrId.id : foundRulesetOrId;
+        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)
+            if (variable.type === VariableValueTypes.Id64Array) {
                 return { ...variable, value: OrderedId64Iterable.sortArray(variable.value) };
+            }
             return variable;
         });
         if (!this._ipcRequestsHandler) {
@@ -176,32 +190,48 @@ export class PresentationManager {
         }
         return { ...options, rulesetOrId: foundRulesetOrId, rulesetVariables: variables };
     }
-    /** Retrieves nodes */
-    async getNodes(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+    /** Returns an iterator that polls nodes asynchronously. */
+    async getNodesIterator(requestOptions) {
+        this.startIModelInitialization(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));
+        const generator = new StreamedResponseGenerator({
+            ...requestOptions,
+            getBatch: async (paging) => {
+                const result = await this._requestsHandler.getPagedNodes({ ...rpcOptions, paging });
+                return {
+                    total: result.total,
+                    // eslint-disable-next-line deprecation/deprecation
+                    items: this._localizationHelper.getLocalizedNodes(result.items.map(Node.fromJSON)),
+                };
+            },
+        });
+        return generator.createAsyncIteratorResponse();
+    }
+    /**
+     * Retrieves nodes
+     * @deprecated in 4.5. Use [[getNodesIterator]] instead.
+     */
+    async getNodes(requestOptions) {
+        const result = await this.getNodesIterator(requestOptions);
+        return collect(result.items);
     }
     /** Retrieves nodes count. */
     async getNodesCount(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(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. */
+    /**
+     * Retrieves total nodes count and a single page of nodes.
+     * @deprecated in 4.5. Use [[getNodesIterator]] instead.
+     */
     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 }));
+        const result = await this.getNodesIterator(requestOptions);
         return {
             count: result.total,
-            // eslint-disable-next-line deprecation/deprecation
-            nodes: this._localizationHelper.getLocalizedNodes(result.items.map(Node.fromJSON)),
+            nodes: await collect(result.items),
         };
     }
     /**
@@ -209,16 +239,21 @@ export class PresentationManager {
      * @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);
-        const descriptor = Descriptor.fromJSON(result);
-        return descriptor ? this._localizationHelper.getLocalizedContentDescriptor(descriptor) : undefined;
+        this.startIModelInitialization(requestOptions.imodel);
+        try {
+            const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+            const rpcOptions = this.toRpcTokenOptions({ ...options });
+            const result = await this._requestsHandler.getNodesDescriptor(rpcOptions);
+            const descriptor = Descriptor.fromJSON(result);
+            return descriptor ? this._localizationHelper.getLocalizedContentDescriptor(descriptor) : undefined;
+        }
+        finally {
+            await this.ensureIModelInitialized(requestOptions.imodel);
+        }
     }
     /** 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);
+        this.startIModelInitialization(requestOptions.imodel);
         const options = await this.addRulesetAndVariablesToOptions(requestOptions);
         const rpcOptions = this.toRpcTokenOptions({ ...options });
         const result = await this._requestsHandler.getNodePaths(rpcOptions);
@@ -227,7 +262,7 @@ export class PresentationManager {
     }
     /** Retrieves paths from root nodes to nodes containing filter text in their label. */
     async getFilteredNodePaths(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(requestOptions.imodel);
         const options = await this.addRulesetAndVariablesToOptions(requestOptions);
         const result = await this._requestsHandler.getFilteredNodePaths(this.toRpcTokenOptions(options));
         // eslint-disable-next-line deprecation/deprecation
@@ -239,26 +274,31 @@ export class PresentationManager {
      * @public
      */
     async getContentSources(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(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);
-        const descriptor = Descriptor.fromJSON(result);
-        return descriptor ? this._localizationHelper.getLocalizedContentDescriptor(descriptor) : undefined;
+        this.startIModelInitialization(requestOptions.imodel);
+        try {
+            const options = await this.addRulesetAndVariablesToOptions(requestOptions);
+            const rpcOptions = this.toRpcTokenOptions({
+                ...options,
+                keys: stripTransientElementKeys(options.keys).toJSON(),
+            });
+            const result = await this._requestsHandler.getContentDescriptor(rpcOptions);
+            const descriptor = Descriptor.fromJSON(result);
+            return descriptor ? this._localizationHelper.getLocalizedContentDescriptor(descriptor) : undefined;
+        }
+        finally {
+            await this.ensureIModelInitialized(requestOptions.imodel);
+        }
     }
     /** Retrieves overall content set size. */
     async getContentSetSize(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(requestOptions.imodel);
         const options = await this.addRulesetAndVariablesToOptions(requestOptions);
         const rpcOptions = this.toRpcTokenOptions({
             ...options,
@@ -267,13 +307,7 @@ export class PresentationManager {
         });
         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);
+    async getContentIteratorInternal(requestOptions) {
         const options = await this.addRulesetAndVariablesToOptions(requestOptions);
         const rpcOptions = this.toRpcTokenOptions({
             ...options,
@@ -281,46 +315,113 @@ export class PresentationManager {
             keys: stripTransientElementKeys(requestOptions.keys).toJSON(),
             ...(!requestOptions.omitFormattedValues && this._schemaContextProvider !== undefined ? { omitFormattedValues: true } : undefined),
         });
-        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: [] };
+        let contentFormatter;
+        if (!requestOptions.omitFormattedValues && this._schemaContextProvider) {
+            const koqPropertyFormatter = new KoqPropertyValueFormatter(this._schemaContextProvider(requestOptions.imodel), this._defaultFormats);
+            contentFormatter = new ContentFormatter(new ContentPropertyValueFormatter(koqPropertyFormatter), requestOptions.unitSystem ?? this._explicitActiveUnitSystem ?? IModelApp.quantityFormatter.activeUnitSystem);
+        }
+        let descriptor = requestOptions.descriptor instanceof Descriptor ? requestOptions.descriptor : undefined;
+        let firstPage;
+        if (!descriptor) {
+            const firstPageResponse = await this._requestsHandler.getPagedContent(rpcOptions);
+            if (!firstPageResponse?.descriptor || !firstPageResponse.contentSet) {
+                return undefined;
             }
-            return this._requestsHandler.getPagedContentSet({ ...rpcOptions, paging: partialPageOptions });
+            descriptor = Descriptor.fromJSON(firstPageResponse?.descriptor);
+            firstPage = firstPageResponse?.contentSet;
+        }
+        // istanbul ignore if
+        if (!descriptor) {
+            return undefined;
+        }
+        descriptor = this._localizationHelper.getLocalizedContentDescriptor(descriptor);
+        const getPage = async (paging, requestIndex) => {
+            let contentSet = requestIndex === 0 ? firstPage : undefined;
+            contentSet ??= await this._requestsHandler.getPagedContentSet({ ...rpcOptions, paging });
+            let items = contentSet.items.map((x) => Item.fromJSON(x)).filter((x) => x !== undefined);
+            if (contentFormatter) {
+                items = await contentFormatter.formatContentItems(items, descriptor);
+            }
+            items = this._localizationHelper.getLocalizedContentItems(items);
+            return {
+                total: contentSet.total,
+                items,
+            };
+        };
+        const generator = new StreamedResponseGenerator({
+            ...requestOptions,
+            getBatch: getPage,
         });
-        if (!descriptor)
+        return {
+            ...(await generator.createAsyncIteratorResponse()),
+            descriptor,
+        };
+    }
+    /** Retrieves a content descriptor, item count and async generator for the items themselves. */
+    async getContentIterator(requestOptions) {
+        this.startIModelInitialization(requestOptions.imodel);
+        const response = await this.getContentIteratorInternal(requestOptions);
+        if (!response) {
+            return undefined;
+        }
+        await this.ensureIModelInitialized(requestOptions.imodel);
+        return response;
+    }
+    /**
+     * Retrieves content which consists of a content descriptor and a page of records.
+     * @deprecated in 4.5. Use [[getContentIterator]] instead.
+     */
+    async getContent(requestOptions) {
+        // eslint-disable-next-line deprecation/deprecation
+        return (await this.getContentAndSize(requestOptions))?.content;
+    }
+    /**
+     * Retrieves content set size and content which consists of a content descriptor and a page of records.
+     * @deprecated in 4.5. Use [[getContentIterator]] instead.
+     */
+    async getContentAndSize(requestOptions) {
+        const response = await this.getContentIterator(requestOptions);
+        if (!response) {
             return undefined;
-        const items = result.items.map((itemJson) => Item.fromJSON(itemJson)).filter((item) => (item !== undefined));
-        const resultContent = new Content(descriptor, items);
-        if (!requestOptions.omitFormattedValues && this._schemaContextProvider) {
-            const koqPropertyFormatter = new KoqPropertyValueFormatter(this._schemaContextProvider(requestOptions.imodel), this._defaultFormats);
-            const contentFormatter = new ContentFormatter(new ContentPropertyValueFormatter(koqPropertyFormatter), requestOptions.unitSystem ?? this._explicitActiveUnitSystem ?? IModelApp.quantityFormatter.activeUnitSystem);
-            await contentFormatter.formatContent(resultContent);
         }
+        const { descriptor, total } = response;
+        const items = await collect(response.items);
         return {
-            size: result.total,
-            content: this._localizationHelper.getLocalizedContent(resultContent),
+            content: new Content(descriptor, items),
+            size: total,
         };
     }
-    /** Retrieves distinct values of specific field from the content. */
-    async getPagedDistinctValues(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+    /** Returns an iterator that asynchronously polls distinct values of specific field from the content. */
+    async getDistinctValuesIterator(requestOptions) {
+        this.startIModelInitialization(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 }));
+        const generator = new StreamedResponseGenerator({
+            ...requestOptions,
+            getBatch: async (paging) => {
+                const response = await this._requestsHandler.getPagedDistinctValues({ ...rpcOptions, paging });
+                return {
+                    total: response.total,
+                    // eslint-disable-next-line deprecation/deprecation
+                    items: response.items.map((x) => this._localizationHelper.getLocalizedDisplayValueGroup(DisplayValueGroup.fromJSON(x))),
+                };
+            },
+        });
+        return generator.createAsyncIteratorResponse();
+    }
+    /**
+     * Retrieves distinct values of specific field from the content.
+     * @deprecated in 4.5. Use [[getDistinctValuesIterator]] instead.
+     */
+    async getPagedDistinctValues(requestOptions) {
+        const result = await this.getDistinctValuesIterator(requestOptions);
         return {
-            ...result,
-            // eslint-disable-next-line deprecation/deprecation
-            items: result.items.map(DisplayValueGroup.fromJSON).map((g) => this._localizationHelper.getLocalizedDisplayValueGroup(g)),
+            total: result.total,
+            items: await collect(result.items),
         };
     }
     /**
@@ -328,11 +429,12 @@ export class PresentationManager {
      * @public
      */
     async getElementProperties(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(requestOptions.imodel);
         const results = await this._requestsHandler.getElementProperties(this.toRpcTokenOptions(requestOptions));
         // istanbul ignore if
-        if (!results)
+        if (!results) {
             return undefined;
+        }
         return this._localizationHelper.getLocalizedElementProperties(results);
     }
     /**
@@ -340,15 +442,15 @@ export class PresentationManager {
      * @public
      */
     async getContentInstanceKeys(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(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 generator = new StreamedResponseGenerator({
+            ...requestOptions,
+            getBatch: async (page) => {
                 const keys = await this._requestsHandler.getContentInstanceKeys({ ...rpcOptions, paging: page });
                 return {
                     total: keys.total,
@@ -360,82 +462,72 @@ export class PresentationManager {
                     }, new Array()),
                 };
             },
+        });
+        const { total, items } = await generator.createAsyncIteratorResponse();
+        return {
+            total,
+            async *items() {
+                yield* items;
+            },
         };
-        return createPagedGeneratorResponse(props);
     }
     /** Retrieves display label definition of specific item. */
     async getDisplayLabelDefinition(requestOptions) {
-        await this.onConnection(requestOptions.imodel);
+        this.startIModelInitialization(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);
+    async getDisplayLabelDefinitionsIterator(requestOptions) {
+        this.startIModelInitialization(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 });
+        const generator = new StreamedResponseGenerator({
+            ...requestOptions,
+            getBatch: async (page) => {
+                const partialKeys = !page.start ? rpcOptions.keys : rpcOptions.keys.slice(page.start);
+                const result = await this._requestsHandler.getPagedDisplayLabelDefinitions({ ...rpcOptions, keys: partialKeys });
+                result.items = this._localizationHelper.getLocalizedLabelDefinitions(result.items);
+                return result;
+            },
         });
-        return this._localizationHelper.getLocalizedLabelDefinitions(result.items);
+        return generator.createAsyncIteratorResponse();
+    }
+    /**
+     * Retrieves display label definition of specific items.
+     * @deprecated in 4.5. Use [[getDisplayLabelDefinitionsIterator]] instead.
+     */
+    async getDisplayLabelDefinitions(requestOptions) {
+        const { items } = await this.getDisplayLabelDefinitionsIterator(requestOptions);
+        return collect(items);
     }
 }
 const getDescriptorOverrides = (descriptorOrOverrides) => {
-    if (descriptorOrOverrides instanceof Descriptor)
+    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))
+    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;
+        const isTransient = (Key.isInstanceKey(key) && key.className === TRANSIENT_ELEMENT_CLASSNAME) ||
+            (Key.isEntityProps(key) && key.classFullName === TRANSIENT_ELEMENT_CLASSNAME);
         return !isTransient;
     });
     return copy;
 };
+async function collect(iter) {
+    const result = new Array();
+    for await (const value of iter) {
+        result.push(value);
+    }
+    return result;
+}
 //# sourceMappingURL=PresentationManager.js.map