@sap/ux-ui5-tooling 1.20.4 → 1.22.0

package/dist/preview-middleware/dist/client/cpe/quick-actions/quick-action-service.ts

@@ -0,0 +1,184 @@
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import type { ActionService } from 'sap/ui/rta/service/Action';
+import Log from 'sap/base/Log';
+
+import type {
+    ExternalAction,
+    QuickActionExecutionPayload,
+    QuickActionGroup
+} from '@sap-ux-private/control-property-editor-common';
+import {
+    executeQuickAction,
+    quickActionListChanged,
+    SIMPLE_QUICK_ACTION_KIND,
+    NESTED_QUICK_ACTION_KIND,
+    updateQuickAction,
+    externalFileChange,
+    reportTelemetry
+} from '@sap-ux-private/control-property-editor-common';
+
+import type { ActionSenderFunction, ControlTreeIndex, Service, SubscribeFunction } from '../types';
+
+import type {
+    QuickActionActivationContext,
+    QuickActionContext,
+    QuickActionDefinition
+} from './quick-action-definition';
+import type { QuickActionDefinitionRegistry } from './registry';
+import type { OutlineService } from '../outline/service';
+import type { TextBundle } from '../../i18n';
+import { getTextBundle } from '../../i18n';
+import type { ChangeService } from '../changes';
+import { DialogFactory } from '../../adp/dialog-factory';
+import { getApplicationType } from '../../utils/application';
+import { getUi5Version } from '../../utils/version';
+
+/**
+ * Service providing Quick Actions.
+ */
+export class QuickActionService implements Service {
+    private sendAction: ActionSenderFunction = () => {};
+    private readonly actions: QuickActionDefinition[] = [];
+    private controlTreeIndex: ControlTreeIndex;
+
+    private actionService: ActionService;
+    private texts: TextBundle;
+
+    /**
+     * Quick action service constructor.
+     *
+     * @param rta - RTA object.
+     * @param outlineService - Outline service instance.
+     * @param registries - Quick action registries.
+     * @param changeService
+     */
+    constructor(
+        private readonly rta: RuntimeAuthoring,
+        private readonly outlineService: OutlineService,
+        private readonly registries: QuickActionDefinitionRegistry<string>[],
+        private readonly changeService: ChangeService
+    ) {}
+
+    /**
+     * Initialize selection service.
+     *
+     * @param sendAction - Action sender function.
+     * @param subscribe - Subscriber function.
+     */
+    public async init(sendAction: ActionSenderFunction, subscribe: SubscribeFunction): Promise<void> {
+        this.sendAction = sendAction;
+        this.actionService = await this.rta.getService('action');
+        this.texts = await getTextBundle();
+
+        subscribe(async (action: ExternalAction): Promise<void> => {
+            if (executeQuickAction.match(action)) {
+                const actionInstance = this.actions
+                    .findLast((quickActionDefinition) => quickActionDefinition.id === action.payload.id);
+                if (!actionInstance) {
+                    return;
+                }
+                const commands = await this.executeAction(actionInstance, action.payload);
+
+                for (const command of commands) {
+                    await this.rta.getCommandStack().pushAndExecute(command);
+                }
+
+                if (actionInstance.forceRefreshAfterExecution) {
+                    this.sendAction(updateQuickAction(actionInstance.getActionObject()));
+                }
+            }
+            if (externalFileChange.match(action)) {
+                await this.reloadQuickActions(this.controlTreeIndex);
+            }
+        });
+
+        this.outlineService.onOutlineChange(async (event) => {
+            this.controlTreeIndex = event.detail.controlIndex;
+            await this.reloadQuickActions(event.detail.controlIndex);
+        });
+
+        this.changeService.onStackChange(async () => {
+            await this.reloadQuickActions(this.controlTreeIndex);
+        });
+
+        DialogFactory.onOpenDialogStatusChange(async () => {
+            await this.reloadQuickActions(this.controlTreeIndex);
+        });
+    }
+
+    /**
+     * Prepares a list of currently applicable Quick Actions and sends them to the UI.
+     *
+     * @param controlIndex - Control tree index.
+     */
+    public async reloadQuickActions(controlIndex: ControlTreeIndex): Promise<void> {
+        const context: QuickActionActivationContext = {
+            controlIndex,
+            manifest: this.rta.getRootControlInstance().getManifest(),
+            actionService: this.actionService
+        };
+
+        const groups: QuickActionGroup[] = [];
+        for (const registry of this.registries) {
+            for (const { title, definitions, view, key } of registry.getDefinitions(context)) {
+                const group: QuickActionGroup = {
+                    title,
+                    actions: []
+                };
+                const actionContext: QuickActionContext = {
+                    ...context,
+                    view,
+                    key,
+                    rta: this.rta,
+                    flexSettings: this.rta.getFlexSettings(),
+                    resourceBundle: this.texts,
+                    changeService: this.changeService
+                };
+                for (const Definition of definitions) {
+                    try {
+                        const instance = new Definition(actionContext);
+                        await instance.initialize();
+                        await this.addAction(group, instance);
+                    } catch {
+                        Log.warning(`Failed to initialize ${Definition.name} quick action.`);
+                    }
+                }
+                groups.push(group);
+            }
+        }
+
+        this.sendAction(quickActionListChanged(groups));
+    }
+
+    private async addAction(group: QuickActionGroup, instance: QuickActionDefinition): Promise<void> {
+        if (instance.isApplicable) {
+            await instance.runEnablementValidators();
+            const quickAction = instance.getActionObject();
+            group.actions.push(quickAction);
+            this.actions.push(instance);
+        }
+    }
+
+    private async executeAction(actionInstance: QuickActionDefinition, payload: QuickActionExecutionPayload) {
+        try {
+            const versionInfo = await getUi5Version();
+            await reportTelemetry({
+                category: 'QuickAction',
+                actionName: actionInstance.type,
+                telemetryEventIdentifier: actionInstance.getTelemetryIdentifier(true),
+                quickActionSteps: actionInstance.quickActionSteps,
+                appType: getApplicationType(this.rta.getRootControlInstance().getManifest()),
+                ui5Version: `${versionInfo.major}.${versionInfo.minor}.${versionInfo.patch}`
+            });
+        } catch (error) {
+            Log.error('Error in reporting Telemetry:', error);
+        }
+        if (payload.kind === SIMPLE_QUICK_ACTION_KIND && actionInstance.kind === SIMPLE_QUICK_ACTION_KIND) {
+            return actionInstance.execute();
+        }
+        if (payload.kind === NESTED_QUICK_ACTION_KIND && actionInstance.kind === NESTED_QUICK_ACTION_KIND) {
+            return actionInstance.execute(payload.path);
+        }
+        return [];
+    }
+}

package/dist/preview-middleware/dist/client/cpe/quick-actions/registry.js

@@ -0,0 +1,145 @@
+"use strict";
+
+sap.ui.define(["sap/m/NavContainer", "sap/f/FlexibleColumnLayout", "sap/f/library", "sap/base/Log", "sap/ui/core/ComponentContainer", "../../utils/core", "../utils"], function (NavContainer, FlexibleColumnLayout, sap_f_library, Log, ComponentContainer, ____utils_core, ___utils) {
+  "use strict";
+
+  const LayoutType = sap_f_library["LayoutType"];
+  const getControlById = ____utils_core["getControlById"];
+  const getRootControlFromComponentContainer = ___utils["getRootControlFromComponentContainer"];
+  const NAV_CONTAINER_CONTROL_TYPE = 'sap.m.NavContainer';
+  const FLEXIBLE_COLUMN_LAYOUT_CONTROL_TYPE = 'sap.f.FlexibleColumnLayout';
+  /**
+   * Base class for Quick Action definition providers.
+   *
+   */
+  class QuickActionDefinitionRegistry {
+    /**
+     * Mapping of page view name to page type name.
+     */
+    PAGE_NAME_MAP = {};
+
+    /**
+     * Provides a list of Quick Action definitions that are applicable for the given context.
+     *
+     * @param _context - Activation context.
+     */
+    getDefinitions(_context) {
+      throw new Error('Not implemented!');
+    }
+
+    /**
+     * Finds component container from the page control.
+     *
+     * @param page - Page control provided by containers.
+     * @returns ComponentContainer control.
+     */
+    getComponentContainerFromPage(page) {
+      if (page instanceof ComponentContainer) {
+        return page;
+      }
+      return undefined;
+    }
+
+    /**
+     * Returns a list of Active pages based on the provided control index.
+     *
+     * @param controlIndex - Control tree index.
+     * @returns A list of Active pages.
+     */
+    getActivePageContent(controlIndex) {
+      const views = this.getActiveViews(controlIndex);
+      const pages = [];
+      for (const view of views) {
+        const name = view.getViewName();
+        const pageName = this.PAGE_NAME_MAP[name];
+        if (pageName) {
+          pages.push({
+            name: pageName,
+            view
+          });
+        } else {
+          Log.warning(`Could not find matching page for view of type "${name}".`);
+        }
+      }
+      return pages;
+    }
+
+    /**
+     * Get all the root views of currently active pages.
+     *
+     * @param controlIndex - Control index.
+     * @returns List of page root views.
+     */
+    getActiveViews(controlIndex) {
+      const pages = this.getActivePages(controlIndex);
+      const views = [];
+      for (const page of pages) {
+        if (page) {
+          const container = this.getComponentContainerFromPage(page);
+          const rootControl = getRootControlFromComponentContainer(container);
+          if (rootControl) {
+            views.push(rootControl);
+          }
+        }
+      }
+      return views;
+    }
+
+    /**
+     * Finds active page controls from the control tree index.
+     *
+     * @param controlIndex - Control tree index.
+     * @returns A list of page controls.
+     */
+    getActivePages(controlIndex) {
+      const navContainerNode = controlIndex[NAV_CONTAINER_CONTROL_TYPE]?.[0];
+      if (navContainerNode) {
+        const control = getControlById(navContainerNode.controlId);
+        if (control instanceof NavContainer) {
+          return [control.getCurrentPage()];
+        }
+      }
+      const flexibleLayoutNode = controlIndex[FLEXIBLE_COLUMN_LAYOUT_CONTROL_TYPE]?.[0];
+      if (flexibleLayoutNode) {
+        const control = getControlById(flexibleLayoutNode.controlId);
+        if (control instanceof FlexibleColumnLayout) {
+          return this.getVisibleFlexibleColumnLayoutPages(control);
+        }
+      }
+      return [];
+    }
+
+    /**
+     * Finds the visible Flexible Column Layout pages.
+     *
+     * @param control - Flexible Column Layout control.
+     * @returns A list of visible pages.
+     */
+    getVisibleFlexibleColumnLayoutPages(control) {
+      const layout = control.getLayout();
+      switch (layout) {
+        case LayoutType.OneColumn:
+          return [control.getCurrentBeginColumnPage()];
+        case LayoutType.MidColumnFullScreen:
+          return [control.getCurrentMidColumnPage()];
+        case LayoutType.EndColumnFullScreen:
+          return [control.getCurrentEndColumnPage()];
+        case LayoutType.ThreeColumnsBeginExpandedEndHidden:
+        case LayoutType.ThreeColumnsMidExpanded:
+        case LayoutType.ThreeColumnsMidExpandedEndHidden:
+        case LayoutType.ThreeColumnsEndExpanded:
+          return [control.getCurrentBeginColumnPage(), control.getCurrentMidColumnPage(), control.getCurrentEndColumnPage()];
+        case LayoutType.TwoColumnsMidExpanded:
+        case LayoutType.TwoColumnsBeginExpanded:
+          return [control.getCurrentBeginColumnPage(), control.getCurrentMidColumnPage()];
+      }
+      return [];
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.QuickActionDefinitionRegistry = QuickActionDefinitionRegistry;
+  return __exports;
+});
+//# sourceMappingURL=registry.js.map

package/dist/preview-middleware/dist/client/cpe/quick-actions/registry.ts

@@ -0,0 +1,157 @@
+import NavContainer from 'sap/m/NavContainer';
+import FlexibleColumnLayout from 'sap/f/FlexibleColumnLayout';
+import { LayoutType } from 'sap/f/library';
+import type Control from 'sap/ui/core/Control';
+import type XMLView from 'sap/ui/core/mvc/XMLView';
+import Log from 'sap/base/Log';
+import ComponentContainer from 'sap/ui/core/ComponentContainer';
+
+import type { QuickActionActivationContext, QuickActionDefinitionGroup } from './quick-action-definition';
+
+import type { ControlTreeIndex } from '../types';
+import { getControlById } from '../../utils/core';
+import { getRootControlFromComponentContainer } from '../utils';
+
+const NAV_CONTAINER_CONTROL_TYPE = 'sap.m.NavContainer';
+const FLEXIBLE_COLUMN_LAYOUT_CONTROL_TYPE = 'sap.f.FlexibleColumnLayout';
+
+export interface ActivePage<T extends string> {
+    name: T;
+    view: XMLView;
+}
+
+/**
+ * Base class for Quick Action definition providers.
+ *
+ */
+export abstract class QuickActionDefinitionRegistry<T extends string> {
+    /**
+     * Mapping of page view name to page type name.
+     */
+    PAGE_NAME_MAP: Record<string, T> = {};
+
+    /**
+     * Provides a list of Quick Action definitions that are applicable for the given context.
+     *
+     * @param _context - Activation context.
+     */
+    getDefinitions(_context: QuickActionActivationContext): QuickActionDefinitionGroup[] {
+        throw new Error('Not implemented!');
+    }
+
+    /**
+     * Finds component container from the page control.
+     *
+     * @param page - Page control provided by containers.
+     * @returns ComponentContainer control.
+     */
+    protected getComponentContainerFromPage(page: Control): ComponentContainer | undefined {
+        if (page instanceof ComponentContainer) {
+            return page;
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns a list of Active pages based on the provided control index.
+     *
+     * @param controlIndex - Control tree index.
+     * @returns A list of Active pages.
+     */
+    protected getActivePageContent(controlIndex: ControlTreeIndex): ActivePage<T>[] {
+        const views = this.getActiveViews(controlIndex);
+        const pages: ActivePage<T>[] = [];
+        for (const view of views) {
+            const name = view.getViewName();
+            const pageName = this.PAGE_NAME_MAP[name];
+            if (pageName) {
+                pages.push({
+                    name: pageName,
+                    view
+                });
+            } else {
+                Log.warning(`Could not find matching page for view of type "${name}".`);
+            }
+        }
+        return pages;
+    }
+
+    /**
+     * Get all the root views of currently active pages.
+     *
+     * @param controlIndex - Control index.
+     * @returns List of page root views.
+     */
+    private getActiveViews(controlIndex: ControlTreeIndex): XMLView[] {
+        const pages = this.getActivePages(controlIndex);
+        const views: XMLView[] = [];
+
+        for (const page of pages) {
+            if (page) {
+                const container = this.getComponentContainerFromPage(page);
+                const rootControl = getRootControlFromComponentContainer(container);
+                if (rootControl) {
+                    views.push(rootControl);
+                }
+            }
+        }
+        return views;
+    }
+
+    /**
+     * Finds active page controls from the control tree index.
+     *
+     * @param controlIndex - Control tree index.
+     * @returns A list of page controls.
+     */
+    private getActivePages(controlIndex: ControlTreeIndex): (Control | undefined)[] {
+        const navContainerNode = controlIndex[NAV_CONTAINER_CONTROL_TYPE]?.[0];
+        if (navContainerNode) {
+            const control = getControlById(navContainerNode.controlId);
+            if (control instanceof NavContainer) {
+                return [control.getCurrentPage()];
+            }
+        }
+
+        const flexibleLayoutNode = controlIndex[FLEXIBLE_COLUMN_LAYOUT_CONTROL_TYPE]?.[0];
+        if (flexibleLayoutNode) {
+            const control = getControlById(flexibleLayoutNode.controlId);
+            if (control instanceof FlexibleColumnLayout) {
+                return this.getVisibleFlexibleColumnLayoutPages(control);
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * Finds the visible Flexible Column Layout pages.
+     *
+     * @param control - Flexible Column Layout control.
+     * @returns A list of visible pages.
+     */
+    private getVisibleFlexibleColumnLayoutPages(control: FlexibleColumnLayout): (Control | undefined)[] {
+        const layout = control.getLayout();
+        switch (layout) {
+            case LayoutType.OneColumn:
+                return [control.getCurrentBeginColumnPage()];
+            case LayoutType.MidColumnFullScreen:
+                return [control.getCurrentMidColumnPage()];
+            case LayoutType.EndColumnFullScreen:
+                return [control.getCurrentEndColumnPage()];
+            case LayoutType.ThreeColumnsBeginExpandedEndHidden:
+            case LayoutType.ThreeColumnsMidExpanded:
+            case LayoutType.ThreeColumnsMidExpandedEndHidden:
+            case LayoutType.ThreeColumnsEndExpanded:
+                return [
+                    control.getCurrentBeginColumnPage(),
+                    control.getCurrentMidColumnPage(),
+                    control.getCurrentEndColumnPage()
+                ];
+            case LayoutType.TwoColumnsMidExpanded:
+            case LayoutType.TwoColumnsBeginExpanded:
+                return [control.getCurrentBeginColumnPage(), control.getCurrentMidColumnPage()];
+        }
+        return [];
+    }
+}

package/dist/preview-middleware/dist/client/cpe/quick-actions/utils.js

@@ -0,0 +1,94 @@
+"use strict";
+
+sap.ui.define(["../../utils/core"], function (____utils_core) {
+  "use strict";
+
+  const getControlById = ____utils_core["getControlById"];
+  const isA = ____utils_core["isA"];
+  /**
+   * Checks if control is visible in the page.
+   *
+   * @param page - Page control.
+   * @param controlId - UI5 control id.
+   * @returns True if control is visible in the page.
+   */
+  function pageHasControlId(page, controlId) {
+    const controlDomElement = getControlById(controlId)?.getDomRef();
+    return !!controlDomElement && !!page?.getDomRef()?.contains(controlDomElement);
+  }
+
+  /**
+   * Checks if control is a child element of the rootControl.
+   *
+   * @param control - UI5 Control to be tested.
+   * @param rootControl - UI5 root control.
+   * @returns True if control is the child of the specified rootControl.
+   */
+  function isDescendantOfPage(control, rootControl) {
+    let currentControl = control;
+    while (currentControl) {
+      if (currentControl === rootControl) {
+        return true;
+      }
+      // if parent is a reusable component, use oContainer to find the parent
+      if (isA('sap.ui.core.Component', currentControl) && currentControl?.oContainer) {
+        currentControl = currentControl.oContainer.getParent();
+      } else {
+        currentControl = currentControl.getParent();
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Find all controls in page that match the provided types.
+   *
+   * @param controlIndex - Control tree index.
+   * @param activePage - Active page control.
+   * @param controlTypes - Relevant control types.
+   * @returns A list of UI5 controls.
+   */
+  function getRelevantControlFromActivePage(controlIndex, activePage, controlTypes) {
+    const relevantControls = [];
+    for (const type of controlTypes) {
+      const controls = controlIndex[type] ?? [];
+      for (const control of controls) {
+        const ui5Control = getControlById(control.controlId);
+        const parent = ui5Control?.getParent();
+        const isActionApplicable = isDescendantOfPage(parent, activePage);
+        if (isActionApplicable && ui5Control) {
+          // if parent control added, discard adding child control.
+          // Relevant for cases where wrapper exists eg: sap.m.Table exist in sap.ui.comp.smarttable.SmartTable
+          const parentFound = relevantControls.findIndex(relevantControl => relevantControl.getId() === ui5Control.getParent()?.getId());
+          if (parentFound === -1) {
+            relevantControls.push(ui5Control);
+          }
+        }
+      }
+    }
+    return relevantControls;
+  }
+  function getParentContainer(control, type) {
+    let currentControl = control;
+    while (currentControl) {
+      if (isA(type, currentControl)) {
+        return currentControl;
+      }
+      // if parent is a reusable component, use oContainer to find the parent
+      if (isA('sap.ui.core.Component', currentControl) && currentControl?.oContainer) {
+        currentControl = currentControl.oContainer.getParent();
+      } else {
+        currentControl = currentControl.getParent();
+      }
+    }
+    return undefined;
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.pageHasControlId = pageHasControlId;
+  __exports.getRelevantControlFromActivePage = getRelevantControlFromActivePage;
+  __exports.getParentContainer = getParentContainer;
+  return __exports;
+});
+//# sourceMappingURL=utils.js.map

package/dist/preview-middleware/dist/client/cpe/quick-actions/utils.ts

@@ -0,0 +1,113 @@
+import type UI5Element from 'sap/ui/core/Element';
+import type Control from 'sap/ui/core/Control';
+import type ManagedObject from 'sap/ui/base/ManagedObject';
+import type { FEAppPage } from 'sap/ui/rta/RuntimeAuthoring';
+
+import { getControlById, isA } from '../../utils/core';
+
+import type { ControlTreeIndex } from '../types';
+import type Component from 'sap/ui/core/Component';
+
+export interface FEAppPageInfo {
+    page: FEAppPage;
+    isInvisible: boolean;
+}
+export interface FEAppPagesMap {
+    [key: string]: FEAppPageInfo[];
+}
+
+/**
+ * Checks if control is visible in the page.
+ *
+ * @param page - Page control.
+ * @param controlId - UI5 control id.
+ * @returns True if control is visible in the page.
+ */
+export function pageHasControlId(page: Control, controlId: string): boolean {
+    const controlDomElement = getControlById(controlId)?.getDomRef();
+    return !!controlDomElement && !!page?.getDomRef()?.contains(controlDomElement);
+}
+
+/**
+ * Checks if control is a child element of the rootControl.
+ *
+ * @param control - UI5 Control to be tested.
+ * @param rootControl - UI5 root control.
+ * @returns True if control is the child of the specified rootControl.
+ */
+function isDescendantOfPage(control: ManagedObject | null | undefined, rootControl: ManagedObject) {
+    let currentControl = control;
+    while (currentControl) {
+        if (currentControl === rootControl) {
+            return true;
+        }
+        // if parent is a reusable component, use oContainer to find the parent
+        if (
+            isA<Component>('sap.ui.core.Component', currentControl) &&
+            (currentControl as unknown as { oContainer: Control })?.oContainer
+        ) {
+            currentControl = (currentControl as unknown as { oContainer: Control }).oContainer.getParent();
+        } else {
+            currentControl = currentControl.getParent();
+        }
+    }
+    return false;
+}
+
+/**
+ * Find all controls in page that match the provided types.
+ *
+ * @param controlIndex - Control tree index.
+ * @param activePage - Active page control.
+ * @param controlTypes - Relevant control types.
+ * @returns A list of UI5 controls.
+ */
+export function getRelevantControlFromActivePage<T extends UI5Element = UI5Element>(
+    controlIndex: ControlTreeIndex,
+    activePage: Control,
+    controlTypes: string[]
+): T[] {
+    const relevantControls: T[] = [];
+    for (const type of controlTypes) {
+        const controls = controlIndex[type] ?? [];
+        for (const control of controls) {
+            const ui5Control = getControlById<T>(control.controlId);
+            const parent = ui5Control?.getParent();
+            const isActionApplicable = isDescendantOfPage(parent, activePage);
+
+            if (isActionApplicable && ui5Control) {
+                // if parent control added, discard adding child control.
+                // Relevant for cases where wrapper exists eg: sap.m.Table exist in sap.ui.comp.smarttable.SmartTable
+                const parentFound = relevantControls.findIndex(
+                    (relevantControl) => relevantControl.getId() === ui5Control.getParent()?.getId()
+                );
+                if (parentFound === -1) {
+                    relevantControls.push(ui5Control);
+                }
+            }
+        }
+    }
+    return relevantControls;
+}
+
+export function getParentContainer<T extends ManagedObject>(
+    control: ManagedObject | null | undefined,
+    type: string
+): T | undefined {
+    let currentControl = control;
+    while (currentControl) {
+        if (isA<T>(type, currentControl)) {
+            return currentControl;
+        }
+        // if parent is a reusable component, use oContainer to find the parent
+        if (
+            isA<Component>('sap.ui.core.Component', currentControl) &&
+            (currentControl as unknown as { oContainer: Control })?.oContainer
+        ) {
+            currentControl = (currentControl as unknown as { oContainer: Control }).oContainer.getParent();
+        } else {
+            currentControl = currentControl.getParent();
+        }
+    }
+    return undefined;
+}