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

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

@@ -1,39 +1,39 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolUiProvider = void 0;
-const ConfigurableUiControl_1 = require("../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
- */
-class ToolUiProvider extends ConfigurableUiControl_1.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 ConfigurableUiControl_1.ConfigurableUiControlType.ToolUiProvider; }
-    syncToolSettingsProperties(_args) { }
-    reloadPropertiesFromTool() { }
-}
-exports.ToolUiProvider = ToolUiProvider;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolUiProvider = void 0;
+const ConfigurableUiControl_1 = require("../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
+ */
+class ToolUiProvider extends ConfigurableUiControl_1.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 ConfigurableUiControl_1.ConfigurableUiControlType.ToolUiProvider; }
+    syncToolSettingsProperties(_args) { }
+    reloadPropertiesFromTool() { }
+}
+exports.ToolUiProvider = ToolUiProvider;
 //# sourceMappingURL=ToolUiProvider.js.map

package/lib/cjs/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/cjs/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/cjs/appui-react/ui-items-provider/AbstractUiItemsManager.js

@@ -0,0 +1,502 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAbstractUiItemsManagerAdapter = void 0;
+/* eslint-disable deprecation/deprecation */
+const abstract = require("@itwin/appui-abstract");
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_react_1 = require("@itwin/core-react");
+const StagePanelLocation_1 = require("../stagepanels/StagePanelLocation");
+const StagePanelSection_1 = require("../stagepanels/StagePanelSection");
+const ToolbarItem_1 = require("../toolbar/ToolbarItem");
+const StatusBarItem_1 = require("../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 */
+function createAbstractUiItemsManagerAdapter() {
+    if (!AbstractUiItemsManager)
+        return undefined;
+    return new AbstractUiItemsManagerAdapter(AbstractUiItemsManager);
+}
+exports.createAbstractUiItemsManagerAdapter = createAbstractUiItemsManagerAdapter;
+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]) => {
+            (0, core_bentley_1.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 = core_react_1.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 ((0, StatusBarItem_1.isStatusBarCustomItem)(item)) {
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            isCustom: true,
+            reactNode: item.content,
+        };
+    }
+    else {
+        const internalData = new Map();
+        const icon = core_react_1.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 = core_react_1.IconHelper.getIconData(item.icon, internalData);
+    if ((0, ToolbarItem_1.isToolbarActionItem)(item)) {
+        abstractItem = {
+            ...item,
+            badgeType: item.badge,
+            icon,
+            internalData,
+            parentToolGroupId: item.parentGroupItemId,
+        };
+    }
+    else if ((0, ToolbarItem_1.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_1.StagePanelLocation.Top]: "top",
+            [StagePanelLocation_1.StagePanelLocation.Left]: "left",
+            [StagePanelLocation_1.StagePanelLocation.Right]: "right",
+            [StagePanelLocation_1.StagePanelLocation.Bottom]: "bottom",
+        };
+        // @ts-ignore Possibly 'any'
+        return map[location];
+    });
+    const internalData = new Map();
+    const icon = core_react_1.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,
+        };
+    }
+    (0, core_bentley_1.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_1.StagePanelLocation.Top,
+            left: StagePanelLocation_1.StagePanelLocation.Left,
+            right: StagePanelLocation_1.StagePanelLocation.Right,
+            bottom: StagePanelLocation_1.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_1.StagePanelLocation.Left;
+        case AbstractStagePanelLocation.Top:
+            return StagePanelLocation_1.StagePanelLocation.Top;
+        case AbstractStagePanelLocation.TopMost:
+            return StagePanelLocation_1.StagePanelLocation.Top;
+        case AbstractStagePanelLocation.Bottom:
+            return StagePanelLocation_1.StagePanelLocation.Bottom;
+        case AbstractStagePanelLocation.BottomMost:
+            return StagePanelLocation_1.StagePanelLocation.Bottom;
+    }
+    return StagePanelLocation_1.StagePanelLocation.Right;
+}
+function toAbstractStagePanelLocation(location) {
+    switch (location) {
+        case StagePanelLocation_1.StagePanelLocation.Left:
+            return [AbstractStagePanelLocation.Left];
+        case StagePanelLocation_1.StagePanelLocation.Top:
+            return [AbstractStagePanelLocation.Top, AbstractStagePanelLocation.TopMost];
+        case StagePanelLocation_1.StagePanelLocation.Bottom:
+            return [AbstractStagePanelLocation.Bottom, AbstractStagePanelLocation.BottomMost];
+    }
+    return [AbstractStagePanelLocation.Right];
+}
+function fromAbstractStagePanelSection(section) {
+    switch (section) {
+        case AbstractStagePanelSection.End:
+            return StagePanelSection_1.StagePanelSection.End;
+    }
+    return StagePanelSection_1.StagePanelSection.Start;
+}
+function toAbstractStagePanelSection(section) {
+    switch (section) {
+        case StagePanelSection_1.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 === core_react_1.IconHelper.reactIconKey && internalData)
+        return internalData.get(core_react_1.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