@sap/ux-ui5-tooling 1.20.4 → 1.22.0

package/dist/preview-middleware/dist/client/adp/dialog-factory.ts

@@ -0,0 +1,210 @@
+import type Dialog from 'sap/m/Dialog';
+import type UI5Element from 'sap/ui/core/Element';
+import Fragment from 'sap/ui/core/Fragment';
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+
+import { getTextBundle } from '../i18n';
+
+import type { AddFragmentOptions } from './controllers/AddFragment.controller';
+import AddFragment from './controllers/AddFragment.controller';
+import AddTableColumnFragments from './controllers/AddTableColumnFragments.controller';
+import ControllerExtension from './controllers/ControllerExtension.controller';
+import ExtensionPoint from './controllers/ExtensionPoint.controller';
+
+import type { ExtensionPointData } from './extension-point';
+import { AddFragmentData } from './add-fragment';
+import { ExtendControllerData } from './extend-controller';
+import FileExistsDialog, { FileExistsDialogOptions } from './controllers/FileExistsDialog.controller';
+import AddSubpage, { AddSubpageOptions } from './controllers/AddSubpage.controller';
+import { QuickActionTelemetryData } from '../cpe/quick-actions/quick-action-definition';
+import AddCustomFragment, { AddCustomFragmentOptions } from './controllers/AddCustomFragment.controller';
+import AddActionFragment, { AddActionOptions } from './controllers/AddActionFragment.controller';
+
+export const enum DialogNames {
+    ADD_FRAGMENT = 'AddFragment',
+    ADD_ACTION = 'AddAction',
+    ADD_TABLE_COLUMN_FRAGMENTS = 'AddTableColumnFragments',
+    CONTROLLER_EXTENSION = 'ControllerExtension',
+    ADD_FRAGMENT_AT_EXTENSION_POINT = 'ExtensionPoint',
+    ADD_CUSTOM_FRAGMENT = 'AddCustomFragment',
+    FILE_EXISTS = 'FileExistsDialog',
+    ADD_SUBPAGE = 'AddSubpage'
+}
+
+type Controller =
+    | AddFragment
+    | AddTableColumnFragments
+    | AddActionFragment
+    | ControllerExtension
+    | ExtensionPoint
+    | FileExistsDialog
+    | AddSubpage
+    | AddCustomFragment;
+
+type DialogData = ExtensionPointData | AddFragmentData | ExtendControllerData;
+
+export const OPEN_DIALOG_STATUS_CHANGED = 'OPEN_DIALOG_STATUS_CHANGED';
+
+export class DialogFactory {
+    private static readonly eventTarget = new EventTarget();
+    private static isDialogOpen = false;
+    /**
+     * Only one dialog can be open at a time. This flag indicates if a new dialog can be opened.
+     */
+
+    public static get canOpenDialog(): boolean {
+        return !this.isDialogOpen;
+    }
+
+    /**
+     * Factory method for creating a new dialog.
+     *
+     * @param overlay - Control overlay.
+     * @param rta - Runtime Authoring instance.
+     * @param dialogName - Dialog name.
+     * @param data - Data to be passed to the dialog.
+     * @param options - Dialog options.
+     * @param telemetryData - Telemetry data.
+     */
+    public static async createDialog(
+        overlay: UI5Element,
+        rta: RuntimeAuthoring,
+        dialogName: DialogNames,
+        data?: DialogData,
+        options:
+            | Partial<AddFragmentOptions>
+            | Partial<FileExistsDialogOptions>
+            | AddCustomFragmentOptions
+            | AddActionOptions
+            | AddSubpageOptions = {},
+        telemetryData?: QuickActionTelemetryData
+    ): Promise<void> {
+        if (this.isDialogOpen) {
+            return;
+        }
+        let controller: Controller;
+        const resources = await getTextBundle();
+
+        switch (dialogName) {
+            case DialogNames.ADD_FRAGMENT:
+                controller = new AddFragment(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    overlay,
+                    rta,
+                    {
+                        ...('aggregation' in options && { aggregation: options.aggregation }),
+                        ...('defaultAggregationArrayIndex' in options && {
+                            defaultAggregationArrayIndex: options.defaultAggregationArrayIndex
+                        }),
+                        title: resources.getText(options.title ?? 'ADP_ADD_FRAGMENT_DIALOG_TITLE')
+                    },
+                    data as AddFragmentData,
+                    telemetryData
+                );
+                break;
+            case DialogNames.ADD_CUSTOM_FRAGMENT:
+                controller = new AddCustomFragment(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    overlay,
+                    rta,
+                    {
+                        ...options,
+                        title: resources.getText(options.title ?? 'ADP_ADD_FRAGMENT_DIALOG_TITLE')
+                    } as AddCustomFragmentOptions
+                );
+                break;
+            case DialogNames.ADD_ACTION:
+                controller = new AddActionFragment(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    overlay,
+                    rta,
+                    {
+                        ...options,
+                        title: resources.getText(options.title ?? 'ADP_ADD_FRAGMENT_DIALOG_TITLE')
+                    } as AddActionOptions
+                );
+                break;
+            case DialogNames.ADD_TABLE_COLUMN_FRAGMENTS:
+                controller = new AddTableColumnFragments(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    overlay,
+                    rta,
+                    {
+                        ...('aggregation' in options && { aggregation: options.aggregation }),
+                        title: resources.getText(options.title ?? 'ADP_ADD_FRAGMENT_DIALOG_TITLE')
+                    },
+                    telemetryData
+                );
+                break;
+            case DialogNames.CONTROLLER_EXTENSION:
+                controller = new ControllerExtension(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    overlay,
+                    rta,
+                    data as ExtendControllerData,
+                    telemetryData
+                );
+                break;
+            case DialogNames.ADD_FRAGMENT_AT_EXTENSION_POINT:
+                controller = new ExtensionPoint(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    overlay,
+                    rta,
+                    data as ExtensionPointData
+                );
+                break;
+            case DialogNames.FILE_EXISTS:
+                controller = new FileExistsDialog(
+                    `open.ux.preview.client.adp.controllers.${dialogName}`,
+                    options as FileExistsDialogOptions
+                );
+                break;
+            case DialogNames.ADD_SUBPAGE:
+                controller = new AddSubpage(`open.ux.preview.client.adp.controllers.${dialogName}`, overlay, rta, {
+                    ...options,
+                    title: resources.getText(options.title ?? 'ADD_SUB_PAGE_DIALOG_TITLE')
+                } as AddSubpageOptions);
+                break;
+        }
+
+        const id = dialogName === DialogNames.ADD_FRAGMENT_AT_EXTENSION_POINT ? `dialog--${dialogName}` : undefined;
+
+        const dialog = (await Fragment.load({
+            name: `open.ux.preview.client.adp.ui.${dialogName}`,
+            controller,
+            id
+        })) as Dialog;
+
+        this.isDialogOpen = true;
+        dialog.attachBeforeClose(() => {
+            this.updateStatus(false);
+        });
+
+        await controller.setup(dialog);
+        this.updateStatus(true);
+    }
+
+    /**
+     * Updates open dialog status.
+     *
+     * @param isDialogOpen Flag indicating if there is an open dialog.
+     */
+    private static updateStatus(isDialogOpen: boolean) {
+        this.isDialogOpen = isDialogOpen;
+        const event = new CustomEvent(OPEN_DIALOG_STATUS_CHANGED);
+        this.eventTarget.dispatchEvent(event);
+    }
+
+    /**
+     * Attach event handler for OPEN_DIALOG_STATUS_CHANGED event.
+     *
+     * @param handler Event handler.
+     * @returns Function that removes listener.
+     */
+    public static onOpenDialogStatusChange(handler: (event: CustomEvent) => void | Promise<void>): () => void {
+        this.eventTarget.addEventListener(OPEN_DIALOG_STATUS_CHANGED, handler as EventListener);
+        return () => {
+            this.eventTarget.removeEventListener(OPEN_DIALOG_STATUS_CHANGED, handler as EventListener);
+        };
+    }
+}

package/dist/preview-middleware/dist/client/adp/extend-controller.js

@@ -0,0 +1,48 @@
+"use strict";
+
+sap.ui.define(["sap/ui/rta/command/CommandFactory", "./utils", "./dialog-factory", "sap/ui/rta/plugin/ExtendControllerPlugin"], function (CommandFactory, ___utils, ___dialog_factory, ExtendController) {
+  "use strict";
+
+  const createDeferred = ___utils["createDeferred"];
+  const DialogFactory = ___dialog_factory["DialogFactory"];
+  const DialogNames = ___dialog_factory["DialogNames"];
+  /**
+   * Initializes the ExtendControllerPlugin and includes it in the Runtime Authoring (RTA) plugins.
+   *
+   * @param rta Runtime Authoring instance
+   */
+  function initExtendControllerPlugin(rta) {
+    const flexSettings = rta.getFlexSettings();
+    const commandFactory = new CommandFactory({
+      flexSettings
+    });
+    const plugin = new ExtendController({
+      commandFactory,
+      handlerFunction: async overlay => await handlerFunction(rta, overlay)
+    });
+    const plugins = rta.getPlugins();
+    plugins.extendControllerPlugin = plugin;
+    rta.setPlugins(plugins);
+  }
+
+  /**
+   * Handles the creation of a controller extension by opening a dialog and resolving the deferred data.
+   *
+   * @param rta Runtime Authoring instance
+   * @param overlay UI5 Element overlay
+   * @returns A promise that resolves with DeferredXmlFragmentData
+   */
+  async function handlerFunction(rta, overlay) {
+    const deferred = createDeferred();
+    await DialogFactory.createDialog(overlay, rta, DialogNames.CONTROLLER_EXTENSION, {
+      deferred
+    });
+    return deferred.promise;
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.initExtendControllerPlugin = initExtendControllerPlugin;
+  return __exports;
+});
+//# sourceMappingURL=extend-controller.js.map

package/dist/preview-middleware/dist/client/adp/extend-controller.ts

@@ -0,0 +1,49 @@
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import type UI5Element from 'sap/ui/core/Element';
+import CommandFactory from 'sap/ui/rta/command/CommandFactory';
+import { Deferred, createDeferred } from './utils';
+import { DialogFactory, DialogNames } from './dialog-factory';
+import ExtendController from 'sap/ui/rta/plugin/ExtendControllerPlugin';
+
+export interface ExtendControllerData {
+    deferred: Deferred<DeferredExtendControllerData>;
+}
+
+export type DeferredExtendControllerData = {
+    codeRef: string;
+    viewId: string;
+};
+
+/**
+ * Initializes the ExtendControllerPlugin and includes it in the Runtime Authoring (RTA) plugins.
+ *
+ * @param rta Runtime Authoring instance
+ */
+export function initExtendControllerPlugin(rta: RuntimeAuthoring): void {
+    const flexSettings = rta.getFlexSettings();
+    const commandFactory = new CommandFactory({ flexSettings });
+
+    const plugin = new ExtendController({
+        commandFactory,
+        handlerFunction: async (overlay: UI5Element) => await handlerFunction(rta, overlay)
+    });
+
+    const plugins = rta.getPlugins();
+    plugins.extendControllerPlugin = plugin;
+    rta.setPlugins(plugins);
+}
+
+/**
+ * Handles the creation of a controller extension by opening a dialog and resolving the deferred data.
+ *
+ * @param rta Runtime Authoring instance
+ * @param overlay UI5 Element overlay
+ * @returns A promise that resolves with DeferredXmlFragmentData
+ */
+async function handlerFunction(rta: RuntimeAuthoring, overlay: UI5Element): Promise<DeferredExtendControllerData> {
+    const deferred = createDeferred<DeferredExtendControllerData>();
+
+    await DialogFactory.createDialog(overlay, rta, DialogNames.CONTROLLER_EXTENSION, { deferred });
+
+    return deferred.promise;
+}

package/dist/preview-middleware/dist/client/adp/extension-point.js

@@ -0,0 +1,83 @@
+"use strict";
+
+sap.ui.define(["sap/ui/rta/plugin/AddXMLAtExtensionPoint", "sap/ui/rta/command/CommandFactory", "open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common", "./utils", "./dialog-factory", "../cpe/communication-service"], function (AddXMLAtExtensionPoint, CommandFactory, ___sap_ux_private_control_property_editor_common, ___utils, ___dialog_factory, ___cpe_communication_service) {
+  "use strict";
+
+  const addExtensionPoint = ___sap_ux_private_control_property_editor_common["addExtensionPoint"];
+  const createDeferred = ___utils["createDeferred"];
+  const DialogFactory = ___dialog_factory["DialogFactory"];
+  const DialogNames = ___dialog_factory["DialogNames"];
+  const CommunicationService = ___cpe_communication_service["CommunicationService"];
+  class ExtensionPointService {
+    actionId = 'CTX_ADDXML_AT_EXTENSIONPOINT';
+    /**
+     * @param rta Runtime Authoring
+     */
+    constructor(rta) {
+      this.rta = rta;
+    }
+
+    /**
+     * Initializes communication with CPE, and the extension point plugin.
+     *
+     */
+    init() {
+      this.initPlugin();
+      CommunicationService.subscribe(async action => {
+        if (addExtensionPoint.match(action)) {
+          try {
+            const {
+              controlId,
+              name
+            } = action.payload;
+            const suffix = `--${name}`;
+            const baseControlId = controlId.endsWith(suffix) ? controlId.slice(0, -suffix.length) : controlId;
+            const service = await this.rta.getService('action');
+            service.execute(baseControlId, this.actionId);
+            this.selectedExtensionPointName = name;
+          } catch {
+            throw new Error(`Failed to execute service with actionId: ${this.actionId}`);
+          }
+        }
+      });
+    }
+
+    /**
+     * Initializes Add XML at Extension Point plugin and adds it to the default RTA plugins.
+     */
+    initPlugin() {
+      const flexSettings = this.rta.getFlexSettings();
+      const commandFactory = new CommandFactory({
+        flexSettings
+      });
+      const plugin = new AddXMLAtExtensionPoint({
+        commandFactory,
+        fragmentHandler: async (overlay, info) => await this.fragmentHandler(overlay, info)
+      });
+      const plugins = this.rta.getPlugins();
+      plugins.addXMLAtExtensionPoint = plugin;
+      this.rta.setPlugins(plugins);
+    }
+
+    /**
+     * Handler function for AddXMLAtExtensionPoint plugin.
+     *
+     * @param overlay UI5 Element overlay
+     * @param info Extension point data from the plugin
+     * @returns Deferred extension point data that is provided to the plugin
+     */
+    async fragmentHandler(overlay, info) {
+      const deferred = createDeferred();
+      const name = this.selectedExtensionPointName;
+      await DialogFactory.createDialog(overlay, this.rta, DialogNames.ADD_FRAGMENT_AT_EXTENSION_POINT, {
+        name,
+        info,
+        deferred
+      });
+      this.selectedExtensionPointName = '';
+      return deferred.promise;
+    }
+  }
+  return ExtensionPointService;
+});
+//# sourceMappingURL=extension-point.js.map

package/dist/preview-middleware/dist/client/adp/extension-point.ts

@@ -0,0 +1,116 @@
+import type View from 'sap/ui/core/mvc/View';
+import type UI5Element from 'sap/ui/core/Element';
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import AddXMLAtExtensionPoint from 'sap/ui/rta/plugin/AddXMLAtExtensionPoint';
+import CommandFactory from 'sap/ui/rta/command/CommandFactory';
+
+import type { ExternalAction } from '@sap-ux-private/control-property-editor-common';
+import { addExtensionPoint } from '@sap-ux-private/control-property-editor-common';
+
+import type { Deferred } from './utils';
+import { createDeferred } from './utils';
+import { DialogFactory, DialogNames } from './dialog-factory';
+
+import { CommunicationService } from '../cpe/communication-service';
+
+type ActionService = {
+    execute: (controlId: string, actionId: string) => void;
+};
+
+type DeferredExtPointData = {
+    fragmentPath: string;
+    extensionPointName: string | undefined;
+};
+
+export interface ExtensionPointInfo {
+    name: string;
+    index?: number;
+    view?: View;
+    createdControls: string[];
+    fragmentId?: string;
+    aggregation?: string[];
+    aggregationName?: string;
+    defaultContent: UI5Element[];
+    targetControl?: UI5Element;
+}
+
+export interface ExtensionPointData {
+    name: string;
+    deferred: Deferred<DeferredExtPointData>;
+    info: ExtensionPointInfo[];
+}
+
+export default class ExtensionPointService {
+    private readonly actionId = 'CTX_ADDXML_AT_EXTENSIONPOINT';
+    private selectedExtensionPointName: string;
+
+    /**
+     * @param rta Runtime Authoring
+     */
+    constructor(private readonly rta: RuntimeAuthoring) {}
+
+    /**
+     * Initializes communication with CPE, and the extension point plugin.
+     *
+     */
+    public init() {
+        this.initPlugin();
+        CommunicationService.subscribe(async (action: ExternalAction): Promise<void> => {
+            if (addExtensionPoint.match(action)) {
+                try {
+                    const { controlId, name } = action.payload;
+
+                    const suffix = `--${name}`;
+                    const baseControlId = controlId.endsWith(suffix) ? controlId.slice(0, -suffix.length) : controlId;
+                    const service = await this.rta.getService<ActionService>('action');
+
+                    service.execute(baseControlId, this.actionId);
+                    this.selectedExtensionPointName = name;
+                } catch {
+                    throw new Error(`Failed to execute service with actionId: ${this.actionId}`);
+                }
+            }
+        });
+    }
+
+    /**
+     * Initializes Add XML at Extension Point plugin and adds it to the default RTA plugins.
+     */
+    public initPlugin() {
+        const flexSettings = this.rta.getFlexSettings();
+        const commandFactory = new CommandFactory({
+            flexSettings
+        });
+
+        const plugin = new AddXMLAtExtensionPoint({
+            commandFactory,
+            fragmentHandler: async (overlay: UI5Element, info: ExtensionPointInfo[]) =>
+                await this.fragmentHandler(overlay, info)
+        });
+
+        const plugins = this.rta.getPlugins();
+        plugins.addXMLAtExtensionPoint = plugin;
+        this.rta.setPlugins(plugins);
+    }
+
+    /**
+     * Handler function for AddXMLAtExtensionPoint plugin.
+     *
+     * @param overlay UI5 Element overlay
+     * @param info Extension point data from the plugin
+     * @returns Deferred extension point data that is provided to the plugin
+     */
+    public async fragmentHandler(overlay: UI5Element, info: ExtensionPointInfo[]): Promise<DeferredExtPointData> {
+        const deferred = createDeferred<DeferredExtPointData>();
+        const name = this.selectedExtensionPointName;
+
+        await DialogFactory.createDialog(overlay, this.rta, DialogNames.ADD_FRAGMENT_AT_EXTENSION_POINT, {
+            name,
+            info,
+            deferred
+        });
+
+        this.selectedExtensionPointName = '';
+        return deferred.promise;
+    }
+}

package/dist/preview-middleware/dist/client/adp/init-dialogs.js

@@ -0,0 +1,142 @@
+"use strict";
+
+sap.ui.define(["sap/ui/rta/util/hasStableId", "sap/ui/fl/Utils", "./dialog-factory", "../i18n", "./utils", "./sync-views-utils"], function (hasStableId, FlUtils, ___dialog_factory, ___i18n, ___utils, ___sync_views_utils) {
+  "use strict";
+
+  const DialogFactory = ___dialog_factory["DialogFactory"];
+  const DialogNames = ___dialog_factory["DialogNames"];
+  const getTextBundle = ___i18n["getTextBundle"];
+  const getReuseComponentChecker = ___utils["getReuseComponentChecker"];
+  const getSyncViewIds = ___sync_views_utils["getSyncViewIds"];
+  /**
+   * Handler for enablement of Extend With Controller context menu entry
+   *
+   * @param control UI5 control.
+   * @param isReuseComponent Function to check if the control is a reuse component.
+   * @param isCloud Whether the application is running in the cloud
+   * @returns boolean whether menu item is enabled or not
+   */
+  function isControllerExtensionEnabledForControl(control, isReuseComponent, isCloud) {
+    const viewId = FlUtils.getViewForControl(control).getId();
+    const syncViewsIds = getSyncViewIds();
+    const isControlInSyncView = syncViewsIds.has(viewId);
+    if (isCloud) {
+      const isClickedControlReuseComponent = isReuseComponent(control.getId());
+      return !isControlInSyncView && !isClickedControlReuseComponent;
+    }
+    return !isControlInSyncView;
+  }
+
+  /**
+   * Handler for enablement of Extend With Controller context menu entry
+   *
+   * @param overlays Control overlays
+   * @param isReuseComponent Function to check if the control is a reuse component.
+   * @param isCloud Whether the application is running in the cloud
+   * @returns boolean whether menu item is enabled or not
+   */
+  const isControllerExtensionEnabled = (overlays, isReuseComponent, isCloud) => {
+    if (overlays.length === 0 || overlays.length > 1) {
+      return false;
+    }
+    return isControllerExtensionEnabledForControl(overlays[0].getElement(), isReuseComponent, isCloud);
+  };
+
+  /**
+   * Determines whether the fragment command should be enabled based on the provided overlays.
+   *
+   * @param {ElementOverlay[]} overlays - An array of ElementOverlay objects representing the UI overlays.
+   * @param {isReuseComponentApi} isReuseComponent - Function to check if the control is a reuse component.
+   * @param {boolean} isCloud - Whether the application is running in the cloud.
+   * @returns {boolean} True if the fragment command is enabled, false otherwise.
+   */
+  const isFragmentCommandEnabled = (overlays, isReuseComponent, isCloud) => {
+    if (overlays.length === 0 || overlays.length > 1) {
+      return false;
+    }
+    const control = overlays[0].getElement();
+    const stableId = hasStableId(overlays[0]);
+    if (isCloud) {
+      return stableId && !isReuseComponent(control.getId());
+    }
+    return stableId;
+  };
+
+  /**
+   * Determines the text that should be displayed for the Add Fragment context menu item.
+   *
+   * @param {ElementOverlay} overlay - An ElementOverlay object representing the UI overlay.
+   * @param {isReuseComponentApi} isReuseComponentChecker - Function to check if the control is a reuse component.
+   * @param {boolean} isCloud - Whether the application is running in the cloud.
+   * @param {TextBundle} resources - The text bundle.
+   * @returns {string} The text of the Add Fragment context menu item.
+   */
+  const getAddFragmentItemText = (overlay, isReuseComponentChecker, isCloud, resources) => {
+    if (isCloud && isReuseComponentChecker(overlay.getElement().getId())) {
+      return resources.getText('ADP_ADD_FRAGMENT_MENU_ITEM_REUSE_COMPONENT');
+    }
+    if (!hasStableId(overlay)) {
+      return resources.getText('ADP_ADD_FRAGMENT_MENU_ITEM_UNSTABLE_ID');
+    }
+    return resources.getText('ADP_ADD_FRAGMENT_MENU_ITEM');
+  };
+
+  /**
+   * Determines the text that should be displayed for Controller Extension context menu item.
+   *
+   * @param {ElementOverlay} overlay - An ElementOverlay object representing the UI overlay.
+   * @param {isReuseComponentApi} isReuseComponentChecker - Function to check if the control is a reuse component.
+   * @param {boolean} isCloud - Whether the application is running in the cloud.
+   * @param {TextBundle} resources - The text bundle.
+   * @returns {string} The text of the Add Fragment context menu item.
+   */
+  const getExtendControllerItemText = (overlay, isReuseComponentChecker, isCloud, resources) => {
+    const viewId = FlUtils.getViewForControl(overlay.getElement()).getId();
+    const syncViewsIds = getSyncViewIds();
+    if (syncViewsIds.has(viewId)) {
+      return resources.getText('ADP_ADD_CONTROLLER_EXTENSION_MENU_ITEM_SYNC_VIEW');
+    }
+    if (isCloud && isReuseComponentChecker(overlay.getElement().getId())) {
+      return resources.getText('ADP_ADD_CONTROLLER_EXTENSION_MENU_ITEM_REUSE_COMPONENT');
+    }
+    return resources.getText('ADP_ADD_CONTROLLER_EXTENSION_MENU_ITEM');
+  };
+
+  /**
+   * Adds a new item to the context menu
+   *
+   * @param rta Runtime Authoring
+   * @param ui5VersionInfo UI5 version information
+   */
+  const initDialogs = async (rta, ui5VersionInfo) => {
+    const contextMenu = rta.getDefaultPlugins().contextMenu;
+    const isCloud = rta.getFlexSettings().isCloud;
+    const resources = await getTextBundle();
+    const isReuseComponentChecker = await getReuseComponentChecker(ui5VersionInfo);
+    contextMenu.addMenuItem({
+      id: 'ADD_FRAGMENT',
+      text: overlay => getAddFragmentItemText(overlay, isReuseComponentChecker, isCloud, resources),
+      handler: async overlays => await DialogFactory.createDialog(overlays[0], rta, DialogNames.ADD_FRAGMENT),
+      icon: 'sap-icon://attachment-html',
+      enabled: overlays => isFragmentCommandEnabled(overlays, isReuseComponentChecker, isCloud)
+    });
+    contextMenu.addMenuItem({
+      id: 'EXTEND_CONTROLLER',
+      text: overlay => getExtendControllerItemText(overlay, isReuseComponentChecker, isCloud, resources),
+      handler: async overlays => await DialogFactory.createDialog(overlays[0], rta, DialogNames.CONTROLLER_EXTENSION),
+      icon: 'sap-icon://create-form',
+      enabled: overlays => isControllerExtensionEnabled(overlays, isReuseComponentChecker, isCloud)
+    });
+  };
+  var __exports = {
+    __esModule: true
+  };
+  __exports.isControllerExtensionEnabledForControl = isControllerExtensionEnabledForControl;
+  __exports.isControllerExtensionEnabled = isControllerExtensionEnabled;
+  __exports.isFragmentCommandEnabled = isFragmentCommandEnabled;
+  __exports.getAddFragmentItemText = getAddFragmentItemText;
+  __exports.getExtendControllerItemText = getExtendControllerItemText;
+  __exports.initDialogs = initDialogs;
+  return __exports;
+});
+//# sourceMappingURL=init-dialogs.js.map