@itwin/appui-react 4.0.0-dev.8 → 4.0.0

package/lib/esm/appui-react/toolsettings/ToolInformation.js

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Item
+ */
+import { UiError } from "@itwin/appui-abstract";
+import { ConfigurableUiControlType } from "../configurableui/ConfigurableUiControl";
+import { UiFramework } from "../UiFramework";
+/** Provides information about a tool with a given id, including the ToolUiProvider.
+ * @public
+ */
+export class ToolInformation {
+    constructor(toolId) {
+        this.toolId = toolId;
+    }
+    /** Get the ToolUiProvider registered for this tool */
+    get toolUiProvider() {
+        if (!this._toolUiProvider) {
+            let provider;
+            if (UiFramework.controls.isRegistered(this.toolId)) {
+                provider = UiFramework.controls.create(this.toolId, this.toolId);
+            }
+            else {
+                if (UiFramework.toolSettings.useDefaultToolSettingsProvider && this.toolId === UiFramework.toolSettings.toolIdForToolSettings)
+                    provider = UiFramework.controls.create("DefaultToolSettings", this.toolId);
+            }
+            // istanbul ignore else
+            if (provider) {
+                if (provider.getType() !== ConfigurableUiControlType.ToolUiProvider) {
+                    throw new UiError(UiFramework.loggerCategory(this), `toolUiProvider: toolId '${this.toolId}' is registered to a control that is NOT a ToolUiProvider`);
+                }
+                this._toolUiProvider = provider;
+            }
+        }
+        return this._toolUiProvider;
+    }
+}
+//# sourceMappingURL=ToolInformation.js.map

package/lib/esm/appui-react/toolsettings/ToolInformation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolInformation.js","sourceRoot":"","sources":["../../../../src/appui-react/toolsettings/ToolInformation.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C;;GAEG;AACH,MAAM,OAAO,eAAe;IAG1B,YAAmB,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IACjC,CAAC;IAED,sDAAsD;IACtD,IAAW,cAAc;QACvB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACzB,IAAI,QAAoC,CAAC;YAEzC,IAAI,WAAW,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;gBAClD,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAmB,CAAC;aACpF;iBAAM;gBACL,IAAI,WAAW,CAAC,YAAY,CAAC,8BAA8B,IAAI,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC,YAAY,CAAC,qBAAqB;oBAC3H,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,qBAAqB,EAAE,IAAI,CAAC,MAAM,CAAmB,CAAC;aAChG;YACD,uBAAuB;YACvB,IAAI,QAAQ,EAAE;gBACZ,IAAI,QAAQ,CAAC,OAAO,EAAE,KAAK,yBAAyB,CAAC,cAAc,EAAE;oBACnE,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,2BAA2B,IAAI,CAAC,MAAM,2DAA2D,CAAC,CAAC;iBACxJ;gBAED,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;aACjC;SACF;QAED,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;CACF","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Item\r\n */\r\n\r\nimport { UiError } from \"@itwin/appui-abstract\";\r\nimport { ConfigurableUiControlType } from \"../configurableui/ConfigurableUiControl\";\r\nimport { UiFramework } from \"../UiFramework\";\r\nimport { ToolUiProvider } from \"./ToolUiProvider\";\r\n\r\n/** Provides information about a tool with a given id, including the ToolUiProvider.\r\n * @public\r\n */\r\nexport class ToolInformation {\r\n  private _toolUiProvider: ToolUiProvider | undefined;\r\n\r\n  constructor(public toolId: string) {\r\n  }\r\n\r\n  /** Get the ToolUiProvider registered for this tool */\r\n  public get toolUiProvider(): ToolUiProvider | undefined {\r\n    if (!this._toolUiProvider) {\r\n      let provider: ToolUiProvider | undefined;\r\n\r\n      if (UiFramework.controls.isRegistered(this.toolId)) {\r\n        provider = UiFramework.controls.create(this.toolId, this.toolId) as ToolUiProvider;\r\n      } else {\r\n        if (UiFramework.toolSettings.useDefaultToolSettingsProvider && this.toolId === UiFramework.toolSettings.toolIdForToolSettings)\r\n          provider = UiFramework.controls.create(\"DefaultToolSettings\", this.toolId) as ToolUiProvider;\r\n      }\r\n      // istanbul ignore else\r\n      if (provider) {\r\n        if (provider.getType() !== ConfigurableUiControlType.ToolUiProvider) {\r\n          throw new UiError(UiFramework.loggerCategory(this), `toolUiProvider: toolId '${this.toolId}' is registered to a control that is NOT a ToolUiProvider`);\r\n        }\r\n\r\n        this._toolUiProvider = provider;\r\n      }\r\n    }\r\n\r\n    return this._toolUiProvider;\r\n  }\r\n}\r\n"]}

package/lib/esm/appui-react/toolsettings/ToolUiProvider.d.ts

@@ -0,0 +1,36 @@
+/** @packageDocumentation
+ * @module ToolSettings
+ */
+import * as React from "react";
+import { UiDataProvider } from "@itwin/appui-abstract";
+import { ConfigurableCreateInfo, ConfigurableUiControl, ConfigurableUiControlType } from "../configurableui/ConfigurableUiControl";
+import { ToolSettingsEntry } from "../widget-panels/ToolSettings";
+import { SyncToolSettingsPropertiesEventArgs } from "../framework/FrameworkToolSettings";
+/**
+ * ToolUiProvider provides the Tool Settings and/or Tool Assistance UI for a tool.
+ * The ToolUiProvider is registered for the tool id via UiFramework.controls.register.
+ * @public
+ */
+export declare class ToolUiProvider extends ConfigurableUiControl {
+    private _toolSettingsNode;
+    private _horizontalToolSettingNodes;
+    protected _dataProvider: UiDataProvider | undefined;
+    constructor(info: ConfigurableCreateInfo, options: any);
+    get uniqueId(): string;
+    /** A React node that holds tool settings when shown in a rectangular area (i.e. not in Horizontal area at top of application window.) */
+    get toolSettingsNode(): React.ReactNode;
+    set toolSettingsNode(r: React.ReactNode);
+    /** An array of entries to load into the horizontal tool settings
+     * @public
+     */
+    get horizontalToolSettingNodes(): ToolSettingsEntry[] | undefined;
+    set horizontalToolSettingNodes(r: ToolSettingsEntry[] | undefined);
+    /** The UiDataProvider class */
+    get dataProvider(): UiDataProvider | undefined;
+    set dataProvider(d: UiDataProvider | undefined);
+    /** Gets the type of ConfigurableUiControl, which is 'ToolUiProvider' in this case */
+    getType(): ConfigurableUiControlType;
+    syncToolSettingsProperties(_args: SyncToolSettingsPropertiesEventArgs): void;
+    reloadPropertiesFromTool(): void;
+}
+//# sourceMappingURL=ToolUiProvider.d.ts.map

package/lib/esm/appui-react/toolsettings/ToolUiProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolUiProvider.d.ts","sourceRoot":"","sources":["../../../../src/appui-react/toolsettings/ToolUiProvider.tsx"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACnI,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,mCAAmC,EAAE,MAAM,oCAAoC,CAAC;AAEzF;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,qBAAqB;IACvD,OAAO,CAAC,iBAAiB,CAAkB;IAC3C,OAAO,CAAC,2BAA2B,CAAkC;IACrE,SAAS,CAAC,aAAa,EAAE,cAAc,GAAG,SAAS,CAAC;gBACxC,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,GAAG;IAItD,IAAoB,QAAQ,IAAI,MAAM,CAA0D;IAEhG,yIAAyI;IACzI,IAAW,gBAAgB,IAAI,KAAK,CAAC,SAAS,CAAmC;IACjF,IAAW,gBAAgB,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,EAAiC;IAE/E;;OAEG;IACH,IAAW,0BAA0B,IAAI,iBAAiB,EAAE,GAAG,SAAS,CAA6C;IACrH,IAAW,0BAA0B,CAAC,CAAC,EAAE,iBAAiB,EAAE,GAAG,SAAS,EAA2C;IAEnH,+BAA+B;IAC/B,IAAW,YAAY,IAAI,cAAc,GAAG,SAAS,CAA+B;IACpF,IAAW,YAAY,CAAC,CAAC,EAAE,cAAc,GAAG,SAAS,EAA6B;IAElF,qFAAqF;IAC9E,OAAO,IAAI,yBAAyB;IAEpC,0BAA0B,CAAC,KAAK,EAAE,mCAAmC,GAAG,IAAI;IAC5E,wBAAwB,IAAI,IAAI;CACxC"}

package/lib/esm/appui-react/toolsettings/ToolUiProvider.js

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module ToolSettings
+ */
+import { ConfigurableUiControl, ConfigurableUiControlType } from "../configurableui/ConfigurableUiControl";
+/**
+ * ToolUiProvider provides the Tool Settings and/or Tool Assistance UI for a tool.
+ * The ToolUiProvider is registered for the tool id via UiFramework.controls.register.
+ * @public
+ */
+export class ToolUiProvider extends ConfigurableUiControl {
+    constructor(info, options) {
+        super(info, options);
+    }
+    get uniqueId() { return `${this.constructor.name}[${super.uniqueId}]`; }
+    /** A React node that holds tool settings when shown in a rectangular area (i.e. not in Horizontal area at top of application window.) */
+    get toolSettingsNode() { return this._toolSettingsNode; }
+    set toolSettingsNode(r) { this._toolSettingsNode = r; }
+    /** An array of entries to load into the horizontal tool settings
+     * @public
+     */
+    get horizontalToolSettingNodes() { return this._horizontalToolSettingNodes; }
+    set horizontalToolSettingNodes(r) { this._horizontalToolSettingNodes = r; }
+    /** The UiDataProvider class */
+    get dataProvider() { return this._dataProvider; }
+    set dataProvider(d) { this._dataProvider = d; }
+    /** Gets the type of ConfigurableUiControl, which is 'ToolUiProvider' in this case */
+    getType() { return ConfigurableUiControlType.ToolUiProvider; }
+    syncToolSettingsProperties(_args) { }
+    reloadPropertiesFromTool() { }
+}
+//# sourceMappingURL=ToolUiProvider.js.map

package/lib/esm/appui-react/toolsettings/ToolUiProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolUiProvider.js","sourceRoot":"","sources":["../../../../src/appui-react/toolsettings/ToolUiProvider.tsx"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAIH,OAAO,EAA0B,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAInI;;;;GAIG;AACH,MAAM,OAAO,cAAe,SAAQ,qBAAqB;IAIvD,YAAY,IAA4B,EAAE,OAAY;QACpD,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,IAAoB,QAAQ,KAAa,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,IAAI,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;IAEhG,yIAAyI;IACzI,IAAW,gBAAgB,KAAsB,OAAO,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACjF,IAAW,gBAAgB,CAAC,CAAkB,IAAI,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC,CAAC;IAE/E;;OAEG;IACH,IAAW,0BAA0B,KAAsC,OAAO,IAAI,CAAC,2BAA2B,CAAC,CAAC,CAAC;IACrH,IAAW,0BAA0B,CAAC,CAAkC,IAAI,IAAI,CAAC,2BAA2B,GAAG,CAAC,CAAC,CAAC,CAAC;IAEnH,+BAA+B;IAC/B,IAAW,YAAY,KAAiC,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IACpF,IAAW,YAAY,CAAC,CAA6B,IAAI,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC;IAElF,qFAAqF;IAC9E,OAAO,KAAgC,OAAO,yBAAyB,CAAC,cAAc,CAAC,CAAC,CAAC;IAEzF,0BAA0B,CAAC,KAA0C,IAAU,CAAC;IAChF,wBAAwB,KAAW,CAAC;CAC5C","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module ToolSettings\r\n */\r\n\r\nimport * as React from \"react\";\r\nimport { UiDataProvider } from \"@itwin/appui-abstract\";\r\nimport { ConfigurableCreateInfo, ConfigurableUiControl, ConfigurableUiControlType } from \"../configurableui/ConfigurableUiControl\";\r\nimport { ToolSettingsEntry } from \"../widget-panels/ToolSettings\";\r\nimport { SyncToolSettingsPropertiesEventArgs } from \"../framework/FrameworkToolSettings\";\r\n\r\n/**\r\n * ToolUiProvider provides the Tool Settings and/or Tool Assistance UI for a tool.\r\n * The ToolUiProvider is registered for the tool id via UiFramework.controls.register.\r\n * @public\r\n */\r\nexport class ToolUiProvider extends ConfigurableUiControl {\r\n  private _toolSettingsNode: React.ReactNode;\r\n  private _horizontalToolSettingNodes: ToolSettingsEntry[] | undefined;\r\n  protected _dataProvider: UiDataProvider | undefined;\r\n  constructor(info: ConfigurableCreateInfo, options: any) {\r\n    super(info, options);\r\n  }\r\n\r\n  public override get uniqueId(): string { return `${this.constructor.name}[${super.uniqueId}]`; }\r\n\r\n  /** A React node that holds tool settings when shown in a rectangular area (i.e. not in Horizontal area at top of application window.) */\r\n  public get toolSettingsNode(): React.ReactNode { return this._toolSettingsNode; }\r\n  public set toolSettingsNode(r: React.ReactNode) { this._toolSettingsNode = r; }\r\n\r\n  /** An array of entries to load into the horizontal tool settings\r\n   * @public\r\n   */\r\n  public get horizontalToolSettingNodes(): ToolSettingsEntry[] | undefined { return this._horizontalToolSettingNodes; }\r\n  public set horizontalToolSettingNodes(r: ToolSettingsEntry[] | undefined) { this._horizontalToolSettingNodes = r; }\r\n\r\n  /** The UiDataProvider class */\r\n  public get dataProvider(): UiDataProvider | undefined { return this._dataProvider; }\r\n  public set dataProvider(d: UiDataProvider | undefined) { this._dataProvider = d; }\r\n\r\n  /** Gets the type of ConfigurableUiControl, which is 'ToolUiProvider' in this case */\r\n  public getType(): ConfigurableUiControlType { return ConfigurableUiControlType.ToolUiProvider; }\r\n\r\n  public syncToolSettingsProperties(_args: SyncToolSettingsPropertiesEventArgs): void { }\r\n  public reloadPropertiesFromTool(): void { }\r\n}\r\n"]}

package/lib/esm/appui-react/ui-items-provider/AbstractUiItemsManager.d.ts

@@ -0,0 +1,34 @@
+/** @packageDocumentation
+ * @module UiProvider
+ */
+import { BeUiEvent } from "@itwin/core-bentley";
+import type { UiItemsManager as AbstractUiItemsManagerType } from "@itwin/appui-abstract";
+import type { UiItemsManager, UiItemsProviderOverrides, UiItemsProviderRegisteredEventArgs } from "./UiItemsManager";
+import { StagePanelLocation } from "../stagepanels/StagePanelLocation";
+import { StagePanelSection } from "../stagepanels/StagePanelSection";
+import { Widget } from "../widgets/Widget";
+import { ProviderItem } from "./ProviderItem";
+import { UiItemsProvider } from "./UiItemsProvider";
+import { ToolbarItem, ToolbarOrientation, ToolbarUsage } from "../toolbar/ToolbarItem";
+import { BackstageItem } from "../backstage/BackstageItem";
+import { StatusBarItem } from "../statusbar/StatusBarItem";
+/** @internal */
+export declare function createAbstractUiItemsManagerAdapter(): AbstractUiItemsManagerAdapter | undefined;
+type Target = Pick<typeof UiItemsManager, "getWidgets" | "getToolbarButtonItems" | "getStatusBarItems" | "getBackstageItems" | "register" | "getUiItemsProvider" | "registeredProviderIds" | "hasRegisteredProviders" | "unregister" | "onUiProviderRegisteredEvent" | "clearAllProviders">;
+declare class AbstractUiItemsManagerAdapter implements Target {
+    private readonly _adaptee;
+    constructor(_adaptee: typeof AbstractUiItemsManagerType);
+    clearAllProviders(): void;
+    get onUiProviderRegisteredEvent(): BeUiEvent<UiItemsProviderRegisteredEventArgs>;
+    unregister(providerId: string): void;
+    get hasRegisteredProviders(): boolean;
+    get registeredProviderIds(): string[];
+    register(provider: UiItemsProvider, overrides?: UiItemsProviderOverrides | undefined): void;
+    getUiItemsProvider(providerId: string): UiItemsProvider | undefined;
+    getBackstageItems(): readonly ProviderItem<BackstageItem>[];
+    getStatusBarItems(stageId: string, stageUsage: string): readonly ProviderItem<StatusBarItem>[];
+    getToolbarButtonItems(stageId: string, stageUsage: string, usage: ToolbarUsage, orientation: ToolbarOrientation): readonly ProviderItem<ToolbarItem>[];
+    getWidgets(stageId: string, stageUsage: string, location: StagePanelLocation, section?: StagePanelSection | undefined): readonly ProviderItem<Widget>[];
+}
+export {};
+//# sourceMappingURL=AbstractUiItemsManager.d.ts.map

package/lib/esm/appui-react/ui-items-provider/AbstractUiItemsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractUiItemsManager.d.ts","sourceRoot":"","sources":["../../../../src/appui-react/ui-items-provider/AbstractUiItemsManager.ts"],"names":[],"mappings":"AAIA;;GAEG;AAKH,OAAO,EAAU,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAWV,cAAc,IAAI,0BAA0B,EAK7C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,kCAAkC,EAAE,MAAM,kBAAkB,CAAC;AACrH,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAA2C,WAAW,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAChI,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAyB,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAmBlF,gBAAgB;AAChB,wBAAgB,mCAAmC,8CAIlD;AAED,KAAK,MAAM,GAAG,IAAI,CAAC,OAAO,cAAc,EAAE,YAAY,GAAG,uBAAuB,GAAG,mBAAmB,GAAG,mBAAmB,GAAG,UAAU,GAAG,oBAAoB,GAAG,uBAAuB,GAAG,wBAAwB,GAAG,YAAY,GAAG,6BAA6B,GAAG,mBAAmB,CAAC,CAAC;AAE5R,cAAM,6BAA8B,YAAW,MAAM;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,OAAO,0BAA0B;IAGjE,iBAAiB,IAAI,IAAI;IAIhC,IAAW,2BAA2B,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAOtF;IAEM,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAI3C,IAAW,sBAAsB,IAAI,OAAO,CAE3C;IAED,IAAW,qBAAqB,IAAI,MAAM,EAAE,CAE3C;IAEM,QAAQ,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,wBAAwB,GAAG,SAAS,GAAG,IAAI;IAK3F,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IASnE,iBAAiB,IAAI,SAAS,YAAY,CAAC,aAAa,CAAC,EAAE;IAY3D,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,YAAY,CAAC,aAAa,CAAC,EAAE;IAY9F,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,kBAAkB,GAAG,SAAS,YAAY,CAAC,WAAW,CAAC,EAAE;IAYtJ,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,SAAS,GAAG,SAAS,YAAY,CAAC,MAAM,CAAC,EAAE;CA8B/J"}

package/lib/esm/appui-react/ui-items-provider/AbstractUiItemsManager.js

@@ -0,0 +1,498 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module UiProvider
+ */
+/* eslint-disable deprecation/deprecation */
+import * as abstract from "@itwin/appui-abstract";
+import { assert } from "@itwin/core-bentley";
+import { IconHelper } from "@itwin/core-react";
+import { StagePanelLocation } from "../stagepanels/StagePanelLocation";
+import { StagePanelSection } from "../stagepanels/StagePanelSection";
+import { isToolbarActionItem, isToolbarGroupItem } from "../toolbar/ToolbarItem";
+import { isStatusBarCustomItem } from "../statusbar/StatusBarItem";
+// @ts-ignore Removed in 4.0
+const AbstractUiItemsManager = abstract.UiItemsManager;
+// @ts-ignore Removed in 4.0
+const isAbstractStatusBarCustomItem = abstract.isAbstractStatusBarCustomItem;
+// @ts-ignore Removed in 4.0
+const AbstractStagePanelLocation = abstract.StagePanelLocation; // eslint-disable-line @typescript-eslint/no-redeclare
+// @ts-ignore Removed in 4.0
+const AbstractStagePanelSection = abstract.StagePanelSection; // eslint-disable-line @typescript-eslint/no-redeclare
+const AbstractToolbarItemUtilities = abstract.ToolbarItemUtilities;
+const originalDataSymbol = Symbol("originalData");
+/** @internal */
+export function createAbstractUiItemsManagerAdapter() {
+    if (!AbstractUiItemsManager)
+        return undefined;
+    return new AbstractUiItemsManagerAdapter(AbstractUiItemsManager);
+}
+class AbstractUiItemsManagerAdapter {
+    constructor(_adaptee) {
+        this._adaptee = _adaptee;
+    }
+    clearAllProviders() {
+        return this._adaptee.clearAllProviders();
+    }
+    get onUiProviderRegisteredEvent() {
+        if (!("emit" in this._adaptee.onUiProviderRegisteredEvent)) {
+            this._adaptee.onUiProviderRegisteredEvent.emit = (args) => {
+                this._adaptee.onUiProviderRegisteredEvent.raiseEvent(args);
+            };
+        }
+        return this._adaptee.onUiProviderRegisteredEvent;
+    }
+    unregister(providerId) {
+        return this._adaptee.unregister(providerId);
+    }
+    get hasRegisteredProviders() {
+        return this._adaptee.hasRegisteredProviders;
+    }
+    get registeredProviderIds() {
+        return this._adaptee.registeredProviderIds;
+    }
+    register(provider, overrides) {
+        const abstractProvider = new UiItemsProviderToAbstractAdapter(provider);
+        return this._adaptee.register(abstractProvider, overrides);
+    }
+    getUiItemsProvider(providerId) {
+        const abstractProvider = this._adaptee.getUiItemsProvider(providerId);
+        if (!abstractProvider)
+            return undefined;
+        const provider = new AbstractToUiItemsProviderAdapter(abstractProvider);
+        return provider;
+    }
+    getBackstageItems() {
+        const abstractItems = this._adaptee.getBackstageItems();
+        const items = abstractItems.map((abstractItem) => {
+            const item = fromAbstractBackstageItem(abstractItem);
+            return {
+                ...item,
+                providerId: abstractItem.providerId ? abstractItem.providerId : "",
+            };
+        });
+        return items;
+    }
+    getStatusBarItems(stageId, stageUsage) {
+        const abstractItems = this._adaptee.getStatusBarItems(stageId, stageUsage);
+        const items = abstractItems.map((abstractItem) => {
+            const item = fromAbstractStatusBarItem(abstractItem);
+            return {
+                ...item,
+                providerId: abstractItem.providerId ? abstractItem.providerId : "",
+            };
+        });
+        return items;
+    }
+    getToolbarButtonItems(stageId, stageUsage, usage, orientation) {
+        const abstractItems = this._adaptee.getToolbarButtonItems(stageId, stageUsage, usage, orientation);
+        const items = abstractItems.map((abstractItem) => {
+            var _a;
+            const item = fromAbstractToolbarItem(abstractItem);
+            return {
+                ...item,
+                providerId: (_a = abstractItem.providerId) !== null && _a !== void 0 ? _a : "",
+            };
+        });
+        return items;
+    }
+    getWidgets(stageId, stageUsage, location, section) {
+        const abstractLocations = toAbstractStagePanelLocation(location);
+        const abstractSections = section === undefined ? [undefined] : toAbstractStagePanelSection(section);
+        const combos = [];
+        abstractLocations.forEach((abstractLocation) => {
+            abstractSections.forEach((abstractSection) => {
+                combos.push([abstractLocation, abstractSection]);
+            });
+        });
+        let abstractWidgets = combos.reduce((acc, [abstractLocation, abstractSection]) => {
+            const w = this._adaptee.getWidgets(stageId, stageUsage, abstractLocation, abstractSection);
+            acc.push(...w);
+            return acc;
+        }, []);
+        abstractWidgets = abstractWidgets.reduce((acc, abstractWidget) => {
+            if (-1 === acc.findIndex((w) => w.id === abstractWidget.id))
+                acc.push(abstractWidget);
+            return acc;
+        }, []);
+        const widgets = abstractWidgets
+            // @ts-ignore Possibly 'any'
+            .map((abstractWidget) => {
+            var _a;
+            const widget = fromAbstractWidget(abstractWidget);
+            return {
+                ...widget,
+                providerId: (_a = abstractWidget.providerId) !== null && _a !== void 0 ? _a : "",
+            };
+        });
+        return widgets;
+    }
+}
+class UiItemsProviderToAbstractAdapter {
+    get id() {
+        return this._adaptee.id;
+    }
+    constructor(_adaptee) {
+        this._adaptee = _adaptee;
+    }
+    onUnregister() {
+        var _a, _b;
+        (_b = (_a = this._adaptee).onUnregister) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    provideBackstageItems() {
+        if (!this._adaptee.provideBackstageItems)
+            return [];
+        const items = this._adaptee.provideBackstageItems();
+        const abstractItems = items.map((item) => toAbstractBackstageItem(item));
+        return abstractItems;
+    }
+    provideStatusBarItems(stageId, stageUsage, _stageAppData) {
+        if (!this._adaptee.provideStatusBarItems)
+            return [];
+        const items = this._adaptee.provideStatusBarItems(stageId, stageUsage);
+        const abstractItems = items.map((item) => toAbstractStatusBarItem(item));
+        return abstractItems;
+    }
+    provideToolbarButtonItems(stageId, stageUsage, usage, orientation, _stageAppData) {
+        if (!this._adaptee.provideToolbarItems)
+            return [];
+        const items = this._adaptee.provideToolbarItems(stageId, stageUsage, usage, orientation);
+        const abstractItems = items.map((item) => toAbstractToolbarItem(item));
+        return abstractItems;
+    }
+    provideWidgets(stageId, stageUsage, abstractLocation, abstractSection, _zoneLocation, _stageAppData) {
+        if (!this._adaptee.provideWidgets)
+            return [];
+        const location = fromAbstractStagePanelLocation(abstractLocation);
+        const section = abstractSection === undefined ? undefined : fromAbstractStagePanelSection(abstractSection);
+        const widgets = this._adaptee.provideWidgets(stageId, stageUsage, location, section);
+        const abstractWidgets = widgets.map((widget) => toAbstractWidget(widget));
+        return abstractWidgets;
+    }
+}
+class AbstractToUiItemsProviderAdapter {
+    get id() {
+        return this._adaptee.id;
+    }
+    constructor(_adaptee) {
+        this._adaptee = _adaptee;
+    }
+    onUnregister() {
+        var _a, _b;
+        (_b = (_a = this._adaptee).onUnregister) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    provideBackstageItems() {
+        if (!this._adaptee.provideBackstageItems)
+            return [];
+        const abstractItems = this._adaptee.provideBackstageItems();
+        const items = abstractItems.map((abstractItem) => fromAbstractBackstageItem(abstractItem));
+        return items;
+    }
+    provideStatusBarItems(stageId, stageUsage) {
+        if (!this._adaptee.provideStatusBarItems)
+            return [];
+        const abstractItems = this._adaptee.provideStatusBarItems(stageId, stageUsage);
+        const items = abstractItems.map((abstractItem) => fromAbstractStatusBarItem(abstractItem));
+        return items;
+    }
+    provideWidgets(stageId, stageUsage, location, section) {
+        if (!this._adaptee.provideWidgets)
+            return [];
+        const abstractLocations = toAbstractStagePanelLocation(location);
+        const abstractSections = section === undefined ? [undefined] : toAbstractStagePanelSection(section);
+        const combos = [];
+        abstractLocations.forEach((abstractLocation) => {
+            abstractSections.forEach((abstractSection) => {
+                combos.push([abstractLocation, abstractSection]);
+            });
+        });
+        let abstractWidgets = combos.reduce((acc, [abstractLocation, abstractSection]) => {
+            assert(!!this._adaptee.provideWidgets);
+            const w = this._adaptee.provideWidgets(stageId, stageUsage, abstractLocation, abstractSection);
+            acc.push(...w);
+            return acc;
+        }, []);
+        abstractWidgets = abstractWidgets.reduce((acc, abstractWidget) => {
+            if (-1 === acc.findIndex((w) => w.id === abstractWidget.id))
+                acc.push(abstractWidget);
+            return acc;
+        }, []);
+        const widgets = abstractWidgets.map((abstractWidget) => fromAbstractWidget(abstractWidget));
+        return widgets;
+    }
+    provideToolbarItems(stageId, stageUsage, usage, orientation) {
+        if (!this._adaptee.provideToolbarButtonItems)
+            return [];
+        const abstractItems = this._adaptee.provideToolbarButtonItems(stageId, stageUsage, usage, orientation);
+        const items = abstractItems.map((abstractItem) => fromAbstractToolbarItem(abstractItem));
+        return items;
+    }
+}
+function toAbstractBackstageItem(item) {
+    let abstractItem = getOriginalData(item);
+    if (abstractItem)
+        return abstractItem;
+    const internalData = new Map();
+    const icon = IconHelper.getIconData(item.icon, internalData);
+    abstractItem = {
+        ...item,
+        badgeType: item.badge,
+        icon,
+        internalData,
+    };
+    setOriginalData(abstractItem, item);
+    return abstractItem;
+}
+function toAbstractStatusBarItem(item) {
+    let abstractItem = getOriginalData(item);
+    if (abstractItem)
+        return abstractItem;
+    if (isStatusBarCustomItem(item)) {
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            isCustom: true,
+            reactNode: item.content,
+        };
+    }
+    else {
+        const internalData = new Map();
+        const icon = IconHelper.getIconData(item.icon, internalData);
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            icon,
+            internalData,
+        };
+    }
+    setOriginalData(abstractItem, item);
+    return abstractItem;
+}
+function toAbstractToolbarItem(item) {
+    let abstractItem = getOriginalData(item);
+    if (abstractItem)
+        return abstractItem;
+    const internalData = new Map();
+    const icon = IconHelper.getIconData(item.icon, internalData);
+    if (isToolbarActionItem(item)) {
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            icon,
+            internalData,
+            parentToolGroupId: item.parentGroupItemId,
+        };
+    }
+    else if (isToolbarGroupItem(item)) {
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            icon,
+            internalData,
+            parentToolGroupId: item.parentGroupItemId,
+            items: item.items.map((i) => toAbstractToolbarItem(i)),
+        };
+    }
+    else {
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            isCustom: true,
+            icon,
+            internalData,
+        };
+    }
+    setOriginalData(abstractItem, item);
+    return abstractItem;
+}
+function toAbstractWidget(widget) {
+    var _a, _b;
+    let abstractWidget = getOriginalData(widget);
+    if (abstractWidget)
+        return abstractWidget;
+    const allowedPanelTargets = (_a = widget.allowedPanels) === null || _a === void 0 ? void 0 : _a.map((location) => {
+        const map = {
+            [StagePanelLocation.Top]: "top",
+            [StagePanelLocation.Left]: "left",
+            [StagePanelLocation.Right]: "right",
+            [StagePanelLocation.Bottom]: "bottom",
+        };
+        // @ts-ignore Possibly 'any'
+        return map[location];
+    });
+    const internalData = new Map();
+    const icon = IconHelper.getIconData(widget.icon, internalData);
+    abstractWidget = {
+        ...widget,
+        id: (_b = widget.id) !== null && _b !== void 0 ? _b : "",
+        getWidgetContent: () => widget.content,
+        allowedPanelTargets,
+        badgeType: widget.badge,
+        defaultFloatingPosition: typeof widget.canFloat === "object" ? widget.canFloat.defaultPosition : undefined,
+        defaultFloatingSize: typeof widget.canFloat === "object" ? widget.canFloat.defaultSize : undefined,
+        floatingContainerId: typeof widget.canFloat === "object" ? widget.canFloat.containerId : undefined,
+        hideWithUiWhenFloating: typeof widget.canFloat === "object" ? widget.canFloat.hideWithUi : undefined,
+        isFloatingStateSupported: !!widget.canFloat,
+        isFloatingStateWindowResizable: typeof widget.canFloat === "object" ? widget.canFloat.isResizable : undefined,
+        icon,
+        internalData,
+    };
+    setOriginalData(abstractWidget, widget);
+    return abstractWidget;
+}
+function fromAbstractBackstageItem(abstractItem) {
+    let item = getOriginalData(abstractItem);
+    if (item)
+        return item;
+    const icon = fromAbstractIcon(abstractItem.icon, abstractItem.internalData);
+    item = {
+        ...abstractItem,
+        badge: abstractItem.badgeType,
+        icon,
+    };
+    setOriginalData(item, abstractItem);
+    return item;
+}
+function fromAbstractStatusBarItem(abstractItem) {
+    let item = getOriginalData(abstractItem);
+    if (item)
+        return item;
+    if (isAbstractStatusBarCustomItem(abstractItem)) {
+        const content = abstractItem.reactNode;
+        return {
+            ...abstractItem,
+            badge: abstractItem.badgeType,
+            content,
+        };
+    }
+    else {
+        const icon = fromAbstractIcon(abstractItem.icon, abstractItem.internalData);
+        item = {
+            ...abstractItem,
+            badge: abstractItem.badgeType,
+            icon,
+        };
+    }
+    assert(!!item);
+    setOriginalData(item, abstractItem);
+    return item;
+}
+function fromAbstractToolbarItem(abstractItem) {
+    let item = getOriginalData(abstractItem);
+    if (item)
+        return item;
+    const icon = fromAbstractIcon(abstractItem.icon, abstractItem.internalData);
+    if (AbstractToolbarItemUtilities.isCustomDefinition(abstractItem)) {
+        item = {
+            ...abstractItem,
+            badge: abstractItem.badgeType,
+            icon,
+        };
+    }
+    else {
+        item = {
+            ...abstractItem,
+            badge: abstractItem.badgeType,
+            parentGroupItemId: abstractItem.parentToolGroupId,
+            icon,
+        };
+    }
+    setOriginalData(item, abstractItem);
+    return item;
+}
+function fromAbstractWidget(abstractWidget) {
+    var _a, _b;
+    let widget = getOriginalData(abstractWidget);
+    if (widget)
+        return widget;
+    const allowedPanels = (_a = abstractWidget.allowedPanelTargets) === null || _a === void 0 ? void 0 : _a.map((target) => {
+        const map = {
+            top: StagePanelLocation.Top,
+            left: StagePanelLocation.Left,
+            right: StagePanelLocation.Right,
+            bottom: StagePanelLocation.Bottom,
+        };
+        // @ts-ignore Possibly 'any'
+        return map[target];
+    });
+    const icon = fromAbstractIcon(abstractWidget.icon, abstractWidget.internalData);
+    widget = {
+        ...abstractWidget,
+        id: (_b = abstractWidget.id) !== null && _b !== void 0 ? _b : "",
+        content: abstractWidget.getWidgetContent(),
+        allowedPanels,
+        badge: abstractWidget.badgeType,
+        canFloat: abstractWidget.isFloatingStateSupported && {
+            containerId: abstractWidget.floatingContainerId,
+            defaultPosition: abstractWidget.defaultFloatingPosition,
+            defaultSize: abstractWidget.defaultFloatingSize,
+            hideWithUi: abstractWidget.hideWithUiWhenFloating,
+            isResizable: abstractWidget.isFloatingStateWindowResizable,
+        },
+        icon,
+    };
+    setOriginalData(widget, abstractWidget);
+    return widget;
+}
+function fromAbstractStagePanelLocation(location) {
+    switch (location) {
+        case AbstractStagePanelLocation.Left:
+            return StagePanelLocation.Left;
+        case AbstractStagePanelLocation.Top:
+            return StagePanelLocation.Top;
+        case AbstractStagePanelLocation.TopMost:
+            return StagePanelLocation.Top;
+        case AbstractStagePanelLocation.Bottom:
+            return StagePanelLocation.Bottom;
+        case AbstractStagePanelLocation.BottomMost:
+            return StagePanelLocation.Bottom;
+    }
+    return StagePanelLocation.Right;
+}
+function toAbstractStagePanelLocation(location) {
+    switch (location) {
+        case StagePanelLocation.Left:
+            return [AbstractStagePanelLocation.Left];
+        case StagePanelLocation.Top:
+            return [AbstractStagePanelLocation.Top, AbstractStagePanelLocation.TopMost];
+        case StagePanelLocation.Bottom:
+            return [AbstractStagePanelLocation.Bottom, AbstractStagePanelLocation.BottomMost];
+    }
+    return [AbstractStagePanelLocation.Right];
+}
+function fromAbstractStagePanelSection(section) {
+    switch (section) {
+        case AbstractStagePanelSection.End:
+            return StagePanelSection.End;
+    }
+    return StagePanelSection.Start;
+}
+function toAbstractStagePanelSection(section) {
+    switch (section) {
+        case StagePanelSection.End:
+            return [AbstractStagePanelSection.End];
+    }
+    return [AbstractStagePanelSection.Start, AbstractStagePanelSection.Middle];
+}
+function fromAbstractIcon(icon, internalData) {
+    if (!icon)
+        return undefined;
+    const iconString = abstract.ConditionalStringValue.getValue(icon);
+    if (!iconString)
+        return undefined;
+    if (iconString === IconHelper.reactIconKey && internalData)
+        return internalData.get(IconHelper.reactIconKey);
+    return iconString;
+}
+function getOriginalData(obj) {
+    const originalData = obj[originalDataSymbol];
+    if (!originalData)
+        return undefined;
+    return originalData;
+}
+function setOriginalData(obj, data) {
+    obj[originalDataSymbol] = data;
+}
+//# sourceMappingURL=AbstractUiItemsManager.js.map