@itwin/presentation-common 4.0.0-dev.24 → 4.0.0-dev.28

package/lib/esm/presentation-common/content/ContentTraverser.js

@@ -1,430 +1,428 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Content
- */
-import { assert, using } from "@itwin/core-bentley";
-import { Content } from "./Content";
-import { Field } from "./Fields";
-import { Item } from "./Item";
-import { PropertyValueFormat } from "./TypeDescription";
-import { DisplayValue, Value } from "./Value";
-/**
- * An utility for traversing field hierarchy. Stops traversal as soon as `cb` returns `false`.
- * @public
- */
-export function traverseFieldHierarchy(hierarchy, cb) {
-    if (cb(hierarchy))
-        hierarchy.childFields.forEach((childHierarchy) => traverseFieldHierarchy(childHierarchy, cb));
-}
-/**
- * An utility to traverse content using provided visitor. Provides means to parse content into different formats,
- * for different components.
- * @public
- */
-export function traverseContent(visitor, content) {
-    if (!visitor.startContent({ descriptor: content.descriptor }))
-        return;
-    try {
-        const fieldHierarchies = createFieldHierarchies(content.descriptor.fields);
-        visitor.processFieldHierarchies({ hierarchies: fieldHierarchies });
-        content.contentSet.forEach((item) => {
-            traverseContentItemFields(visitor, fieldHierarchies, item);
-        });
-    }
-    finally {
-        visitor.finishContent();
-    }
-}
-/**
- * An utility for calling [[traverseContent]] when there's only one content item.
- * @public
- */
-export function traverseContentItem(visitor, descriptor, item) {
-    traverseContent(visitor, new Content(descriptor, [item]));
-}
-class VisitedCategories {
-    constructor(_visitor, category) {
-        this._visitor = _visitor;
-        const stack = [];
-        let curr = category;
-        while (curr) {
-            stack.push(curr);
-            curr = curr.parent;
-        }
-        stack.reverse();
-        this._didVisitAllHierarchy = true;
-        this._visitedCategories = [];
-        for (curr of stack) {
-            if (this._visitor.startCategory({ category: curr })) {
-                this._visitedCategories.push(curr);
-            }
-            else {
-                this._didVisitAllHierarchy = false;
-                break;
-            }
-        }
-    }
-    dispose() {
-        while (this._visitedCategories.pop())
-            this._visitor.finishCategory();
-    }
-    get shouldContinue() { return this._didVisitAllHierarchy; }
-}
-function traverseContentItemFields(visitor, fieldHierarchies, item) {
-    if (!visitor.startItem({ item }))
-        return;
-    try {
-        fieldHierarchies.forEach((fieldHierarchy) => {
-            using(new VisitedCategories(visitor, fieldHierarchy.field.category), (res) => {
-                if (res.shouldContinue)
-                    traverseContentItemField(visitor, fieldHierarchy, item);
-            });
-        });
-    }
-    finally {
-        visitor.finishItem();
-    }
-}
-function traverseContentItemField(visitor, fieldHierarchy, item) {
-    if (!visitor.startField({ hierarchy: fieldHierarchy }))
-        return;
-    try {
-        const rootToThisField = createFieldPath(fieldHierarchy.field);
-        let parentFieldName;
-        const pathUpToField = rootToThisField.slice(undefined, -1);
-        for (let i = 0; i < pathUpToField.length; ++i) {
-            const parentField = pathUpToField[i];
-            const nextField = rootToThisField[i + 1];
-            if (item.isFieldMerged(parentField.name)) {
-                visitor.processMergedValue({ requestedField: fieldHierarchy.field, mergedField: parentField, parentFieldName });
-                return;
-            }
-            const { emptyNestedItem, convertedItem } = convertNestedContentItemToStructArrayItem(item, parentField, nextField);
-            if (emptyNestedItem)
-                return;
-            item = convertedItem;
-            parentFieldName = combineFieldNames(parentField.name, parentFieldName);
-        }
-        if (item.isFieldMerged(fieldHierarchy.field.name)) {
-            visitor.processMergedValue({ requestedField: fieldHierarchy.field, mergedField: fieldHierarchy.field, parentFieldName });
-            return;
-        }
-        if (fieldHierarchy.field.isNestedContentField()) {
-            fieldHierarchy = convertNestedContentFieldHierarchyToStructArrayHierarchy(fieldHierarchy, parentFieldName);
-            const { emptyNestedItem, convertedItem } = convertNestedContentFieldHierarchyItemToStructArrayItem(item, fieldHierarchy);
-            if (emptyNestedItem)
-                return;
-            item = convertedItem;
-        }
-        else if (pathUpToField.length > 0) {
-            fieldHierarchy = {
-                ...fieldHierarchy,
-                field: Object.assign(fieldHierarchy.field.clone(), {
-                    type: {
-                        valueFormat: PropertyValueFormat.Array,
-                        typeName: `${fieldHierarchy.field.type.typeName}[]`,
-                        memberType: fieldHierarchy.field.type,
-                    },
-                }),
-            };
-        }
-        traverseContentItemFieldValue(visitor, fieldHierarchy, item.mergedFieldNames, fieldHierarchy.field.type, parentFieldName, item.values[fieldHierarchy.field.name], item.displayValues[fieldHierarchy.field.name]);
-    }
-    finally {
-        visitor.finishField();
-    }
-}
-function traverseContentItemFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue) {
-    if (rawValue !== undefined) {
-        if (valueType.valueFormat === PropertyValueFormat.Array) {
-            assert(Value.isArray(rawValue));
-            assert(DisplayValue.isArray(displayValue));
-            return traverseContentItemArrayFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue);
-        }
-        if (valueType.valueFormat === PropertyValueFormat.Struct) {
-            assert(Value.isMap(rawValue));
-            assert(DisplayValue.isMap(displayValue));
-            return traverseContentItemStructFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue);
-        }
-    }
-    traverseContentItemPrimitiveFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue);
-}
-function traverseContentItemArrayFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValues, displayValues) {
-    assert(rawValues.length === displayValues.length);
-    assert(valueType.valueFormat === PropertyValueFormat.Array);
-    if (!visitor.startArray({ hierarchy: fieldHierarchy, valueType, parentFieldName, rawValues, displayValues }))
-        return;
-    try {
-        const itemType = valueType.memberType;
-        rawValues.forEach((_, i) => {
-            traverseContentItemFieldValue(visitor, fieldHierarchy, mergedFieldNames, itemType, parentFieldName, rawValues[i], displayValues[i]);
-        });
-    }
-    finally {
-        visitor.finishArray();
-    }
-}
-function traverseContentItemStructFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValues, displayValues) {
-    assert(valueType.valueFormat === PropertyValueFormat.Struct);
-    if (!visitor.startStruct({ hierarchy: fieldHierarchy, valueType, parentFieldName, rawValues, displayValues }))
-        return;
-    try {
-        if (fieldHierarchy.field.isNestedContentField())
-            parentFieldName = combineFieldNames(fieldHierarchy.field.name, parentFieldName);
-        valueType.members.forEach((memberDescription) => {
-            let memberField = fieldHierarchy.childFields.find((f) => f.field.name === memberDescription.name);
-            if (!memberField) {
-                // Not finding a member field means we're traversing an ECStruct. We still need to carry member information, so we
-                // create a fake field to represent the member
-                memberField = {
-                    field: new Field(fieldHierarchy.field.category, memberDescription.name, memberDescription.label, memberDescription.type, fieldHierarchy.field.isReadonly, 0),
-                    childFields: [],
-                };
-            }
-            traverseContentItemFieldValue(visitor, memberField, mergedFieldNames, memberDescription.type, parentFieldName, rawValues[memberDescription.name], displayValues[memberDescription.name]);
-        });
-    }
-    finally {
-        visitor.finishStruct();
-    }
-}
-function traverseContentItemPrimitiveFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue) {
-    if (-1 !== mergedFieldNames.indexOf(fieldHierarchy.field.name)) {
-        visitor.processMergedValue({ mergedField: fieldHierarchy.field, requestedField: fieldHierarchy.field, parentFieldName });
-        return;
-    }
-    visitor.processPrimitiveValue({ field: fieldHierarchy.field, valueType, parentFieldName, rawValue, displayValue });
-}
-/**
- * Parses a list of [[Field]] objects into a list of [[FieldHierarchy]].
- *
- * @param ignoreCategories Enables adding all of the `nestedFields` to parent field's `childFields`
- * without considering categories.
- *
- * @public
- */
-export function createFieldHierarchies(fields, ignoreCategories) {
-    const hierarchies = new Array();
-    const visitField = (category, field, parentField) => {
-        let childFields = [];
-        if (field.isNestedContentField()) {
-            // visit all nested fields
-            childFields = visitFields(field.nestedFields, field);
-            if (0 === childFields.length)
-                return undefined;
-        }
-        const fieldHierarchy = { field, childFields };
-        if (category === (parentField === null || parentField === void 0 ? void 0 : parentField.category) || ignoreCategories && parentField) {
-            // if categories of this field and its parent field match - return the field hierarchy without
-            // including it as a top level field
-            return fieldHierarchy;
-        }
-        addFieldHierarchy(hierarchies, fieldHierarchy);
-        return undefined;
-    };
-    const visitFields = (visitedFields, parentField) => {
-        const includedFields = [];
-        visitedFields.forEach((field) => {
-            const visitedField = visitField(field.category, field, parentField);
-            if (visitedField)
-                includedFields.push(visitedField);
-        });
-        return includedFields;
-    };
-    visitFields(fields, undefined);
-    return hierarchies;
-}
-function findRelatedFields(rootFields, hierarchy) {
-    // build a list of parent fields in hierarchy
-    const fields = [];
-    let currField = hierarchy.field;
-    while (currField) {
-        fields.push(currField);
-        currField = currField.parent;
-    }
-    for (let rootIndex = 0; rootIndex < rootFields.length; ++rootIndex) {
-        const rootFieldHierarchy = rootFields[rootIndex];
-        if (rootFieldHierarchy.field.category !== hierarchy.field.category) {
-            // only interested in fields with the same category
-            continue;
-        }
-        let first = true;
-        currField = rootFieldHierarchy.field;
-        while (currField) {
-            const index = fields.findIndex((f) => f.name === currField.name);
-            if (-1 !== index) {
-                return {
-                    existing: {
-                        field: currField,
-                        hierarchy: first ? rootFieldHierarchy : undefined,
-                        index: rootIndex,
-                    },
-                    matchingField: fields[index],
-                };
-            }
-            currField = currField.parent;
-            first = false;
-        }
-    }
-    return undefined;
-}
-function buildParentHierarchy(hierarchy, parentField) {
-    // note: parentField is found by walking up the parentship relationship
-    // from hierarchy.field, so we expect to always find it here
-    while (hierarchy.field !== parentField) {
-        const hierarchyParent = hierarchy.field.parent;
-        assert(hierarchyParent !== undefined);
-        hierarchy = { field: hierarchyParent, childFields: [hierarchy] };
-    }
-    return hierarchy;
-}
-function mergeHierarchies(lhs, rhs) {
-    assert(lhs.field.name === rhs.field.name);
-    const result = {
-        field: lhs.field.clone(),
-        childFields: [...lhs.childFields],
-    };
-    rhs.childFields.forEach((rhsChildHierarchy) => {
-        const indexInResult = result.childFields.findIndex((resultHierarchy) => resultHierarchy.field.name === rhsChildHierarchy.field.name);
-        if (indexInResult !== -1)
-            result.childFields[indexInResult] = mergeHierarchies(result.childFields[indexInResult], rhsChildHierarchy);
-        else
-            result.childFields.push(rhsChildHierarchy);
-    });
-    return result;
-}
-/**
- * Adds a field hierarchy into root field hierarchies list. *
- * @public
- */
-export function addFieldHierarchy(rootHierarchies, hierarchy) {
-    var _a;
-    const match = findRelatedFields(rootHierarchies, hierarchy);
-    if (!match) {
-        rootHierarchies.push(hierarchy);
-        return;
-    }
-    const targetHierarchy = rootHierarchies[match.existing.index];
-    const existingHierarchy = (_a = match.existing.hierarchy) !== null && _a !== void 0 ? _a : buildParentHierarchy(targetHierarchy, match.existing.field);
-    const insertHierarchy = buildParentHierarchy(hierarchy, match.matchingField);
-    const mergedHierarchy = mergeHierarchies(existingHierarchy, insertHierarchy);
-    mergedHierarchy.field.category = hierarchy.field.category;
-    rootHierarchies[match.existing.index] = mergedHierarchy;
-}
-function createFieldPath(field) {
-    const path = [field];
-    let currField = field;
-    while (currField.parent) {
-        currField = currField.parent;
-        path.push(currField);
-    }
-    path.reverse();
-    return path;
-}
-/** @internal */
-export const FIELD_NAMES_SEPARATOR = "$";
-/**
- * Combines given field names in a way that allows them to be parsed back into a list of individual names using the [[parseCombinedFieldNames]] function.
- * @public
- */
-export function combineFieldNames(fieldName, parentFieldName) {
-    return parentFieldName ? `${parentFieldName}${FIELD_NAMES_SEPARATOR}${fieldName}` : fieldName;
-}
-/**
- * Parses given combined field names string, constructed using [[combineFieldNames]], into a list of individual field names.
- * @public
- */
-export function parseCombinedFieldNames(combinedName) {
-    return combinedName ? combinedName.split(FIELD_NAMES_SEPARATOR) : [];
-}
-function convertNestedContentItemToStructArrayItem(item, field, nextField) {
-    var _a;
-    const value = (_a = item.values[field.name]) !== null && _a !== void 0 ? _a : [];
-    assert(Value.isNestedContent(value));
-    if (value.length === 0)
-        return { emptyNestedItem: true, convertedItem: item };
-    const nextFieldValues = { raw: [], display: [] };
-    value.forEach((ncv) => {
-        const nextRawValue = ncv.values[nextField.name];
-        const nextDisplayValue = ncv.displayValues[nextField.name];
-        if (nextField.isNestedContentField()) {
-            if (nextRawValue) {
-                assert(Value.isNestedContent(nextRawValue));
-                nextFieldValues.raw.push(...nextRawValue);
-            }
-        }
-        else {
-            nextFieldValues.raw.push(nextRawValue);
-            nextFieldValues.display.push(nextDisplayValue);
-        }
-    });
-    const convertedItem = new Item(item.primaryKeys, item.label, item.imageId, item.classInfo, { [nextField.name]: nextFieldValues.raw }, { [nextField.name]: nextFieldValues.display }, item.mergedFieldNames, item.extendedData); // eslint-disable-line deprecation/deprecation
-    return { emptyNestedItem: false, convertedItem };
-}
-function convertNestedContentFieldHierarchyToStructArrayHierarchy(fieldHierarchy, parentFieldName) {
-    const fieldName = fieldHierarchy.field.name;
-    const convertedChildFieldHierarchies = fieldHierarchy.childFields.map((child) => {
-        if (child.field.isNestedContentField())
-            return convertNestedContentFieldHierarchyToStructArrayHierarchy(child, combineFieldNames(fieldName, parentFieldName));
-        return child;
-    });
-    const convertedFieldHierarchy = {
-        field: Object.assign(fieldHierarchy.field.clone(), {
-            type: {
-                valueFormat: PropertyValueFormat.Array,
-                typeName: `${fieldHierarchy.field.type.typeName}[]`,
-                memberType: {
-                    valueFormat: PropertyValueFormat.Struct,
-                    typeName: fieldHierarchy.field.type.typeName,
-                    members: convertedChildFieldHierarchies.map((member) => ({
-                        name: member.field.name,
-                        label: member.field.label,
-                        type: member.field.type,
-                    })),
-                },
-            },
-        }),
-        childFields: convertedChildFieldHierarchies,
-    };
-    return convertedFieldHierarchy;
-}
-function convertNestedContentValuesToStructArrayValuesRecursive(fieldHierarchy, ncvs) {
-    const result = { raw: [], display: [], mergedFieldNames: [] };
-    ncvs.forEach((ncv) => {
-        const values = { ...ncv.values };
-        const displayValues = { ...ncv.displayValues };
-        const mergedFieldNames = [...ncv.mergedFieldNames];
-        fieldHierarchy.childFields.forEach((childFieldHierarchy) => {
-            const childFieldName = childFieldHierarchy.field.name;
-            if (-1 !== ncv.mergedFieldNames.indexOf(childFieldName)) {
-                return;
-            }
-            if (childFieldHierarchy.field.isNestedContentField()) {
-                const value = values[childFieldName];
-                assert(Value.isNestedContent(value));
-                const convertedValues = convertNestedContentValuesToStructArrayValuesRecursive(childFieldHierarchy, value);
-                values[childFieldName] = convertedValues.raw;
-                displayValues[childFieldName] = convertedValues.display;
-                mergedFieldNames.push(...convertedValues.mergedFieldNames);
-            }
-        });
-        result.raw.push(values);
-        result.display.push(displayValues);
-        result.mergedFieldNames.push(...mergedFieldNames);
-    });
-    return result;
-}
-function convertNestedContentFieldHierarchyItemToStructArrayItem(item, fieldHierarchy) {
-    const fieldName = fieldHierarchy.field.name;
-    const rawValue = item.values[fieldName];
-    assert(Value.isNestedContent(rawValue));
-    if (rawValue.length === 0)
-        return { emptyNestedItem: true, convertedItem: item };
-    const converted = convertNestedContentValuesToStructArrayValuesRecursive(fieldHierarchy, rawValue);
-    const convertedItem = new Item(item.primaryKeys, item.label, item.imageId, item.classInfo, { [fieldName]: converted.raw }, { [fieldName]: converted.display }, converted.mergedFieldNames, item.extendedData); // eslint-disable-line deprecation/deprecation
-    return { emptyNestedItem: false, convertedItem };
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Content
+ */
+import { assert, using } from "@itwin/core-bentley";
+import { Content } from "./Content";
+import { Field } from "./Fields";
+import { Item } from "./Item";
+import { PropertyValueFormat } from "./TypeDescription";
+import { DisplayValue, Value } from "./Value";
+/**
+ * An utility for traversing field hierarchy. Stops traversal as soon as `cb` returns `false`.
+ * @public
+ */
+export function traverseFieldHierarchy(hierarchy, cb) {
+    if (cb(hierarchy))
+        hierarchy.childFields.forEach((childHierarchy) => traverseFieldHierarchy(childHierarchy, cb));
+}
+/**
+ * An utility to traverse content using provided visitor. Provides means to parse content into different formats,
+ * for different components.
+ * @public
+ */
+export function traverseContent(visitor, content) {
+    if (!visitor.startContent({ descriptor: content.descriptor }))
+        return;
+    try {
+        const fieldHierarchies = createFieldHierarchies(content.descriptor.fields);
+        visitor.processFieldHierarchies({ hierarchies: fieldHierarchies });
+        content.contentSet.forEach((item) => {
+            traverseContentItemFields(visitor, fieldHierarchies, item);
+        });
+    }
+    finally {
+        visitor.finishContent();
+    }
+}
+/**
+ * An utility for calling [[traverseContent]] when there's only one content item.
+ * @public
+ */
+export function traverseContentItem(visitor, descriptor, item) {
+    traverseContent(visitor, new Content(descriptor, [item]));
+}
+class VisitedCategories {
+    constructor(_visitor, category) {
+        this._visitor = _visitor;
+        const stack = [];
+        let curr = category;
+        while (curr) {
+            stack.push(curr);
+            curr = curr.parent;
+        }
+        stack.reverse();
+        this._didVisitAllHierarchy = true;
+        this._visitedCategories = [];
+        for (curr of stack) {
+            if (this._visitor.startCategory({ category: curr })) {
+                this._visitedCategories.push(curr);
+            }
+            else {
+                this._didVisitAllHierarchy = false;
+                break;
+            }
+        }
+    }
+    dispose() {
+        while (this._visitedCategories.pop())
+            this._visitor.finishCategory();
+    }
+    get shouldContinue() { return this._didVisitAllHierarchy; }
+}
+function traverseContentItemFields(visitor, fieldHierarchies, item) {
+    if (!visitor.startItem({ item }))
+        return;
+    try {
+        fieldHierarchies.forEach((fieldHierarchy) => {
+            using(new VisitedCategories(visitor, fieldHierarchy.field.category), (res) => {
+                if (res.shouldContinue)
+                    traverseContentItemField(visitor, fieldHierarchy, item);
+            });
+        });
+    }
+    finally {
+        visitor.finishItem();
+    }
+}
+function traverseContentItemField(visitor, fieldHierarchy, item) {
+    if (!visitor.startField({ hierarchy: fieldHierarchy }))
+        return;
+    try {
+        const rootToThisField = createFieldPath(fieldHierarchy.field);
+        let parentFieldName;
+        const pathUpToField = rootToThisField.slice(undefined, -1);
+        for (let i = 0; i < pathUpToField.length; ++i) {
+            const parentField = pathUpToField[i];
+            const nextField = rootToThisField[i + 1];
+            if (item.isFieldMerged(parentField.name)) {
+                visitor.processMergedValue({ requestedField: fieldHierarchy.field, mergedField: parentField, parentFieldName });
+                return;
+            }
+            const { emptyNestedItem, convertedItem } = convertNestedContentItemToStructArrayItem(item, parentField, nextField);
+            if (emptyNestedItem)
+                return;
+            item = convertedItem;
+            parentFieldName = combineFieldNames(parentField.name, parentFieldName);
+        }
+        if (item.isFieldMerged(fieldHierarchy.field.name)) {
+            visitor.processMergedValue({ requestedField: fieldHierarchy.field, mergedField: fieldHierarchy.field, parentFieldName });
+            return;
+        }
+        if (fieldHierarchy.field.isNestedContentField()) {
+            fieldHierarchy = convertNestedContentFieldHierarchyToStructArrayHierarchy(fieldHierarchy, parentFieldName);
+            const { emptyNestedItem, convertedItem } = convertNestedContentFieldHierarchyItemToStructArrayItem(item, fieldHierarchy);
+            if (emptyNestedItem)
+                return;
+            item = convertedItem;
+        }
+        else if (pathUpToField.length > 0) {
+            fieldHierarchy = {
+                ...fieldHierarchy,
+                field: Object.assign(fieldHierarchy.field.clone(), {
+                    type: {
+                        valueFormat: PropertyValueFormat.Array,
+                        typeName: `${fieldHierarchy.field.type.typeName}[]`,
+                        memberType: fieldHierarchy.field.type,
+                    },
+                }),
+            };
+        }
+        traverseContentItemFieldValue(visitor, fieldHierarchy, item.mergedFieldNames, fieldHierarchy.field.type, parentFieldName, item.values[fieldHierarchy.field.name], item.displayValues[fieldHierarchy.field.name]);
+    }
+    finally {
+        visitor.finishField();
+    }
+}
+function traverseContentItemFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue) {
+    if (rawValue !== undefined) {
+        if (valueType.valueFormat === PropertyValueFormat.Array) {
+            assert(Value.isArray(rawValue));
+            assert(DisplayValue.isArray(displayValue));
+            return traverseContentItemArrayFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue);
+        }
+        if (valueType.valueFormat === PropertyValueFormat.Struct) {
+            assert(Value.isMap(rawValue));
+            assert(DisplayValue.isMap(displayValue));
+            return traverseContentItemStructFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue);
+        }
+    }
+    traverseContentItemPrimitiveFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue);
+}
+function traverseContentItemArrayFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValues, displayValues) {
+    assert(rawValues.length === displayValues.length);
+    assert(valueType.valueFormat === PropertyValueFormat.Array);
+    if (!visitor.startArray({ hierarchy: fieldHierarchy, valueType, parentFieldName, rawValues, displayValues }))
+        return;
+    try {
+        const itemType = valueType.memberType;
+        rawValues.forEach((_, i) => {
+            traverseContentItemFieldValue(visitor, fieldHierarchy, mergedFieldNames, itemType, parentFieldName, rawValues[i], displayValues[i]);
+        });
+    }
+    finally {
+        visitor.finishArray();
+    }
+}
+function traverseContentItemStructFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValues, displayValues) {
+    assert(valueType.valueFormat === PropertyValueFormat.Struct);
+    if (!visitor.startStruct({ hierarchy: fieldHierarchy, valueType, parentFieldName, rawValues, displayValues }))
+        return;
+    try {
+        if (fieldHierarchy.field.isNestedContentField())
+            parentFieldName = combineFieldNames(fieldHierarchy.field.name, parentFieldName);
+        valueType.members.forEach((memberDescription) => {
+            let memberField = fieldHierarchy.childFields.find((f) => f.field.name === memberDescription.name);
+            if (!memberField) {
+                // Not finding a member field means we're traversing an ECStruct. We still need to carry member information, so we
+                // create a fake field to represent the member
+                memberField = {
+                    field: new Field(fieldHierarchy.field.category, memberDescription.name, memberDescription.label, memberDescription.type, fieldHierarchy.field.isReadonly, 0),
+                    childFields: [],
+                };
+            }
+            traverseContentItemFieldValue(visitor, memberField, mergedFieldNames, memberDescription.type, parentFieldName, rawValues[memberDescription.name], displayValues[memberDescription.name]);
+        });
+    }
+    finally {
+        visitor.finishStruct();
+    }
+}
+function traverseContentItemPrimitiveFieldValue(visitor, fieldHierarchy, mergedFieldNames, valueType, parentFieldName, rawValue, displayValue) {
+    if (-1 !== mergedFieldNames.indexOf(fieldHierarchy.field.name)) {
+        visitor.processMergedValue({ mergedField: fieldHierarchy.field, requestedField: fieldHierarchy.field, parentFieldName });
+        return;
+    }
+    visitor.processPrimitiveValue({ field: fieldHierarchy.field, valueType, parentFieldName, rawValue, displayValue });
+}
+/**
+ * Parses a list of [[Field]] objects into a list of [[FieldHierarchy]].
+ *
+ * @param ignoreCategories Enables adding all of the `nestedFields` to parent field's `childFields`
+ * without considering categories.
+ *
+ * @public
+ */
+export function createFieldHierarchies(fields, ignoreCategories) {
+    const hierarchies = new Array();
+    const visitField = (category, field, parentField) => {
+        let childFields = [];
+        if (field.isNestedContentField()) {
+            // visit all nested fields
+            childFields = visitFields(field.nestedFields, field);
+            if (0 === childFields.length)
+                return undefined;
+        }
+        const fieldHierarchy = { field, childFields };
+        if (category === parentField?.category || ignoreCategories && parentField) {
+            // if categories of this field and its parent field match - return the field hierarchy without
+            // including it as a top level field
+            return fieldHierarchy;
+        }
+        addFieldHierarchy(hierarchies, fieldHierarchy);
+        return undefined;
+    };
+    const visitFields = (visitedFields, parentField) => {
+        const includedFields = [];
+        visitedFields.forEach((field) => {
+            const visitedField = visitField(field.category, field, parentField);
+            if (visitedField)
+                includedFields.push(visitedField);
+        });
+        return includedFields;
+    };
+    visitFields(fields, undefined);
+    return hierarchies;
+}
+function findRelatedFields(rootFields, hierarchy) {
+    // build a list of parent fields in hierarchy
+    const fields = [];
+    let currField = hierarchy.field;
+    while (currField) {
+        fields.push(currField);
+        currField = currField.parent;
+    }
+    for (let rootIndex = 0; rootIndex < rootFields.length; ++rootIndex) {
+        const rootFieldHierarchy = rootFields[rootIndex];
+        if (rootFieldHierarchy.field.category !== hierarchy.field.category) {
+            // only interested in fields with the same category
+            continue;
+        }
+        let first = true;
+        currField = rootFieldHierarchy.field;
+        while (currField) {
+            const index = fields.findIndex((f) => f.name === currField.name);
+            if (-1 !== index) {
+                return {
+                    existing: {
+                        field: currField,
+                        hierarchy: first ? rootFieldHierarchy : undefined,
+                        index: rootIndex,
+                    },
+                    matchingField: fields[index],
+                };
+            }
+            currField = currField.parent;
+            first = false;
+        }
+    }
+    return undefined;
+}
+function buildParentHierarchy(hierarchy, parentField) {
+    // note: parentField is found by walking up the parentship relationship
+    // from hierarchy.field, so we expect to always find it here
+    while (hierarchy.field !== parentField) {
+        const hierarchyParent = hierarchy.field.parent;
+        assert(hierarchyParent !== undefined);
+        hierarchy = { field: hierarchyParent, childFields: [hierarchy] };
+    }
+    return hierarchy;
+}
+function mergeHierarchies(lhs, rhs) {
+    assert(lhs.field.name === rhs.field.name);
+    const result = {
+        field: lhs.field.clone(),
+        childFields: [...lhs.childFields],
+    };
+    rhs.childFields.forEach((rhsChildHierarchy) => {
+        const indexInResult = result.childFields.findIndex((resultHierarchy) => resultHierarchy.field.name === rhsChildHierarchy.field.name);
+        if (indexInResult !== -1)
+            result.childFields[indexInResult] = mergeHierarchies(result.childFields[indexInResult], rhsChildHierarchy);
+        else
+            result.childFields.push(rhsChildHierarchy);
+    });
+    return result;
+}
+/**
+ * Adds a field hierarchy into root field hierarchies list. *
+ * @public
+ */
+export function addFieldHierarchy(rootHierarchies, hierarchy) {
+    const match = findRelatedFields(rootHierarchies, hierarchy);
+    if (!match) {
+        rootHierarchies.push(hierarchy);
+        return;
+    }
+    const targetHierarchy = rootHierarchies[match.existing.index];
+    const existingHierarchy = match.existing.hierarchy ?? buildParentHierarchy(targetHierarchy, match.existing.field);
+    const insertHierarchy = buildParentHierarchy(hierarchy, match.matchingField);
+    const mergedHierarchy = mergeHierarchies(existingHierarchy, insertHierarchy);
+    mergedHierarchy.field.category = hierarchy.field.category;
+    rootHierarchies[match.existing.index] = mergedHierarchy;
+}
+function createFieldPath(field) {
+    const path = [field];
+    let currField = field;
+    while (currField.parent) {
+        currField = currField.parent;
+        path.push(currField);
+    }
+    path.reverse();
+    return path;
+}
+/** @internal */
+export const FIELD_NAMES_SEPARATOR = "$";
+/**
+ * Combines given field names in a way that allows them to be parsed back into a list of individual names using the [[parseCombinedFieldNames]] function.
+ * @public
+ */
+export function combineFieldNames(fieldName, parentFieldName) {
+    return parentFieldName ? `${parentFieldName}${FIELD_NAMES_SEPARATOR}${fieldName}` : fieldName;
+}
+/**
+ * Parses given combined field names string, constructed using [[combineFieldNames]], into a list of individual field names.
+ * @public
+ */
+export function parseCombinedFieldNames(combinedName) {
+    return combinedName ? combinedName.split(FIELD_NAMES_SEPARATOR) : [];
+}
+function convertNestedContentItemToStructArrayItem(item, field, nextField) {
+    const value = item.values[field.name] ?? [];
+    assert(Value.isNestedContent(value));
+    if (value.length === 0)
+        return { emptyNestedItem: true, convertedItem: item };
+    const nextFieldValues = { raw: [], display: [] };
+    value.forEach((ncv) => {
+        const nextRawValue = ncv.values[nextField.name];
+        const nextDisplayValue = ncv.displayValues[nextField.name];
+        if (nextField.isNestedContentField()) {
+            if (nextRawValue) {
+                assert(Value.isNestedContent(nextRawValue));
+                nextFieldValues.raw.push(...nextRawValue);
+            }
+        }
+        else {
+            nextFieldValues.raw.push(nextRawValue);
+            nextFieldValues.display.push(nextDisplayValue);
+        }
+    });
+    const convertedItem = new Item(item.primaryKeys, item.label, item.imageId, item.classInfo, { [nextField.name]: nextFieldValues.raw }, { [nextField.name]: nextFieldValues.display }, item.mergedFieldNames, item.extendedData); // eslint-disable-line deprecation/deprecation
+    return { emptyNestedItem: false, convertedItem };
+}
+function convertNestedContentFieldHierarchyToStructArrayHierarchy(fieldHierarchy, parentFieldName) {
+    const fieldName = fieldHierarchy.field.name;
+    const convertedChildFieldHierarchies = fieldHierarchy.childFields.map((child) => {
+        if (child.field.isNestedContentField())
+            return convertNestedContentFieldHierarchyToStructArrayHierarchy(child, combineFieldNames(fieldName, parentFieldName));
+        return child;
+    });
+    const convertedFieldHierarchy = {
+        field: Object.assign(fieldHierarchy.field.clone(), {
+            type: {
+                valueFormat: PropertyValueFormat.Array,
+                typeName: `${fieldHierarchy.field.type.typeName}[]`,
+                memberType: {
+                    valueFormat: PropertyValueFormat.Struct,
+                    typeName: fieldHierarchy.field.type.typeName,
+                    members: convertedChildFieldHierarchies.map((member) => ({
+                        name: member.field.name,
+                        label: member.field.label,
+                        type: member.field.type,
+                    })),
+                },
+            },
+        }),
+        childFields: convertedChildFieldHierarchies,
+    };
+    return convertedFieldHierarchy;
+}
+function convertNestedContentValuesToStructArrayValuesRecursive(fieldHierarchy, ncvs) {
+    const result = { raw: [], display: [], mergedFieldNames: [] };
+    ncvs.forEach((ncv) => {
+        const values = { ...ncv.values };
+        const displayValues = { ...ncv.displayValues };
+        const mergedFieldNames = [...ncv.mergedFieldNames];
+        fieldHierarchy.childFields.forEach((childFieldHierarchy) => {
+            const childFieldName = childFieldHierarchy.field.name;
+            if (-1 !== ncv.mergedFieldNames.indexOf(childFieldName)) {
+                return;
+            }
+            if (childFieldHierarchy.field.isNestedContentField()) {
+                const value = values[childFieldName];
+                assert(Value.isNestedContent(value));
+                const convertedValues = convertNestedContentValuesToStructArrayValuesRecursive(childFieldHierarchy, value);
+                values[childFieldName] = convertedValues.raw;
+                displayValues[childFieldName] = convertedValues.display;
+                mergedFieldNames.push(...convertedValues.mergedFieldNames);
+            }
+        });
+        result.raw.push(values);
+        result.display.push(displayValues);
+        result.mergedFieldNames.push(...mergedFieldNames);
+    });
+    return result;
+}
+function convertNestedContentFieldHierarchyItemToStructArrayItem(item, fieldHierarchy) {
+    const fieldName = fieldHierarchy.field.name;
+    const rawValue = item.values[fieldName];
+    assert(Value.isNestedContent(rawValue));
+    if (rawValue.length === 0)
+        return { emptyNestedItem: true, convertedItem: item };
+    const converted = convertNestedContentValuesToStructArrayValuesRecursive(fieldHierarchy, rawValue);
+    const convertedItem = new Item(item.primaryKeys, item.label, item.imageId, item.classInfo, { [fieldName]: converted.raw }, { [fieldName]: converted.display }, converted.mergedFieldNames, item.extendedData); // eslint-disable-line deprecation/deprecation
+    return { emptyNestedItem: false, convertedItem };
+}
 //# sourceMappingURL=ContentTraverser.js.map