@sap/ux-ui5-tooling 1.20.4 → 1.22.0

package/dist/preview-middleware/dist/client/cpe/outline/nodes.ts

@@ -0,0 +1,236 @@
+import type { OutlineNode } from '@sap-ux-private/control-property-editor-common';
+import type { OutlineViewNode } from 'sap/ui/rta/command/OutlineService';
+import type { Scenario } from 'sap/ui/fl/Scenario';
+import Log from 'sap/base/Log';
+
+import { getControlById } from '../../utils/core';
+import { getError } from '../../utils/error';
+
+import type { ControlTreeIndex } from '../types';
+import { getOverlay } from '../utils';
+
+import { isEditable } from './editable';
+import type { ChangeService } from '../changes';
+import { getConfigMapControlIdMap, getPageName } from '../../utils/fe-v4';
+
+interface AdditionalData {
+    text?: string;
+    technicalName?: string;
+}
+
+/**
+ * Retrieves additional data for a given control ID.
+ *
+ * @param id The unique identifier of the control.
+ * @returns An object containing the text and the technical name of the control.
+ */
+function getAdditionalData(id: string): AdditionalData {
+    const control = getControlById(id);
+    if (!control) {
+        return {};
+    }
+
+    const metadata = control.getMetadata();
+    const details: AdditionalData = {};
+
+    const technicalName = metadata.getElementName();
+    if (technicalName) {
+        details.technicalName = technicalName;
+    }
+
+    if (metadata.getProperty('text')) {
+        const text = control.getProperty('text');
+        if (typeof text === 'string' && text.trim() !== '') {
+            details.text = text;
+        }
+    }
+
+    return details;
+}
+
+/**
+ * Gets the children nodes of an aggregation type node.
+ *
+ * @param current The current node to retrieve children from
+ * @returns An array of children nodes, or an empty array if none are found
+ */
+function getChildren(current: OutlineViewNode): OutlineViewNode[] {
+    return (current.elements ?? []).flatMap((element: OutlineViewNode) => {
+        if (element.type === 'aggregation') {
+            return element.elements ?? [];
+        } else if (element.type === 'extensionPoint') {
+            return [element];
+        }
+        return [];
+    });
+}
+
+/**
+ * Adds a new child node to the extension point's children array based on the given control ID.
+ *
+ * @param {string} id - The unique identifier of the control to be added as a child node.
+ * @param {OutlineNode[]} children - The array of children nodes to which the new node will be added.
+ * @param {ChangeService} changeService - Change service for change stack event handling.
+ */
+function addChildToExtensionPoint(id: string, children: OutlineNode[], changeService: ChangeService) {
+    const { text, technicalName } = getAdditionalData(id);
+    const editable = isEditable(changeService, id);
+
+    children.push({
+        controlId: id,
+        controlType: technicalName ?? 'sap.ui.extensionpoint.child',
+        name: text ?? id,
+        visible: true,
+        editable,
+        children: [],
+        hasDefaultContent: false
+    });
+}
+/**
+ * Creates control index for all controls in the app.
+ *
+ * @param {ControlTreeIndex} controlIndex - Control index for the ui5 app.
+ * @param {OutlineNode} node - control node added to the outline.
+ */
+function indexNode(controlIndex: ControlTreeIndex, node: OutlineNode): void {
+    const indexedControls = controlIndex[node.controlType];
+    if (indexedControls) {
+        indexedControls.push(node);
+    } else {
+        controlIndex[node.controlType] = [node];
+    }
+}
+
+function addToPropertyIdMap(node: OutlineNode, propertyIdMap: Map<string, string[]>): void {
+    const control = getControlById(node.controlId);
+    if (control) {
+        const overlay = getOverlay(control);
+        const overlayData = overlay?.getDesignTimeMetadata().getData();
+        if (!overlayData?.manifestPropertyPath) {
+            return;
+        }
+        if (overlayData) {
+            const path = overlayData?.manifestPropertyPath?.(control);
+            const pageName = getPageName(control);
+            const key = getConfigMapControlIdMap(
+                pageName,
+                path.split('/').filter((item) => item)
+            );
+            if (key) {
+                if (!propertyIdMap.get(key)) {
+                    propertyIdMap.set(key, []);
+                }
+                propertyIdMap.get(key)?.push(node.controlId);
+            }
+        }
+    }
+}
+
+/**
+ * Transform node.
+ *
+ * @param input outline view node
+ * @param scenario type of project
+ * @param controlIndex Control tree index
+ * @param changeService ChangeService for change stack event handling.
+ * @param propertyIdMap ChangeService for change stack event handling.
+ * @returns transformed outline tree nodes
+ */
+export async function transformNodes(
+    input: OutlineViewNode[],
+    scenario: Scenario,
+    controlIndex: ControlTreeIndex,
+    changeService: ChangeService,
+    propertyIdMap: Map<string, string[]>
+): Promise<OutlineNode[]> {
+    const stack = [...input];
+    const items: OutlineNode[] = [];
+    while (stack.length) {
+        try {
+            const current = stack.shift();
+            const editable = isEditable(changeService, current?.id);
+            const isAdp = scenario === 'ADAPTATION_PROJECT';
+            const isExtPoint = current?.type === 'extensionPoint';
+
+            if (current?.type === 'element') {
+                const children = getChildren(current);
+                const { text } = getAdditionalData(current.id);
+                const technicalName = current.technicalName.split('.').slice(-1)[0];
+
+                const transformedChildren = isAdp
+                    ? await handleDuplicateNodes(children, scenario, controlIndex, changeService, propertyIdMap)
+                    : await transformNodes(children, scenario, controlIndex, changeService, propertyIdMap);
+                const node: OutlineNode = {
+                    controlId: current.id,
+                    controlType: current.technicalName,
+                    name: text ?? technicalName,
+                    editable,
+                    visible: current.visible ?? true,
+                    children: transformedChildren
+                };
+
+                indexNode(controlIndex, node);
+                addToPropertyIdMap(node, propertyIdMap);
+
+                items.push(node);
+            }
+
+            if (isAdp && isExtPoint) {
+                const { defaultContent = [], createdControls = [] } = current.extensionPointInfo;
+
+                const children: OutlineNode[] = [];
+                // We can combine both because there can only be either defaultContent or createdControls for one extension point node.
+                [...defaultContent, ...createdControls].forEach((id: string) => {
+                    addChildToExtensionPoint(id, children, changeService);
+                });
+
+                const node: OutlineNode = {
+                    controlId: `${current.id}--${current.name ?? ''}`,
+                    controlType: current.technicalName,
+                    name: current.name ?? '',
+                    editable,
+                    visible: current.visible ?? true,
+                    children,
+                    hasDefaultContent: defaultContent.length > 0
+                };
+
+                items.push(node);
+            }
+        } catch (error) {
+            Log.error('Failed to transform outline node!', getError(error));
+        }
+    }
+    return items;
+}
+
+/**
+ * Handles duplicate nodes that are retrieved from extension point default content and created controls,
+ * if they exist under an extension point these controls are removed from the children array
+ *
+ * @param children outline view node children
+ * @param scenario type of project
+ * @param controlIndex Control tree index
+ * @param changeService ChangeService for change stack event handling.
+ * @param propertyIdMap  Map<string, string[]>.
+ * @returns transformed outline tree nodes
+ */
+export async function handleDuplicateNodes(
+    children: OutlineViewNode[],
+    scenario: Scenario,
+    controlIndex: ControlTreeIndex,
+    changeService: ChangeService,
+    propertyIdMap: Map<string, string[]>
+): Promise<OutlineNode[]> {
+    const extPointIDs = new Set<string>();
+
+    children.forEach((child: OutlineViewNode) => {
+        if (child.type === 'extensionPoint') {
+            const { defaultContent = [], createdControls = [] } = child.extensionPointInfo;
+            [...defaultContent, ...createdControls].forEach((id) => extPointIDs.add(id));
+        }
+    });
+
+    const uniqueChildren = children.filter((child) => !extPointIDs.has(child.id));
+
+    return transformNodes(uniqueChildren, scenario, controlIndex, changeService, propertyIdMap);
+}

package/dist/preview-middleware/dist/client/cpe/outline/service.js

@@ -0,0 +1,62 @@
+"use strict";
+
+sap.ui.define(["sap/base/Log", "open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common", "../../utils/error", "./nodes"], function (Log, ___sap_ux_private_control_property_editor_common, ____utils_error, ___nodes) {
+  "use strict";
+
+  const outlineChanged = ___sap_ux_private_control_property_editor_common["outlineChanged"];
+  const getError = ____utils_error["getError"];
+  const transformNodes = ___nodes["transformNodes"];
+  const OUTLINE_CHANGE_EVENT = 'OUTLINE_CHANGED';
+  /**
+   * A Class of WorkspaceConnectorService
+   */
+  class OutlineService extends EventTarget {
+    constructor(rta, changeService) {
+      super();
+      this.rta = rta;
+      this.changeService = changeService;
+    }
+
+    /**
+     * Initializes connector service.
+     *
+     * @param sendAction action sender function
+     */
+    async init(sendAction) {
+      const outline = await this.rta.getService('outline');
+      const {
+        scenario
+      } = this.rta.getFlexSettings();
+      const syncOutline = async () => {
+        try {
+          const viewNodes = await outline.get();
+          const controlIndex = {};
+          const configPropertyIdMap = new Map();
+          const outlineNodes = await transformNodes(viewNodes, scenario, controlIndex, this.changeService, configPropertyIdMap);
+          const event = new CustomEvent(OUTLINE_CHANGE_EVENT, {
+            detail: {
+              controlIndex
+            }
+          });
+          this.dispatchEvent(event);
+          sendAction(outlineChanged(outlineNodes));
+          await this.changeService.updateConfigurationProps(configPropertyIdMap);
+        } catch (error) {
+          Log.error('Outline sync failed!', getError(error));
+        }
+      };
+      await syncOutline();
+      outline.attachEvent('update', syncOutline);
+    }
+    onOutlineChange(handler) {
+      this.addEventListener(OUTLINE_CHANGE_EVENT, handler);
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.OUTLINE_CHANGE_EVENT = OUTLINE_CHANGE_EVENT;
+  __exports.OutlineService = OutlineService;
+  return __exports;
+});
+//# sourceMappingURL=service.js.map

package/dist/preview-middleware/dist/client/cpe/outline/service.ts

@@ -0,0 +1,66 @@
+import Log from 'sap/base/Log';
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import type RTAOutlineService from 'sap/ui/rta/command/OutlineService';
+
+import type { ExternalAction } from '@sap-ux-private/control-property-editor-common';
+import { outlineChanged } from '@sap-ux-private/control-property-editor-common';
+
+import { getError } from '../../utils/error';
+import { ChangeService } from '../changes';
+import { ControlTreeIndex } from '../types';
+import { transformNodes } from './nodes';
+
+export const OUTLINE_CHANGE_EVENT = 'OUTLINE_CHANGED';
+
+export interface OutlineChangedEventDetail {
+    controlIndex: ControlTreeIndex;
+}
+/**
+ * A Class of WorkspaceConnectorService
+ */
+export class OutlineService extends EventTarget {
+    constructor(private readonly rta: RuntimeAuthoring, private readonly changeService: ChangeService) {
+        super();
+    }
+
+    /**
+     * Initializes connector service.
+     *
+     * @param sendAction action sender function
+     */
+    public async init(sendAction: (action: ExternalAction) => void): Promise<void> {
+        const outline = await this.rta.getService<RTAOutlineService>('outline');
+        const { scenario } = this.rta.getFlexSettings();
+        const syncOutline = async () => {
+            try {
+                const viewNodes = await outline.get();
+                const controlIndex: ControlTreeIndex = {};
+                const configPropertyIdMap = new Map<string, string[]>();
+                const outlineNodes = await transformNodes(
+                    viewNodes,
+                    scenario,
+                    controlIndex,
+                    this.changeService,
+                    configPropertyIdMap
+                );
+                const event = new CustomEvent(OUTLINE_CHANGE_EVENT, {
+                    detail: {
+                        controlIndex
+                    }
+                });
+
+                this.dispatchEvent(event);
+                sendAction(outlineChanged(outlineNodes));
+                await this.changeService.updateConfigurationProps(configPropertyIdMap);
+            } catch (error) {
+                Log.error('Outline sync failed!', getError(error));
+            }
+        };
+        await syncOutline();
+        outline.attachEvent('update', syncOutline);
+    }
+
+    public onOutlineChange(handler: (event: CustomEvent<OutlineChangedEventDetail>) => void | Promise<void>): void {
+        this.addEventListener(OUTLINE_CHANGE_EVENT, handler as EventListener);
+    }
+}

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

@@ -0,0 +1,161 @@
+"use strict";
+
+sap.ui.define(["sap/base/Log", "open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common", "../../i18n", "../../adp/dialog-factory", "../../utils/application", "../../utils/version"], function (Log, ___sap_ux_private_control_property_editor_common, ____i18n, ____adp_dialog_factory, ____utils_application, ____utils_version) {
+  "use strict";
+
+  const executeQuickAction = ___sap_ux_private_control_property_editor_common["executeQuickAction"];
+  const quickActionListChanged = ___sap_ux_private_control_property_editor_common["quickActionListChanged"];
+  const SIMPLE_QUICK_ACTION_KIND = ___sap_ux_private_control_property_editor_common["SIMPLE_QUICK_ACTION_KIND"];
+  const NESTED_QUICK_ACTION_KIND = ___sap_ux_private_control_property_editor_common["NESTED_QUICK_ACTION_KIND"];
+  const updateQuickAction = ___sap_ux_private_control_property_editor_common["updateQuickAction"];
+  const externalFileChange = ___sap_ux_private_control_property_editor_common["externalFileChange"];
+  const reportTelemetry = ___sap_ux_private_control_property_editor_common["reportTelemetry"];
+  const getTextBundle = ____i18n["getTextBundle"];
+  const DialogFactory = ____adp_dialog_factory["DialogFactory"];
+  const getApplicationType = ____utils_application["getApplicationType"];
+  const getUi5Version = ____utils_version["getUi5Version"];
+  /**
+   * Service providing Quick Actions.
+   */
+  class QuickActionService {
+    sendAction = () => {};
+    actions = [];
+    /**
+     * Quick action service constructor.
+     *
+     * @param rta - RTA object.
+     * @param outlineService - Outline service instance.
+     * @param registries - Quick action registries.
+     * @param changeService
+     */
+    constructor(rta, outlineService, registries, changeService) {
+      this.rta = rta;
+      this.outlineService = outlineService;
+      this.registries = registries;
+      this.changeService = changeService;
+    }
+
+    /**
+     * Initialize selection service.
+     *
+     * @param sendAction - Action sender function.
+     * @param subscribe - Subscriber function.
+     */
+    async init(sendAction, subscribe) {
+      this.sendAction = sendAction;
+      this.actionService = await this.rta.getService('action');
+      this.texts = await getTextBundle();
+      subscribe(async action => {
+        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.
+     */
+    async reloadQuickActions(controlIndex) {
+      const context = {
+        controlIndex,
+        manifest: this.rta.getRootControlInstance().getManifest(),
+        actionService: this.actionService
+      };
+      const groups = [];
+      for (const registry of this.registries) {
+        for (const {
+          title,
+          definitions,
+          view,
+          key
+        } of registry.getDefinitions(context)) {
+          const group = {
+            title,
+            actions: []
+          };
+          const actionContext = {
+            ...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));
+    }
+    async addAction(group, instance) {
+      if (instance.isApplicable) {
+        await instance.runEnablementValidators();
+        const quickAction = instance.getActionObject();
+        group.actions.push(quickAction);
+        this.actions.push(instance);
+      }
+    }
+    async executeAction(actionInstance, payload) {
+      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 [];
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.QuickActionService = QuickActionService;
+  return __exports;
+});
+//# sourceMappingURL=quick-action-service.js.map