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

package/lib/esm/presentation-frontend/favorite-properties/FavoritePropertiesManager.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
  */
@@ -29,21 +29,23 @@ class FavoritePropertiesManager {
         this.onFavoritesChanged = new BeEvent();
         /**
          * Initialize favorite properties for the provided IModelConnection.
+         * @deprecated in 4.5. Initialization is performed automatically by all async methods and only needed for deprecated [[FavoritePropertiesManager.has]] and [[FavoritePropertiesManager.sortFields]].
          */
         this.initializeConnection = async (imodel) => {
             const imodelId = imodel.iModelId;
             const iTwinId = imodel.iTwinId;
-            if (this._globalProperties === undefined)
-                this._globalProperties = await this._storage.loadProperties() || new Set();
+            if (this._globalProperties === undefined) {
+                this._globalProperties = (await this._storage.loadProperties()) || new Set();
+            }
             if (!this._iTwinProperties.has(iTwinId)) {
-                const iTwinProperties = await this._storage.loadProperties(iTwinId) || new Set();
+                const iTwinProperties = (await this._storage.loadProperties(iTwinId)) || new Set();
                 this._iTwinProperties.set(iTwinId, iTwinProperties);
             }
             if (!this._imodelProperties.has(getiModelInfo(iTwinId, imodelId))) {
-                const imodelProperties = await this._storage.loadProperties(iTwinId, imodelId) || new Set();
+                const imodelProperties = (await this._storage.loadProperties(iTwinId, imodelId)) || new Set();
                 this._imodelProperties.set(getiModelInfo(iTwinId, imodelId), imodelProperties);
             }
-            const propertiesOrder = await this._storage.loadPropertiesOrder(iTwinId, imodelId) || [];
+            const propertiesOrder = (await this._storage.loadPropertiesOrder(iTwinId, imodelId)) || [];
             this._propertiesOrder.set(getiModelInfo(iTwinId, imodelId), propertiesOrder);
             await this._adjustPropertyOrderInfos(iTwinId, imodelId);
         };
@@ -59,10 +61,12 @@ class FavoritePropertiesManager {
             // favorite property infos that need to be added to the propertiesOrder array
             const infosToAdd = new Set([...globalProperties, ...iTwinProperties, ...imodelProperties]);
             for (let i = propertiesOrder.length - 1; i >= 0; i--) {
-                if (infosToAdd.has(propertiesOrder[i].name))
+                if (infosToAdd.has(propertiesOrder[i].name)) {
                     infosToAdd.delete(propertiesOrder[i].name);
-                else
+                }
+                else {
                     propertiesOrder.splice(i, 1);
+                }
             }
             infosToAdd.forEach((info) => propertiesOrder.push({
                 name: info,
@@ -71,7 +75,7 @@ class FavoritePropertiesManager {
                 priority: 0,
             }));
             let priority = propertiesOrder.length;
-            propertiesOrder.forEach((oi) => oi.priority = priority--);
+            propertiesOrder.forEach((oi) => (oi.priority = priority--));
         };
         /**
          * Sorts an array of fields with respect to favorite property order.
@@ -79,6 +83,7 @@ class FavoritePropertiesManager {
          * @param imodel IModelConnection.
          * @param fields Array of Field's that needs to be sorted.
          * @note `initializeConnection` must be called with the `imodel` before calling this function.
+         * @deprecated in 4.5. Use [[FavoritePropertiesManager.sortFieldsAsync]] instead. This method is not async, therefore it requires early initialization by calling [[FavoritePropertiesManager.initializeConnection]].
          */
         this.sortFields = (imodel, fields) => {
             this.validateInitialization(imodel);
@@ -89,11 +94,15 @@ class FavoritePropertiesManager {
             const sortFunction = (left, right) => {
                 const lp = fieldPriority.get(left);
                 const rp = fieldPriority.get(right);
-                return lp < rp ? 1 :
-                    lp > rp ? -1 :
-                        left.priority < right.priority ? 1 : // if favorite fields have equal priorities, sort by field priority
-                            left.priority > right.priority ? -1 :
-                                left.name.localeCompare(right.name);
+                return lp < rp
+                    ? 1
+                    : lp > rp
+                        ? -1
+                        : left.priority < right.priority
+                            ? 1 // if favorite fields have equal priorities, sort by field priority
+                            : left.priority > right.priority
+                                ? -1
+                                : left.name.localeCompare(right.name);
             };
             return fields.sort(sortFunction);
         };
@@ -102,30 +111,35 @@ class FavoritePropertiesManager {
             const imodelId = imodel.iModelId;
             const imodelInfo = getiModelInfo(iTwinId, imodelId);
             let baseClasses;
-            if (this._imodelBaseClassesByClass.has(imodelInfo))
+            if (this._imodelBaseClassesByClass.has(imodelInfo)) {
                 baseClasses = this._imodelBaseClassesByClass.get(imodelInfo);
-            else
-                this._imodelBaseClassesByClass.set(imodelInfo, baseClasses = {});
+            }
+            else {
+                this._imodelBaseClassesByClass.set(imodelInfo, (baseClasses = {}));
+            }
             const missingClasses = new Set();
             neededClasses.forEach((className) => {
-                if (!baseClasses.hasOwnProperty(className))
+                if (!baseClasses.hasOwnProperty(className)) {
                     missingClasses.add(className);
+                }
             });
-            if (missingClasses.size === 0)
+            if (missingClasses.size === 0) {
                 return baseClasses;
-            const query = `
-    SELECT (derivedSchema.Name || ':' || derivedClass.Name) AS "ClassFullName", (baseSchema.Name || ':' || baseClass.Name) AS "BaseClassFullName"
-    FROM ECDbMeta.ClassHasAllBaseClasses baseClassRels
-    INNER JOIN ECDbMeta.ECClassDef derivedClass ON derivedClass.ECInstanceId = baseClassRels.SourceECInstanceId
-    INNER JOIN ECDbMeta.ECSchemaDef derivedSchema ON derivedSchema.ECInstanceId = derivedClass.Schema.Id
-    INNER JOIN ECDbMeta.ECClassDef baseClass ON baseClass.ECInstanceId = baseClassRels.TargetECInstanceId
-    INNER JOIN ECDbMeta.ECSchemaDef baseSchema ON baseSchema.ECInstanceId = baseClass.Schema.Id
+            }
+            const query = `
+    SELECT (derivedSchema.Name || ':' || derivedClass.Name) AS "ClassFullName", (baseSchema.Name || ':' || baseClass.Name) AS "BaseClassFullName"
+    FROM ECDbMeta.ClassHasAllBaseClasses baseClassRels
+    INNER JOIN ECDbMeta.ECClassDef derivedClass ON derivedClass.ECInstanceId = baseClassRels.SourceECInstanceId
+    INNER JOIN ECDbMeta.ECSchemaDef derivedSchema ON derivedSchema.ECInstanceId = derivedClass.Schema.Id
+    INNER JOIN ECDbMeta.ECClassDef baseClass ON baseClass.ECInstanceId = baseClassRels.TargetECInstanceId
+    INNER JOIN ECDbMeta.ECSchemaDef baseSchema ON baseSchema.ECInstanceId = baseClass.Schema.Id
     WHERE (derivedSchema.Name || ':' || derivedClass.Name) IN (${[...missingClasses].map((className) => `'${className}'`).join(",")})`;
             const reader = imodel.createQueryReader(query, undefined, { rowFormat: QueryRowFormat.UseJsPropertyNames });
             while (await reader.step()) {
                 const row = reader.current.toRow();
-                if (!(row.classFullName in baseClasses))
+                if (!(row.classFullName in baseClasses)) {
                     baseClasses[row.classFullName] = [];
+                }
                 baseClasses[row.classFullName].push(row.baseClassFullName);
             }
             return baseClasses;
@@ -135,27 +149,67 @@ class FavoritePropertiesManager {
         this._imodelProperties = new Map();
         this._propertiesOrder = new Map();
         this._imodelBaseClassesByClass = new Map();
+        this._imodelInitializationPromises = new Map();
     }
     dispose() {
         // istanbul ignore else
-        if (isIDisposable(this._storage))
+        if (isIDisposable(this._storage)) {
             this._storage.dispose();
+        }
     }
+    isInitialized(imodel) {
+        const iTwinId = imodel.iTwinId;
+        const imodelId = imodel.iModelId;
+        return this._imodelProperties.has(getiModelInfo(iTwinId, imodelId));
+    }
+    /**
+     * Checks if [[FavoritePropertiesManager.initializeConnection]] has been called for a given imodel.
+     * Can be removed when [[FavoritePropertiesManager.has]] and [[FavoritePropertiesManager.sortFields]] are removed.
+     */
     validateInitialization(imodel) {
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
-        if (!this._imodelProperties.has(getiModelInfo(iTwinId, imodelId)))
+        if (!this.isInitialized(imodel)) {
             throw Error(`Favorite properties are not initialized for iModel: '${imodelId}', in iTwin: '${iTwinId}'. Call initializeConnection() with an IModelConnection to initialize.`);
+        }
+    }
+    /**
+     * Calls [[FavoritePropertiesManager.initializeConnection]] and caches the promise which should be awaited by calling [[FavoritePropertiesManager.ensureInitialized]].
+     * @internal
+     */
+    startConnectionInitialization(imodel) {
+        if (!this.isInitialized(imodel) && !this._imodelInitializationPromises.has(imodel)) {
+            // eslint-disable-next-line deprecation/deprecation
+            this._imodelInitializationPromises.set(imodel, this.initializeConnection(imodel));
+        }
+    }
+    /**
+     * Performs the initialization process or finishes the one that was started by [[FavoritePropertiesManager.startConnectionInitialization]].
+     * @internal
+     */
+    async ensureInitialized(imodel) {
+        if (this.isInitialized(imodel)) {
+            return;
+        }
+        let promise = this._imodelInitializationPromises.get(imodel);
+        if (!promise) {
+            // eslint-disable-next-line deprecation/deprecation
+            promise = this.initializeConnection(imodel);
+            // Put the promise in the map to avoid possible multiple initializations from different promises.
+            this._imodelInitializationPromises.set(imodel, promise);
+        }
+        await promise;
+        // Remove this promise from the map, because the next time this method is called, `this.isInitialized` should return true.
+        this._imodelInitializationPromises.delete(imodel);
     }
     /**
      * Adds favorite properties into a certain scope.
      * @param field Field that contains properties. If field contains multiple properties, all of them will be favorited.
      * @param imodel IModelConnection.
      * @param scope FavoritePropertiesScope to put the favorite properties into.
-     * @note `initializeConnection` must be called with the `imodel` before calling this function.
      */
     async add(field, imodel, scope) {
-        this.validateInitialization(imodel);
+        await this.ensureInitialized(imodel);
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
         let favoriteProperties;
@@ -191,10 +245,9 @@ class FavoritePropertiesManager {
      * @param field Field that contains properties. If field contains multiple properties, all of them will be un-favorited.
      * @param imodel IModelConnection.
      * @param scope FavoritePropertiesScope to remove the favorite properties from. It also removes from more general scopes.
-     * @note `initializeConnection` must be called with the `imodel` before calling this function.
      */
     async remove(field, imodel, scope) {
-        this.validateInitialization(imodel);
+        await this.ensureInitialized(imodel);
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
         const fieldInfos = getFieldInfos(field);
@@ -225,8 +278,9 @@ class FavoritePropertiesManager {
                 favoritesChanged = true;
             }
         }
-        if (!favoritesChanged)
+        if (!favoritesChanged) {
             return;
+        }
         const propertiesOrder = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
         removeOrderInfos(propertiesOrder, createFieldOrderInfos(field));
         saves.push(this._storage.savePropertiesOrder(propertiesOrder, iTwinId, imodelId));
@@ -237,10 +291,9 @@ class FavoritePropertiesManager {
      * Removes all favorite properties from a certain scope.
      * @param imodel IModelConnection.
      * @param scope FavoritePropertiesScope to remove the favorite properties from.
-     * @note `initializeConnection` must be called with the `imodel` before calling this function.
      */
     async clear(imodel, scope) {
-        this.validateInitialization(imodel);
+        await this.ensureInitialized(imodel);
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
         let favoriteProperties;
@@ -258,8 +311,9 @@ class FavoritePropertiesManager {
                 favoriteProperties = this._imodelProperties.get(getiModelInfo(iTwinId, imodelId));
                 saveProperties = async () => this._storage.saveProperties(new Set(), iTwinId, imodelId);
         }
-        if (favoriteProperties.size === 0)
+        if (favoriteProperties.size === 0) {
             return;
+        }
         favoriteProperties.clear();
         const saves = [];
         saves.push(saveProperties());
@@ -273,21 +327,45 @@ class FavoritePropertiesManager {
      * @param imodel IModelConnection.
      * @param scope FavoritePropertiesScope to check for favorite properties. It also checks the more general scopes.
      * @note `initializeConnection` must be called with the `imodel` before calling this function.
+     * @deprecated in 4.5. Use [[FavoritePropertiesManager.hasAsync]] instead. This method is not async, therefore it requires early initialization by calling [[FavoritePropertiesManager.initializeConnection]].
      */
     has(field, imodel, scope) {
         this.validateInitialization(imodel);
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
         const fieldInfos = getFieldInfos(field);
-        return setHasAny(this._globalProperties, fieldInfos) ||
+        return (setHasAny(this._globalProperties, fieldInfos) ||
             (scope !== FavoritePropertiesScope.Global && setHasAny(this._iTwinProperties.get(iTwinId), fieldInfos)) ||
-            (scope === FavoritePropertiesScope.IModel && setHasAny(this._imodelProperties.get(getiModelInfo(iTwinId, imodelId)), fieldInfos));
+            (scope === FavoritePropertiesScope.IModel && setHasAny(this._imodelProperties.get(getiModelInfo(iTwinId, imodelId)), fieldInfos)));
+    }
+    /**
+     * Check if field contains at least one favorite property.
+     * @param field Field that contains properties.
+     * @param imodel IModelConnection.
+     * @param scope FavoritePropertiesScope to check for favorite properties. It also checks the more general scopes.
+     */
+    async hasAsync(field, imodel, scope) {
+        await this.ensureInitialized(imodel);
+        // eslint-disable-next-line deprecation/deprecation
+        return this.has(field, imodel, scope);
+    }
+    /**
+     * Sorts an array of fields with respect to favorite property order.
+     * Non-favorited fields get sorted by their default priority and always have lower priority than favorited fields.
+     * @param imodel IModelConnection.
+     * @param fields Array of Field's that needs to be sorted.
+     */
+    async sortFieldsAsync(imodel, fields) {
+        await this.ensureInitialized(imodel);
+        // eslint-disable-next-line deprecation/deprecation
+        return this.sortFields(imodel, fields);
     }
     getFieldPriority(field, iTwinId, imodelId) {
         const orderInfos = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
         const fieldOrderInfos = getFieldOrderInfos(field, orderInfos);
-        if (fieldOrderInfos.length === 0)
+        if (fieldOrderInfos.length === 0) {
             return -1;
+        }
         const mostRecent = getMostRecentOrderInfo(fieldOrderInfos);
         return mostRecent.priority;
     }
@@ -296,7 +374,6 @@ class FavoritePropertiesManager {
      * @param field Field that priority is being changed.
      * @param afterField Field that goes before the moved field. If undefined the moving field is changed to the highest priority (to the top).
      * @param visibleFields Array of fields to move the field in.
-     * @note `initializeConnection` must be called with the `imodel` before calling this function.
      */
     async changeFieldPriority(imodel, field, afterField, visibleFields) {
         /**
@@ -311,23 +388,26 @@ class FavoritePropertiesManager {
          * 4. Irrelevant orderInfos's get moved after `orderInfo` (depends on the direction)
          * 5. All `field` orderInfo's get moved after `afterOrderInfo`
          */
-        this.validateInitialization(imodel);
+        await this.ensureInitialized(imodel);
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
-        if (field === afterField)
+        if (field === afterField) {
             throw Error("`field` can not be the same as `afterField`.");
+        }
         const allOrderInfos = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
         const findFieldOrderInfoData = (f) => {
-            if (!visibleFields.includes(f))
+            if (!visibleFields.includes(f)) {
                 throw Error("Field is not contained in visible fields.");
+            }
             const infos = getFieldOrderInfos(f, allOrderInfos);
-            if (infos.length === 0)
+            if (infos.length === 0) {
                 throw Error("Field has no property order information.");
+            }
             const info = getMostRecentOrderInfo(infos);
             const index = allOrderInfos.indexOf(info);
             return { infos, mostRecent: { info, index } };
         };
-        const { infos: movingOrderInfos, mostRecent: { index: orderInfoIndex } } = findFieldOrderInfoData(field);
+        const { infos: movingOrderInfos, mostRecent: { index: orderInfoIndex }, } = findFieldOrderInfoData(field);
         let afterOrderInfo;
         let afterOrderInfoIndex;
         if (afterField === undefined) {
@@ -335,7 +415,9 @@ class FavoritePropertiesManager {
             afterOrderInfoIndex = -1;
         }
         else {
-            ({ mostRecent: { info: afterOrderInfo, index: afterOrderInfoIndex } } = findFieldOrderInfoData(afterField));
+            ({
+                mostRecent: { info: afterOrderInfo, index: afterOrderInfoIndex },
+            } = findFieldOrderInfoData(afterField));
         }
         let direction; // where to go from `afterOrderInfo` to `orderInfo`
         let startIndex;
@@ -348,8 +430,9 @@ class FavoritePropertiesManager {
             startIndex = afterOrderInfoIndex + 1;
         }
         const neededClassNames = allOrderInfos.reduce((classNames, oi) => {
-            if (oi.parentClassName)
+            if (oi.parentClassName) {
                 classNames.add(oi.parentClassName);
+            }
             return classNames;
         }, new Set());
         const baseClassesByClass = await this._getBaseClassesByClass(imodel, neededClassNames);
@@ -359,20 +442,24 @@ class FavoritePropertiesManager {
         for (let i = startIndex; i !== orderInfoIndex; i += direction) {
             const currOrderInfo = allOrderInfos[i];
             // primitive properties are always relevant, because we can't determine their relevance based on the class hierarchy
-            if (currOrderInfo.parentClassName === undefined)
+            if (currOrderInfo.parentClassName === undefined) {
                 continue;
+            }
             const visible = visibleOrderInfos.includes(currOrderInfo);
             if (visible) {
                 relevantClasses.add(currOrderInfo.parentClassName);
                 continue;
             }
             const hasBaseClasses = baseClassesByClass[currOrderInfo.parentClassName].some((classId) => relevantClasses.has(classId));
-            if (hasBaseClasses)
+            if (hasBaseClasses) {
                 continue;
-            if (direction === Direction.Down)
+            }
+            if (direction === Direction.Down) {
                 irrelevantOrderInfos.push(currOrderInfo);
-            else
+            }
+            else {
                 irrelevantOrderInfos.unshift(currOrderInfo);
+            }
         }
         // remove irrelevantOrderInfo's to add them after the `orderInfo`
         irrelevantOrderInfos.forEach((foi) => {
@@ -384,13 +471,13 @@ class FavoritePropertiesManager {
             const index = allOrderInfos.findIndex((oi) => oi.parentClassName === foi.parentClassName && oi.name === foi.name);
             allOrderInfos.splice(index, 1);
         });
-        movingOrderInfos.forEach((oi) => oi.orderedTimestamp = new Date());
+        movingOrderInfos.forEach((oi) => (oi.orderedTimestamp = new Date()));
         afterOrderInfoIndex = afterOrderInfo === undefined ? -1 : allOrderInfos.indexOf(afterOrderInfo);
         allOrderInfos.splice(afterOrderInfoIndex + 1, 0, ...movingOrderInfos);
         allOrderInfos.splice(afterOrderInfoIndex + 1 + (direction === Direction.Up ? movingOrderInfos.length : 0), 0, ...irrelevantOrderInfos);
         // reassign priority numbers
         let priority = allOrderInfos.length;
-        allOrderInfos.forEach((oi) => oi.priority = priority--);
+        allOrderInfos.forEach((oi) => (oi.priority = priority--));
         await this._storage.savePropertiesOrder(allOrderInfos, iTwinId, imodelId);
         this.onFavoritesChanged.raiseEvent();
     }
@@ -426,36 +513,45 @@ const getNestingPrefix = (field) => {
         });
         curr = curr.parent;
     }
-    if (path.length === 0)
+    if (path.length === 0) {
         return "";
+    }
     path.reverse();
     return `${path.join("-")}-`;
 };
 const getPropertyClassName = (propertyName) => {
     const propertyNameStart = propertyName.split("-")[0];
     const parts = propertyNameStart.split(":").length;
-    if (parts === 1) // primitive
+    if (parts === 1) {
+        // primitive
         return undefined;
-    if (parts === 2) // nested property OR nested property parent class OR regular property parent class
+    }
+    if (parts === 2) {
+        // nested property OR nested property parent class OR regular property parent class
         return propertyNameStart;
+    }
     // regular property without parent class
     return propertyNameStart.substring(0, propertyName.lastIndexOf(":"));
 };
 /** @internal */
 export const getFieldInfos = (field) => {
     const fieldInfos = new Set();
-    if (field.isPropertiesField())
+    if (field.isPropertiesField()) {
         getPropertiesFieldPropertyNames(field).forEach((info) => fieldInfos.add(info));
-    else if (field.isNestedContentField())
+    }
+    else if (field.isNestedContentField()) {
         fieldInfos.add(getNestedContentFieldPropertyName(field));
-    else
+    }
+    else {
         fieldInfos.add(`${FavoritePropertiesManager.FAVORITES_IDENTIFIER_PREFIX}${field.name}`);
+    }
     return fieldInfos;
 };
 const setHasAny = (set, lookup) => {
     for (const key of lookup) {
-        if (set.has(key))
+        if (set.has(key)) {
             return true;
+        }
     }
     return false;
 };
@@ -468,26 +564,29 @@ const addOrderInfos = (dest, source) => {
         }
     });
     let priority = dest.length;
-    dest.forEach((info) => info.priority = priority--);
+    dest.forEach((info) => (info.priority = priority--));
 };
 const removeOrderInfos = (container, toRemove) => {
     toRemove.forEach((roi) => {
         const index = container.findIndex((oi) => oi.name === roi.name);
         /* istanbul ignore else */
-        if (index >= 0)
+        if (index >= 0) {
             container.splice(index, 1);
+        }
     });
 };
 /** @internal */
 export const createFieldOrderInfos = (field) => {
     if (field.isNestedContentField()) {
         const propertyName = getNestedContentFieldPropertyName(field);
-        return [{
+        return [
+            {
                 parentClassName: getPropertyClassName(propertyName),
                 name: propertyName,
                 priority: 0,
                 orderedTimestamp: new Date(),
-            }];
+            },
+        ];
     }
     if (field.isPropertiesField()) {
         return getPropertiesFieldPropertyNames(field).map((propertyName) => ({
@@ -497,27 +596,33 @@ export const createFieldOrderInfos = (field) => {
             orderedTimestamp: new Date(),
         }));
     }
-    return [{
+    return [
+        {
             parentClassName: undefined,
             name: field.name,
             priority: 0,
             orderedTimestamp: new Date(),
-        }];
+        },
+    ];
 };
 const getFieldOrderInfos = (field, orderInfos) => {
     const fieldOrderInfos = [];
     const tryAddOrderInfo = (name) => {
         const fieldOrderInfo = orderInfos.find((oi) => oi.name === name);
-        if (fieldOrderInfo !== undefined)
+        if (fieldOrderInfo !== undefined) {
             fieldOrderInfos.push(fieldOrderInfo);
+        }
     };
-    if (field.isPropertiesField())
+    if (field.isPropertiesField()) {
         getPropertiesFieldPropertyNames(field).forEach(tryAddOrderInfo);
-    else if (field.isNestedContentField())
+    }
+    else if (field.isNestedContentField()) {
         tryAddOrderInfo(getNestedContentFieldPropertyName(field));
-    else
+    }
+    else {
         tryAddOrderInfo(field.name);
+    }
     return fieldOrderInfos;
 };
-const getMostRecentOrderInfo = (orderInfos) => orderInfos.reduce((recent, curr) => (recent && recent.orderedTimestamp >= curr.orderedTimestamp) ? recent : curr);
+const getMostRecentOrderInfo = (orderInfos) => orderInfos.reduce((recent, curr) => (recent && recent.orderedTimestamp >= curr.orderedTimestamp ? recent : curr));
 //# sourceMappingURL=FavoritePropertiesManager.js.map