@itwin/presentation-frontend 5.0.0-dev.10 → 5.0.0-dev.102

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

@@ -5,8 +5,9 @@
 /** @packageDocumentation
  * @module Core
  */
-import { BeEvent, isIDisposable } from "@itwin/core-bentley";
+import { BeEvent, isDisposable, isIDisposable } from "@itwin/core-bentley";
 import { QueryRowFormat } from "@itwin/core-common";
+import { imodelInitializationHandlers } from "../IModelConnectionInitialization.js";
 /**
  * Scopes that favorite properties can be stored in.
  * @public
@@ -24,139 +25,95 @@ export var FavoritePropertiesScope;
  * @public
  */
 export class FavoritePropertiesManager {
+    /** Event raised after favorite properties have changed. */
+    onFavoritesChanged = new BeEvent();
+    storage;
+    _globalProperties;
+    _iTwinProperties;
+    _imodelProperties;
+    _imodelBaseClassesByClass;
+    _imodelInitializationPromises;
+    _imodelInitializationHandler;
+    /** Property order is saved only in iModel scope */
+    _propertiesOrder;
     constructor(props) {
-        /** Event raised after favorite properties have changed. */
-        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._iTwinProperties.has(iTwinId)) {
-                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();
-                this._imodelProperties.set(getiModelInfo(iTwinId, imodelId), imodelProperties);
-            }
-            const propertiesOrder = (await this._storage.loadPropertiesOrder(iTwinId, imodelId)) || [];
-            this._propertiesOrder.set(getiModelInfo(iTwinId, imodelId), propertiesOrder);
-            await this._adjustPropertyOrderInfos(iTwinId, imodelId);
-        };
-        /**
-         * Function that removes order information of properties that are no longer
-         * favorited and adds missing order information for favorited properties.
-         */
-        this._adjustPropertyOrderInfos = async (iTwinId, imodelId) => {
-            const propertiesOrder = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
-            const globalProperties = this._globalProperties;
-            const iTwinProperties = this._iTwinProperties.get(iTwinId);
-            const imodelProperties = this._imodelProperties.get(getiModelInfo(iTwinId, imodelId));
-            // 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)) {
-                    infosToAdd.delete(propertiesOrder[i].name);
-                }
-                else {
-                    propertiesOrder.splice(i, 1);
-                }
-            }
-            infosToAdd.forEach((info) => propertiesOrder.push({
-                name: info,
-                parentClassName: getPropertyClassName(info),
-                orderedTimestamp: new Date(),
-                priority: 0,
-            }));
-            let priority = propertiesOrder.length;
-            propertiesOrder.forEach((oi) => (oi.priority = priority--));
-        };
-        /**
-         * 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.
-         * @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);
-            const iTwinId = imodel.iTwinId;
-            const imodelId = imodel.iModelId;
-            const fieldPriority = new Map();
-            fields.forEach((field) => fieldPriority.set(field, this.getFieldPriority(field, iTwinId, imodelId)));
-            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 fields.sort(sortFunction);
-        };
-        this._getBaseClassesByClass = async (imodel, neededClasses) => {
-            const iTwinId = imodel.iTwinId;
-            const imodelId = imodel.iModelId;
-            const imodelInfo = getiModelInfo(iTwinId, imodelId);
-            let baseClasses;
-            if (this._imodelBaseClassesByClass.has(imodelInfo)) {
-                baseClasses = this._imodelBaseClassesByClass.get(imodelInfo);
-            }
-            else {
-                this._imodelBaseClassesByClass.set(imodelInfo, (baseClasses = {}));
-            }
-            const missingClasses = new Set();
-            neededClasses.forEach((className) => {
-                if (!baseClasses.hasOwnProperty(className)) {
-                    missingClasses.add(className);
-                }
-            });
-            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
-    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)) {
-                    baseClasses[row.classFullName] = [];
-                }
-                baseClasses[row.classFullName].push(row.baseClassFullName);
-            }
-            return baseClasses;
-        };
-        this._storage = props.storage;
+        this.storage = props.storage;
         this._iTwinProperties = new Map();
         this._imodelProperties = new Map();
         this._propertiesOrder = new Map();
         this._imodelBaseClassesByClass = new Map();
         this._imodelInitializationPromises = new Map();
+        imodelInitializationHandlers.add((this._imodelInitializationHandler = {
+            startInitialization: (imodel) => this.startConnectionInitialization(imodel),
+            ensureInitialized: async (imodel) => this.ensureInitialized(imodel),
+        }));
     }
-    dispose() {
-        // istanbul ignore else
-        if (isIDisposable(this._storage)) {
-            this._storage.dispose();
+    [Symbol.dispose]() {
+        imodelInitializationHandlers.delete(this._imodelInitializationHandler);
+        if (isDisposable(this.storage)) {
+            this.storage[Symbol.dispose]();
+            /* c8 ignore next 4 */
+            /* eslint-disable-next-line @typescript-eslint/no-deprecated */
+        }
+        else if (isIDisposable(this.storage)) {
+            this.storage.dispose();
         }
     }
+    /** @deprecated in 5.0 Use [Symbol.dispose] instead. */
+    /* c8 ignore next 3 */
+    dispose() {
+        this[Symbol.dispose]();
+    }
+    /**
+     * 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]].
+     */
+    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._iTwinProperties.has(iTwinId)) {
+            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();
+            this._imodelProperties.set(getiModelInfo(iTwinId, imodelId), imodelProperties);
+        }
+        const propertiesOrder = (await this.storage.loadPropertiesOrder(iTwinId, imodelId)) || [];
+        this._propertiesOrder.set(getiModelInfo(iTwinId, imodelId), propertiesOrder);
+        await this._adjustPropertyOrderInfos(iTwinId, imodelId);
+    };
+    /**
+     * Function that removes order information of properties that are no longer
+     * favorited and adds missing order information for favorited properties.
+     */
+    _adjustPropertyOrderInfos = async (iTwinId, imodelId) => {
+        const propertiesOrder = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
+        const globalProperties = this._globalProperties;
+        const iTwinProperties = this._iTwinProperties.get(iTwinId);
+        const imodelProperties = this._imodelProperties.get(getiModelInfo(iTwinId, imodelId));
+        // 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)) {
+                infosToAdd.delete(propertiesOrder[i].name);
+            }
+            else {
+                propertiesOrder.splice(i, 1);
+            }
+        }
+        infosToAdd.forEach((info) => propertiesOrder.push({
+            name: info,
+            parentClassName: getPropertyClassName(info),
+            orderedTimestamp: new Date(),
+            priority: 0,
+        }));
+        let priority = propertiesOrder.length;
+        propertiesOrder.forEach((oi) => (oi.priority = priority--));
+    };
     isInitialized(imodel) {
         const iTwinId = imodel.iTwinId;
         const imodelId = imodel.iModelId;
@@ -173,20 +130,12 @@ export class FavoritePropertiesManager {
             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 @typescript-eslint/no-deprecated
             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;
@@ -217,15 +166,15 @@ export class FavoritePropertiesManager {
         switch (scope) {
             case FavoritePropertiesScope.Global:
                 favoriteProperties = this._globalProperties;
-                saveProperties = async (properties) => this._storage.saveProperties(properties);
+                saveProperties = async (properties) => this.storage.saveProperties(properties);
                 break;
             case FavoritePropertiesScope.ITwin:
                 favoriteProperties = this._iTwinProperties.get(iTwinId);
-                saveProperties = async (properties) => this._storage.saveProperties(properties, iTwinId);
+                saveProperties = async (properties) => this.storage.saveProperties(properties, iTwinId);
                 break;
             default:
                 favoriteProperties = this._imodelProperties.get(getiModelInfo(iTwinId, imodelId));
-                saveProperties = async (properties) => this._storage.saveProperties(properties, iTwinId, imodelId);
+                saveProperties = async (properties) => this.storage.saveProperties(properties, iTwinId, imodelId);
         }
         const countBefore = favoriteProperties.size;
         const fieldInfos = getFieldInfos(field);
@@ -235,7 +184,7 @@ export class FavoritePropertiesManager {
             saves.push(saveProperties(favoriteProperties));
             const propertiesOrder = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
             addOrderInfos(propertiesOrder, createFieldOrderInfos(field));
-            saves.push(this._storage.savePropertiesOrder(propertiesOrder, iTwinId, imodelId));
+            saves.push(this.storage.savePropertiesOrder(propertiesOrder, iTwinId, imodelId));
             await Promise.all(saves);
             this.onFavoritesChanged.raiseEvent();
         }
@@ -254,18 +203,18 @@ export class FavoritePropertiesManager {
         const workingScopes = [];
         workingScopes.push({
             properties: this._globalProperties,
-            save: async (properties) => this._storage.saveProperties(properties),
+            save: async (properties) => this.storage.saveProperties(properties),
         });
         if (scope === FavoritePropertiesScope.ITwin || scope === FavoritePropertiesScope.IModel) {
             workingScopes.push({
                 properties: this._iTwinProperties.get(iTwinId),
-                save: async (properties) => this._storage.saveProperties(properties, iTwinId),
+                save: async (properties) => this.storage.saveProperties(properties, iTwinId),
             });
         }
         if (scope === FavoritePropertiesScope.IModel) {
             workingScopes.push({
                 properties: this._imodelProperties.get(getiModelInfo(iTwinId, imodelId)),
-                save: async (properties) => this._storage.saveProperties(properties, iTwinId, imodelId),
+                save: async (properties) => this.storage.saveProperties(properties, iTwinId, imodelId),
             });
         }
         const saves = [];
@@ -283,7 +232,7 @@ export class FavoritePropertiesManager {
         }
         const propertiesOrder = this._propertiesOrder.get(getiModelInfo(iTwinId, imodelId));
         removeOrderInfos(propertiesOrder, createFieldOrderInfos(field));
-        saves.push(this._storage.savePropertiesOrder(propertiesOrder, iTwinId, imodelId));
+        saves.push(this.storage.savePropertiesOrder(propertiesOrder, iTwinId, imodelId));
         await Promise.all(saves);
         this.onFavoritesChanged.raiseEvent();
     }
@@ -301,15 +250,15 @@ export class FavoritePropertiesManager {
         switch (scope) {
             case FavoritePropertiesScope.Global:
                 favoriteProperties = this._globalProperties;
-                saveProperties = async () => this._storage.saveProperties(new Set());
+                saveProperties = async () => this.storage.saveProperties(new Set());
                 break;
             case FavoritePropertiesScope.ITwin:
                 favoriteProperties = this._iTwinProperties.get(iTwinId);
-                saveProperties = async () => this._storage.saveProperties(new Set(), iTwinId);
+                saveProperties = async () => this.storage.saveProperties(new Set(), iTwinId);
                 break;
             default:
                 favoriteProperties = this._imodelProperties.get(getiModelInfo(iTwinId, imodelId));
-                saveProperties = async () => this._storage.saveProperties(new Set(), iTwinId, imodelId);
+                saveProperties = async () => this.storage.saveProperties(new Set(), iTwinId, imodelId);
         }
         if (favoriteProperties.size === 0) {
             return;
@@ -349,6 +298,35 @@ export class FavoritePropertiesManager {
         // eslint-disable-next-line @typescript-eslint/no-deprecated
         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.
+     * @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]].
+     */
+    sortFields = (imodel, fields) => {
+        this.validateInitialization(imodel);
+        const iTwinId = imodel.iTwinId;
+        const imodelId = imodel.iModelId;
+        const fieldPriority = new Map();
+        fields.forEach((field) => fieldPriority.set(field, this.getFieldPriority(field, iTwinId, imodelId)));
+        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 fields.sort(sortFunction);
+    };
     /**
      * 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.
@@ -369,6 +347,44 @@ export class FavoritePropertiesManager {
         const mostRecent = getMostRecentOrderInfo(fieldOrderInfos);
         return mostRecent.priority;
     }
+    _getBaseClassesByClass = async (imodel, neededClasses) => {
+        const iTwinId = imodel.iTwinId;
+        const imodelId = imodel.iModelId;
+        const imodelInfo = getiModelInfo(iTwinId, imodelId);
+        let baseClasses;
+        if (this._imodelBaseClassesByClass.has(imodelInfo)) {
+            baseClasses = this._imodelBaseClassesByClass.get(imodelInfo);
+        }
+        else {
+            this._imodelBaseClassesByClass.set(imodelInfo, (baseClasses = {}));
+        }
+        const missingClasses = new Set();
+        neededClasses.forEach((className) => {
+            if (!baseClasses.hasOwnProperty(className)) {
+                missingClasses.add(className);
+            }
+        });
+        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
+    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)) {
+                baseClasses[row.classFullName] = [];
+            }
+            baseClasses[row.classFullName].push(row.baseClassFullName);
+        }
+        return baseClasses;
+    };
     /** Changes field properties priorities to lower than another fields priority
      * @param imodel IModelConnection.
      * @param field Field that priority is being changed.
@@ -478,15 +494,10 @@ export class FavoritePropertiesManager {
         // reassign priority numbers
         let priority = allOrderInfos.length;
         allOrderInfos.forEach((oi) => (oi.priority = priority--));
-        await this._storage.savePropertiesOrder(allOrderInfos, iTwinId, imodelId);
+        await this.storage.savePropertiesOrder(allOrderInfos, iTwinId, imodelId);
         this.onFavoritesChanged.raiseEvent();
     }
 }
-/**
- * Used in tests to avoid collisions between multiple runs using the same storage
- * @internal
- */
-FavoritePropertiesManager.FAVORITES_IDENTIFIER_PREFIX = "";
 var Direction;
 (function (Direction) {
     Direction[Direction["Up"] = -1] = "Up";
@@ -495,11 +506,11 @@ var Direction;
 const getiModelInfo = (iTwinId, imodelId) => `${iTwinId}/${imodelId}`;
 const getPropertiesFieldPropertyNames = (field) => {
     const nestingPrefix = getNestingPrefix(field.parent);
-    return field.properties.map((property) => `${FavoritePropertiesManager.FAVORITES_IDENTIFIER_PREFIX}${nestingPrefix}${property.property.classInfo.name}:${property.property.name}`);
+    return field.properties.map((property) => `${nestingPrefix}${property.property.classInfo.name}:${property.property.name}`);
 };
 const getNestedContentFieldPropertyName = (field) => {
     const nestingPrefix = getNestingPrefix(field);
-    return `${FavoritePropertiesManager.FAVORITES_IDENTIFIER_PREFIX}${nestingPrefix}${field.contentClassInfo.name}`;
+    return `${nestingPrefix}${field.contentClassInfo.name}`;
 };
 const getNestingPrefix = (field) => {
     const path = [];
@@ -542,7 +553,7 @@ export const getFieldInfos = (field) => {
         fieldInfos.add(getNestedContentFieldPropertyName(field));
     }
     else {
-        fieldInfos.add(`${FavoritePropertiesManager.FAVORITES_IDENTIFIER_PREFIX}${field.name}`);
+        fieldInfos.add(field.name);
     }
     return fieldInfos;
 };
@@ -568,7 +579,6 @@ const addOrderInfos = (dest, source) => {
 const removeOrderInfos = (container, toRemove) => {
     toRemove.forEach((roi) => {
         const index = container.findIndex((oi) => oi.name === roi.name);
-        /* istanbul ignore else */
         if (index >= 0) {
             container.splice(index, 1);
         }