@itwin/presentation-frontend 4.5.0-dev.0 → 4.5.0-dev.16

package/lib/cjs/presentation-frontend/favorite-properties/FavoritePropertiesManager.js

@@ -1,8 +1,8 @@
 "use strict";
 /*---------------------------------------------------------------------------------------------
-* 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
  */
@@ -36,17 +36,18 @@ class FavoritePropertiesManager {
         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);
         };
@@ -62,10 +63,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,
@@ -74,7 +77,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.
@@ -92,11 +95,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);
         };
@@ -105,30 +112,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: core_common_1.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;
@@ -141,14 +153,16 @@ class FavoritePropertiesManager {
     }
     dispose() {
         // istanbul ignore else
-        if ((0, core_bentley_1.isIDisposable)(this._storage))
+        if ((0, core_bentley_1.isIDisposable)(this._storage)) {
             this._storage.dispose();
+        }
     }
     validateInitialization(imodel) {
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
-        if (!this._imodelProperties.has(getiModelInfo(iTwinId, imodelId)))
+        if (!this._imodelProperties.has(getiModelInfo(iTwinId, imodelId))) {
             throw Error(`Favorite properties are not initialized for iModel: '${imodelId}', in iTwin: '${iTwinId}'. Call initializeConnection() with an IModelConnection to initialize.`);
+        }
     }
     /**
      * Adds favorite properties into a certain scope.
@@ -228,8 +242,9 @@ class FavoritePropertiesManager {
                 favoritesChanged = true;
             }
         }
-        if (!favoritesChanged)
+        if (!favoritesChanged) {
             return;
+        }
         const propertiesOrder = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
         removeOrderInfos(propertiesOrder, (0, exports.createFieldOrderInfos)(field));
         saves.push(this._storage.savePropertiesOrder(propertiesOrder, iTwinId, imodelId));
@@ -261,8 +276,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());
@@ -282,15 +298,16 @@ class FavoritePropertiesManager {
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
         const fieldInfos = (0, exports.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)));
     }
     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;
     }
@@ -317,20 +334,23 @@ class FavoritePropertiesManager {
         this.validateInitialization(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) {
@@ -338,7 +358,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;
@@ -351,8 +373,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);
@@ -362,20 +385,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) => {
@@ -387,13 +414,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();
     }
@@ -429,37 +456,46 @@ 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 */
 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;
 };
 exports.getFieldInfos = getFieldInfos;
 const setHasAny = (set, lookup) => {
     for (const key of lookup) {
-        if (set.has(key))
+        if (set.has(key)) {
             return true;
+        }
     }
     return false;
 };
@@ -472,26 +508,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 */
 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) => ({
@@ -501,28 +540,34 @@ const createFieldOrderInfos = (field) => {
             orderedTimestamp: new Date(),
         }));
     }
-    return [{
+    return [
+        {
             parentClassName: undefined,
             name: field.name,
             priority: 0,
             orderedTimestamp: new Date(),
-        }];
+        },
+    ];
 };
 exports.createFieldOrderInfos = createFieldOrderInfos;
 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