@itwin/appui-react 5.3.1 → 5.4.0

package/lib/appui-react/frontstage/InternalFrontstageManager.js

@@ -5,6 +5,7 @@
 /** @packageDocumentation
  * @module Frontstage
  */
+var _a;
 import { BeUiEvent, Logger } from "@itwin/core-bentley";
 import { IModelApp, InteractiveTool } from "@itwin/core-frontend";
 import { UiFramework } from "../UiFramework.js";
@@ -21,10 +22,11 @@ export class InternalFrontstageManager {
      *  @internal
      */
     static ensureToolInformationIsSet(toolId) {
-        if (!InternalFrontstageManager._toolInformationMap.get(toolId))
-            InternalFrontstageManager._toolInformationMap.set(toolId, 
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            new ToolInformation(toolId));
+        if (this._toolInformationMap.has(toolId))
+            return;
+        this._toolInformationMap.set(toolId, 
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        new ToolInformation(toolId));
     }
     /** Initializes the InternalFrontstageManager
      * @internal
@@ -38,12 +40,12 @@ export class InternalFrontstageManager {
             if (tool instanceof InteractiveTool)
                 UiFramework.toolSettings.initializeDataForTool(tool);
             // if the tool data is not already cached then see if there is data to cache
-            InternalFrontstageManager.ensureToolInformationIsSet(tool.toolId);
-            InternalFrontstageManager.setActiveTool(tool);
+            this.ensureToolInformationIsSet(tool.toolId);
+            UiFramework.frontstages.setActiveTool(tool);
         });
-        UiFramework.toolSettings.onSyncToolSettingsProperties.addListener(InternalFrontstageManager._handleSyncToolSettingsPropertiesEvent);
-        UiFramework.toolSettings.onReloadToolSettingsProperties.addListener(InternalFrontstageManager._handleReloadToolSettingsEvent);
-        IModelApp.viewManager.onSelectedViewportChanged.addListener(InternalFrontstageManager._handleSelectedViewportChanged);
+        UiFramework.toolSettings.onSyncToolSettingsProperties.addListener(this._handleSyncToolSettingsPropertiesEvent);
+        UiFramework.toolSettings.onReloadToolSettingsProperties.addListener(this._handleReloadToolSettingsEvent);
+        IModelApp.viewManager.onSelectedViewportChanged.addListener(this._handleSelectedViewportChanged);
         UiItemsManager.onUiProviderRegisteredEvent.addListener(() => {
             const frontstageDef = UiFramework.frontstages.activeFrontstageDef;
             if (!frontstageDef)
@@ -54,21 +56,21 @@ export class InternalFrontstageManager {
     }
     /** @internal */
     static get isInitialized() {
-        return InternalFrontstageManager._initialized;
+        return this._initialized;
     }
     static set isInitialized(v) {
-        InternalFrontstageManager._initialized = v;
+        this._initialized = v;
     }
     /** Returns true if Frontstage is loading its controls. If false the Frontstage content and controls have been created. */
     static get isLoading() {
-        return InternalFrontstageManager._isLoading;
+        return this._isLoading;
     }
     /** @internal */
     static get nineZoneSize() {
-        return InternalFrontstageManager._nineZoneSize;
+        return this._nineZoneSize;
     }
     static set nineZoneSize(size) {
-        InternalFrontstageManager._nineZoneSize = size;
+        this._nineZoneSize = size;
     }
     /** @internal */
     static get frontstageDefs() {
@@ -77,19 +79,20 @@ export class InternalFrontstageManager {
     /** Clears the Frontstage map.
      */
     static clearFrontstageDefs() {
-        InternalFrontstageManager._frontstageDefs.clear();
-        InternalFrontstageManager._activeFrontstageDef = undefined;
+        this._frontstageDefs.clear();
+        this._activeFrontstageDef = undefined;
     }
     /** Clears the Frontstage Providers and the defs that may have been created from them.
      */
     static clearFrontstageProviders() {
-        InternalFrontstageManager._frontstageProviders.clear();
-        InternalFrontstageManager.clearFrontstageDefs();
+        this._frontstageProviders.clear();
+        UiFramework.frontstages.clearFrontstageDefs();
     }
     /** Clears the Frontstages, Frontstage Providers and the defs that may have been created from them. */
     static clearFrontstages() {
-        InternalFrontstageManager._frontstages.clear();
-        InternalFrontstageManager.clearFrontstageProviders();
+        this._frontstages.clear();
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        UiFramework.frontstages.clearFrontstageProviders();
     }
     static getFrontstageKey(frontstageId) {
         return frontstageId;
@@ -99,25 +102,25 @@ export class InternalFrontstageManager {
         if (!iModelId)
             return;
         const keysToRemove = [];
-        InternalFrontstageManager._frontstageDefs.forEach((_, key) => {
+        this._frontstageDefs.forEach((_, key) => {
             if (key.startsWith(`[${iModelId}]`))
                 keysToRemove.push(key);
         });
         keysToRemove.forEach((keyValue) => {
-            InternalFrontstageManager._frontstageDefs.delete(keyValue);
+            this._frontstageDefs.delete(keyValue);
         });
     }
     static addFrontstageProvider(
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     frontstageProvider) {
-        const key = InternalFrontstageManager.getFrontstageKey(frontstageProvider.id);
-        key && InternalFrontstageManager._frontstageDefs.delete(key);
-        InternalFrontstageManager._frontstageProviders.set(frontstageProvider.id, frontstageProvider);
+        const key = this.getFrontstageKey(frontstageProvider.id);
+        key && this._frontstageDefs.delete(key);
+        this._frontstageProviders.set(frontstageProvider.id, frontstageProvider);
     }
     static addFrontstage(frontstage) {
-        const key = InternalFrontstageManager.getFrontstageKey(frontstage.id);
-        key && InternalFrontstageManager._frontstageDefs.delete(key);
-        InternalFrontstageManager._frontstages.set(frontstage.id, frontstage);
+        const key = this.getFrontstageKey(frontstage.id);
+        key && this._frontstageDefs.delete(key);
+        this._frontstages.set(frontstage.id, frontstage);
     }
     /** Find a loaded Frontstage with a given id. If the id is not provided, the active Frontstage is returned.
      * If the FrontstageDef has not been cached by FrontstageDef then it will not be found. See async function
@@ -126,8 +129,8 @@ export class InternalFrontstageManager {
      * @returns  FrontstageDef with a given id if found, or undefined if not found.
      */
     static findFrontstageDef(id) {
-        const key = InternalFrontstageManager.getFrontstageKey(id);
-        const frontstageDef = InternalFrontstageManager._frontstageDefs.get(key);
+        const key = this.getFrontstageKey(id);
+        const frontstageDef = this._frontstageDefs.get(key);
         if (frontstageDef instanceof FrontstageDef)
             return frontstageDef;
         return undefined;
@@ -138,11 +141,11 @@ export class InternalFrontstageManager {
         if (!id) {
             return undefined;
         }
-        const provider = InternalFrontstageManager._frontstageProviders.get(id);
+        const provider = this._frontstageProviders.get(id);
         if (provider) {
             return provider;
         }
-        const frontstage = InternalFrontstageManager._frontstages.get(id);
+        const frontstage = this._frontstages.get(id);
         if (frontstage) {
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             return new (class extends FrontstageProvider {
@@ -164,16 +167,16 @@ export class InternalFrontstageManager {
      */
     static async getFrontstageDef(id) {
         if (!id)
-            return InternalFrontstageManager.activeFrontstageDef;
-        let frontstageDef = InternalFrontstageManager.findFrontstageDef(id);
+            return UiFramework.frontstages.activeFrontstageDef;
+        let frontstageDef = this.findFrontstageDef(id);
         if (frontstageDef)
             return frontstageDef;
-        const frontstageProvider = InternalFrontstageManager.findFrontstageProvider(id);
+        const frontstageProvider = this.findFrontstageProvider(id);
         if (frontstageProvider) {
             frontstageDef = await FrontstageDef.create(frontstageProvider);
             if (frontstageDef) {
-                const key = InternalFrontstageManager.getFrontstageKey(frontstageDef.id);
-                InternalFrontstageManager._frontstageDefs.set(key, frontstageDef);
+                const key = this.getFrontstageKey(frontstageDef.id);
+                this._frontstageDefs.set(key, frontstageDef);
             }
             return frontstageDef;
         }
@@ -183,19 +186,19 @@ export class InternalFrontstageManager {
      * @return  Active FrontstageDef, or undefined if one is not active.
      */
     static get activeFrontstageDef() {
-        return InternalFrontstageManager._activeFrontstageDef;
+        return this._activeFrontstageDef;
     }
     /** Gets the Id of the active FrontstageDef. If a Frontstage is not active, blank is returned.
      * @return  Id of the active FrontstageDef, or blank if one is not active.
      */
     static get activeFrontstageId() {
-        const activeFrontstage = InternalFrontstageManager._activeFrontstageDef;
+        const activeFrontstage = this._activeFrontstageDef;
         return activeFrontstage ? activeFrontstage.id : "";
     }
     static hasFrontstage(frontstageId) {
-        if (InternalFrontstageManager.findFrontstageDef(frontstageId))
+        if (this.findFrontstageDef(frontstageId))
             return true;
-        if (InternalFrontstageManager.findFrontstageProvider(frontstageId))
+        if (this.findFrontstageProvider(frontstageId))
             return true;
         return false;
     }
@@ -204,26 +207,26 @@ export class InternalFrontstageManager {
      * @returns A Promise that is fulfilled when the Frontstage is ready.
      */
     static async setActiveFrontstage(frontstageId) {
-        const frontstageDef = await InternalFrontstageManager.getFrontstageDef(frontstageId);
+        const frontstageDef = await UiFramework.frontstages.getFrontstageDef(frontstageId);
         if (!frontstageDef) {
             Logger.logError(UiFramework.loggerCategory("InternalFrontstageManager"), `setActiveFrontstage: Could not load a FrontstageDef with id of '${frontstageId}'`);
             return;
         }
-        return InternalFrontstageManager.setActiveFrontstageDef(frontstageDef);
+        return UiFramework.frontstages.setActiveFrontstageDef(frontstageDef);
     }
     /** Sets the active FrontstageDef.
      * @param  frontstageDef  FrontstageDef to set active.
      * @returns A Promise that is fulfilled when the [[FrontstageDef]] is ready.
      */
     static async setActiveFrontstageDef(frontstageDef) {
-        if (InternalFrontstageManager._activeFrontstageDef === frontstageDef)
+        if (this._activeFrontstageDef === frontstageDef)
             return;
-        InternalFrontstageManager._isLoading = true;
-        const deactivatedFrontstageDef = InternalFrontstageManager._activeFrontstageDef;
+        this._isLoading = true;
+        const deactivatedFrontstageDef = this._activeFrontstageDef;
         if (deactivatedFrontstageDef) {
             await deactivatedFrontstageDef.onDeactivated();
             const timeTracker = deactivatedFrontstageDef.timeTracker;
-            InternalFrontstageManager.onFrontstageDeactivatedEvent.emit({
+            UiFramework.frontstages.onFrontstageDeactivatedEvent.emit({
                 deactivatedFrontstageDef,
                 activatedFrontstageDef: frontstageDef,
                 totalTime: timeTracker.getTotalTimeSeconds(),
@@ -231,53 +234,53 @@ export class InternalFrontstageManager {
                 idleTime: timeTracker.getIdleTimeSeconds(),
             });
         }
-        InternalFrontstageManager._activeFrontstageDef = frontstageDef;
+        this._activeFrontstageDef = frontstageDef;
         if (frontstageDef) {
             await frontstageDef.onActivated();
-            InternalFrontstageManager.onFrontstageActivatedEvent.emit({
+            UiFramework.frontstages.onFrontstageActivatedEvent.emit({
                 activatedFrontstageDef: frontstageDef,
                 deactivatedFrontstageDef,
             });
             await frontstageDef.waitUntilReady();
-            InternalFrontstageManager._isLoading = false;
+            this._isLoading = false;
             frontstageDef.onFrontstageReady();
-            InternalFrontstageManager.onFrontstageReadyEvent.emit({ frontstageDef });
+            UiFramework.frontstages.onFrontstageReadyEvent.emit({ frontstageDef });
             UiFramework.visibility.handleFrontstageReady();
             await frontstageDef.setActiveContent();
         }
-        InternalFrontstageManager._isLoading = false;
+        this._isLoading = false;
     }
     /** Deactivates the active FrontstageDef.
      */
     static async deactivateFrontstageDef() {
-        await this.setActiveFrontstageDef(undefined);
+        await UiFramework.frontstages.setActiveFrontstageDef(undefined);
     }
     /** Gets the Id of the active tool. If a tool is not active, blank is returned.
      * @return  Id of the active tool, or blank if one is not active.
      */
     static get activeToolId() {
-        return InternalFrontstageManager._activeToolId;
+        return this._activeToolId;
     }
     /** Sets the active tool id */
     static setActiveToolId(toolId) {
-        InternalFrontstageManager._activeToolId = toolId;
-        const toolSettingsProvider = InternalFrontstageManager.activeToolSettingsProvider;
+        this._activeToolId = toolId;
+        const toolSettingsProvider = this.activeToolSettingsProvider;
         // ensure the toolSettingsProvider is initialized before emitting onToolActivatedEvent
         if (toolSettingsProvider)
             toolSettingsProvider.initialize();
-        InternalFrontstageManager.onToolActivatedEvent.emit({ toolId });
+        UiFramework.frontstages.onToolActivatedEvent.emit({ toolId });
     }
     /** Sets the active tool */
     static setActiveTool(tool) {
-        InternalFrontstageManager.setActiveToolId(tool.toolId);
-        InternalFrontstageManager.onToolIconChangedEvent.emit({
+        UiFramework.frontstages.setActiveToolId(tool.toolId);
+        UiFramework.frontstages.onToolIconChangedEvent.emit({
             iconSpec: tool.iconSpec,
         });
     }
     /** Gets the active tool's [[ToolInformation]] */
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     static get activeToolInformation() {
-        return InternalFrontstageManager._toolInformationMap.get(InternalFrontstageManager.activeToolId);
+        return this._toolInformationMap.get(UiFramework.frontstages.activeToolId);
     }
     /** Gets the Tool Setting React node of the active tool.
      * @return  Tool Setting React node of the active tool, or undefined if there is no active tool or Tool Settings for the active tool.
@@ -285,7 +288,8 @@ export class InternalFrontstageManager {
      */
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     static get activeToolSettingsProvider() {
-        const activeToolInformation = InternalFrontstageManager.activeToolInformation;
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        const activeToolInformation = UiFramework.frontstages.activeToolInformation;
         return activeToolInformation?.toolUiProvider;
     }
     /** Sets the active layout, content group and active content.
@@ -293,16 +297,16 @@ export class InternalFrontstageManager {
      * @param contentGroup  Content Group to make active
      */
     static async setActiveLayout(contentLayoutDef, contentGroup) {
-        const activeFrontstageDef = InternalFrontstageManager.activeFrontstageDef;
+        const activeFrontstageDef = UiFramework.frontstages.activeFrontstageDef;
         if (activeFrontstageDef) {
-            InternalFrontstageManager._isLoading = false;
+            this._isLoading = false;
             activeFrontstageDef.setContentLayoutAndGroup(contentLayoutDef, contentGroup);
-            InternalFrontstageManager.onContentLayoutActivatedEvent.emit({
+            UiFramework.frontstages.onContentLayoutActivatedEvent.emit({
                 contentLayout: contentLayoutDef,
                 contentGroup,
             });
             await activeFrontstageDef.waitUntilReady();
-            InternalFrontstageManager._isLoading = false;
+            this._isLoading = false;
             await activeFrontstageDef.setActiveContent();
         }
     }
@@ -311,13 +315,13 @@ export class InternalFrontstageManager {
      */
     static async setActiveContentGroup(contentGroup) {
         const contentLayoutDef = UiFramework.content.layouts.getForGroup(contentGroup);
-        await InternalFrontstageManager.setActiveLayout(contentLayoutDef, contentGroup);
+        await this.setActiveLayout(contentLayoutDef, contentGroup);
     }
     /** Opens a modal Frontstage. Modal Frontstages can be stacked.
      * @param modalFrontstage  Information about the modal Frontstage
      */
     static openModalFrontstage(modalFrontstage) {
-        InternalFrontstageManager.pushModalFrontstage(modalFrontstage);
+        this.pushModalFrontstage(modalFrontstage);
     }
     static pushModalFrontstage(modalFrontstage) {
         const timeTracker = new TimeTracker();
@@ -326,55 +330,55 @@ export class InternalFrontstageManager {
             modalFrontstage,
             timeTracker,
         };
-        InternalFrontstageManager._modalFrontstages.push(frontstageItem);
-        InternalFrontstageManager.emitModalFrontstageChangedEvent();
+        this._modalFrontstages.push(frontstageItem);
+        this.emitModalFrontstageChangedEvent();
     }
     /** Closes the top-most modal Frontstage.
      */
     static closeModalFrontstage() {
-        if (InternalFrontstageManager._modalFrontstages.length > 0) {
-            const topMostStageItem = InternalFrontstageManager._modalFrontstages[InternalFrontstageManager._modalFrontstages.length - 1];
+        if (this._modalFrontstages.length > 0) {
+            const topMostStageItem = this._modalFrontstages[this._modalFrontstages.length - 1];
             if (topMostStageItem.modalFrontstage.notifyCloseRequest)
-                InternalFrontstageManager.onCloseModalFrontstageRequestedEvent.emit({
+                UiFramework.frontstages.onCloseModalFrontstageRequestedEvent.emit({
                     modalFrontstage: topMostStageItem.modalFrontstage,
-                    stageCloseFunc: InternalFrontstageManager.popModalFrontstage,
+                    stageCloseFunc: () => this.popModalFrontstage(),
                 });
             else
-                InternalFrontstageManager.popModalFrontstage();
+                this.popModalFrontstage();
         }
     }
     static popModalFrontstage() {
-        const frontstageItem = InternalFrontstageManager._modalFrontstages.pop();
+        const frontstageItem = this._modalFrontstages.pop();
         if (frontstageItem) {
             const modalFrontstage = frontstageItem.modalFrontstage;
             const timeTracker = frontstageItem.timeTracker;
             timeTracker.stopTiming();
-            InternalFrontstageManager.onModalFrontstageClosedEvent.emit({
+            UiFramework.frontstages.onModalFrontstageClosedEvent.emit({
                 modalFrontstage,
                 totalTime: timeTracker.getTotalTimeSeconds(),
                 engagementTime: timeTracker.getEngagementTimeSeconds(),
                 idleTime: timeTracker.getIdleTimeSeconds(),
             });
         }
-        InternalFrontstageManager.emitModalFrontstageChangedEvent();
+        this.emitModalFrontstageChangedEvent();
         UiFramework.visibility.handleFrontstageReady();
     }
     static emitModalFrontstageChangedEvent() {
-        InternalFrontstageManager.onModalFrontstageChangedEvent.emit({
-            modalFrontstageCount: InternalFrontstageManager.modalFrontstageCount,
+        UiFramework.frontstages.onModalFrontstageChangedEvent.emit({
+            modalFrontstageCount: UiFramework.frontstages.modalFrontstageCount,
         });
     }
     /** Updates the top-most modal Frontstage.
      */
     static updateModalFrontstage() {
-        InternalFrontstageManager.emitModalFrontstageChangedEvent();
+        this.emitModalFrontstageChangedEvent();
     }
     /** Gets the top-most modal Frontstage.
      * @returns Top-most modal Frontstage, or undefined if there is none.
      */
     static get activeModalFrontstage() {
-        if (InternalFrontstageManager._modalFrontstages.length > 0) {
-            const frontstageItem = InternalFrontstageManager._modalFrontstages[InternalFrontstageManager._modalFrontstages.length - 1];
+        if (this._modalFrontstages.length > 0) {
+            const frontstageItem = this._modalFrontstages[this._modalFrontstages.length - 1];
             const modalFrontstage = frontstageItem.modalFrontstage;
             return modalFrontstage;
         }
@@ -386,14 +390,14 @@ export class InternalFrontstageManager {
      * @returns Modal Frontstage count
      */
     static get modalFrontstageCount() {
-        return InternalFrontstageManager._modalFrontstages.length;
+        return this._modalFrontstages.length;
     }
     /** Sets the active Navigation Aid via its Id.
      * @param navigationAidId  Id of the Navigation Aid to set as active
      * @param iModelConnection IModelConnection to query for view data
      */
     static setActiveNavigationAid(navigationAidId, iModelConnection) {
-        InternalFrontstageManager.onNavigationAidActivatedEvent.emit({
+        UiFramework.frontstages.onNavigationAidActivatedEvent.emit({
             navigationAidId,
             iModelConnection,
         });
@@ -404,7 +408,7 @@ export class InternalFrontstageManager {
      * @returns true if the widget state was set successfully, or false if not.
      */
     static setWidgetState(widgetId, state) {
-        const widgetDef = InternalFrontstageManager.findWidget(widgetId);
+        const widgetDef = UiFramework.frontstages.findWidget(widgetId);
         if (widgetDef) {
             widgetDef.setWidgetState(state);
             return true;
@@ -419,54 +423,54 @@ export class InternalFrontstageManager {
      * @returns The WidgetDef with the given id, or undefined if not found.
      */
     static findWidget(widgetId) {
-        const activeFrontstageDef = InternalFrontstageManager.activeFrontstageDef;
-        if (activeFrontstageDef)
-            return activeFrontstageDef.findWidgetDef(widgetId);
-        return undefined;
+        const activeFrontstageDef = UiFramework.frontstages.activeFrontstageDef;
+        if (!activeFrontstageDef)
+            return undefined;
+        return activeFrontstageDef.findWidgetDef(widgetId);
     }
     /** Opens a nested Frontstage. Nested Frontstages can be stacked.
      * @param nestedFrontstage  Information about the nested Frontstage
      */
     static async openNestedFrontstage(nestedFrontstage) {
-        if (InternalFrontstageManager.nestedFrontstageCount === 0)
-            InternalFrontstageManager._activePrimaryFrontstageDef =
-                InternalFrontstageManager._activeFrontstageDef;
-        InternalFrontstageManager.pushNestedFrontstage(nestedFrontstage);
-        await InternalFrontstageManager.setActiveFrontstageDef(nestedFrontstage);
+        if (UiFramework.frontstages.nestedFrontstageCount === 0)
+            this._activePrimaryFrontstageDef = this._activeFrontstageDef;
+        this.pushNestedFrontstage(nestedFrontstage);
+        await UiFramework.frontstages.setActiveFrontstageDef(nestedFrontstage);
     }
     static pushNestedFrontstage(nestedFrontstage) {
-        InternalFrontstageManager._nestedFrontstages.push(nestedFrontstage);
+        this._nestedFrontstages.push(nestedFrontstage);
     }
     /** Closes the top-most nested Frontstage.
      */
     static async closeNestedFrontstage() {
-        InternalFrontstageManager.popNestedFrontstage();
-        if (InternalFrontstageManager.nestedFrontstageCount > 0) {
-            await InternalFrontstageManager.setActiveFrontstageDef(InternalFrontstageManager.activeNestedFrontstage);
+        this.popNestedFrontstage();
+        if (UiFramework.frontstages.nestedFrontstageCount > 0) {
+            await UiFramework.frontstages.setActiveFrontstageDef(UiFramework.frontstages.activeNestedFrontstage);
         }
         else {
-            await InternalFrontstageManager.setActiveFrontstageDef(InternalFrontstageManager._activePrimaryFrontstageDef);
-            InternalFrontstageManager._activePrimaryFrontstageDef = undefined;
+            await UiFramework.frontstages.setActiveFrontstageDef(this._activePrimaryFrontstageDef);
+            this._activePrimaryFrontstageDef = undefined;
         }
     }
     static popNestedFrontstage() {
-        InternalFrontstageManager._nestedFrontstages.pop();
+        this._nestedFrontstages.pop();
     }
     /** Gets the top-most nested Frontstage.
      * @returns Top-most nested Frontstage, or undefined if there is none.
      */
     static get activeNestedFrontstage() {
-        if (InternalFrontstageManager._nestedFrontstages.length > 0)
-            return InternalFrontstageManager._nestedFrontstages[InternalFrontstageManager._nestedFrontstages.length - 1];
+        if (this._nestedFrontstages.length > 0)
+            return this._nestedFrontstages[this._nestedFrontstages.length - 1];
         return undefined;
     }
     /** Gets the number of nested Frontstages.
      * @returns Nested Frontstage count
      */
     static get nestedFrontstageCount() {
-        return InternalFrontstageManager._nestedFrontstages.length;
+        return this._nestedFrontstages.length;
     }
 }
+_a = InternalFrontstageManager;
 InternalFrontstageManager._initialized = false;
 InternalFrontstageManager._isLoading = false;
 InternalFrontstageManager._activeToolId = "";
@@ -480,23 +484,25 @@ InternalFrontstageManager._nestedFrontstages = new Array();
 // eslint-disable-next-line @typescript-eslint/no-deprecated
 InternalFrontstageManager._toolInformationMap = new Map();
 InternalFrontstageManager._handleSyncToolSettingsPropertiesEvent = (args) => {
-    InternalFrontstageManager.activeToolSettingsProvider &&
-        InternalFrontstageManager.activeToolSettingsProvider.syncToolSettingsProperties(args);
+    const provider = _a.activeToolSettingsProvider;
+    if (!provider)
+        return;
+    provider.syncToolSettingsProperties(args);
 };
 // pass on ReloadToolSettingsEvent from ToolAdmin so they are treated by UiProviders
 InternalFrontstageManager._handleReloadToolSettingsEvent = () => {
-    if (InternalFrontstageManager.activeToolSettingsProvider) {
-        InternalFrontstageManager.activeToolSettingsProvider.reloadPropertiesFromTool();
-    }
+    const provider = _a.activeToolSettingsProvider;
+    if (!provider)
+        return;
+    provider.reloadPropertiesFromTool();
 };
 /** Handles a Viewport change & sets the active view accordingly */
 InternalFrontstageManager._handleSelectedViewportChanged = (args) => {
-    if (args.current &&
-        InternalFrontstageManager.activeFrontstageDef &&
-        !InternalFrontstageManager.isLoading) {
-        // eslint-disable-next-line @typescript-eslint/no-deprecated
-        InternalFrontstageManager.activeFrontstageDef.setActiveViewFromViewport(args.current);
-    }
+    const frontstageDef = _a.activeFrontstageDef;
+    if (!args.current || !frontstageDef || UiFramework.frontstages.isLoading)
+        return;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    frontstageDef.setActiveViewFromViewport(args.current);
 };
 /** Get Frontstage Deactivated event. */
 InternalFrontstageManager.onFrontstageDeactivatedEvent = new BeUiEvent(); // eslint-disable-line @typescript-eslint/no-deprecated