@sap-ux/preview-middleware 0.16.58 → 0.16.60

package/dist/client/cpe/outline/service.js

@@ -0,0 +1,60 @@
+'use strict';
+sap.ui.define([
+    'sap/base/Log',
+    'open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common',
+    '../../utils/error',
+    '../../i18n',
+    './nodes'
+], function (Log, ___sap_ux_private_control_property_editor_common, ____utils_error, ____i18n, ___nodes) {
+    'use strict';
+    const outlineChanged = ___sap_ux_private_control_property_editor_common['outlineChanged'];
+    const SCENARIO = ___sap_ux_private_control_property_editor_common['SCENARIO'];
+    const showMessage = ___sap_ux_private_control_property_editor_common['showMessage'];
+    const getError = ____utils_error['getError'];
+    const getTextBundle = ____i18n['getTextBundle'];
+    const transformNodes = ___nodes['transformNodes'];
+    const OUTLINE_CHANGE_EVENT = 'OUTLINE_CHANGED';
+    class OutlineService extends EventTarget {
+        constructor(rta) {
+            super();
+            this.rta = rta;
+        }
+        async init(sendAction) {
+            const outline = await this.rta.getService('outline');
+            const scenario = this.rta.getFlexSettings().scenario;
+            const resourceBundle = await getTextBundle();
+            const key = 'ADP_REUSE_COMPONENTS_MESSAGE';
+            const message = resourceBundle.getText(key) ?? key;
+            let hasSentWarning = false;
+            const reuseComponentsIds = new Set();
+            const syncOutline = async () => {
+                try {
+                    const viewNodes = await outline.get();
+                    const controlIndex = {};
+                    const outlineNodes = await transformNodes(viewNodes, scenario, reuseComponentsIds, controlIndex);
+                    const event = new CustomEvent(OUTLINE_CHANGE_EVENT, { detail: { controlIndex } });
+                    this.dispatchEvent(event);
+                    sendAction(outlineChanged(outlineNodes));
+                    if (reuseComponentsIds.size > 0 && scenario === SCENARIO.AdaptationProject && !hasSentWarning) {
+                        sendAction(showMessage({
+                            message,
+                            shouldHideIframe: false
+                        }));
+                        hasSentWarning = true;
+                    }
+                } 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;
+});

package/dist/client/cpe/outline/service.ts

@@ -0,0 +1,73 @@
+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, SCENARIO, showMessage } from '@sap-ux-private/control-property-editor-common';
+
+import { getError } from '../../utils/error';
+import { getTextBundle } from '../../i18n';
+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 rta: RuntimeAuthoring) {
+        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().scenario;
+        const resourceBundle = await getTextBundle();
+        const key = 'ADP_REUSE_COMPONENTS_MESSAGE';
+        const message = resourceBundle.getText(key) ?? key;
+        let hasSentWarning = false;
+        const reuseComponentsIds = new Set<string>();
+        const syncOutline = async () => {
+            try {
+                const viewNodes = await outline.get();
+                const controlIndex: ControlTreeIndex = {};
+                const outlineNodes = await transformNodes(viewNodes, scenario, reuseComponentsIds, controlIndex);
+
+                const event = new CustomEvent(OUTLINE_CHANGE_EVENT, {
+                    detail: {
+                        controlIndex
+                    }
+                });
+
+                this.dispatchEvent(event);
+                sendAction(outlineChanged(outlineNodes));
+                if (reuseComponentsIds.size > 0 && scenario === SCENARIO.AdaptationProject && !hasSentWarning) {
+                    sendAction(
+                        showMessage({
+                            message,
+                            shouldHideIframe: false
+                        })
+                    );
+                    hasSentWarning = true;
+                }
+            } 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/client/cpe/quick-actions/quick-action-definition.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=quick-action-definition.js.map

package/dist/client/cpe/quick-actions/quick-action-definition.ts

@@ -0,0 +1,115 @@
+import type FlexCommand from 'sap/ui/rta/command/FlexCommand';
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import type { FlexSettings, Manifest } from 'sap/ui/rta/RuntimeAuthoring';
+import type { ActionService } from 'sap/ui/rta/service/Action';
+import type XMLView from 'sap/ui/core/mvc/XMLView';
+
+import type {
+    NestedQuickAction,
+    SimpleQuickAction,
+    NESTED_QUICK_ACTION_KIND,
+    SIMPLE_QUICK_ACTION_KIND
+} from '@sap-ux-private/control-property-editor-common';
+
+import type { TextBundle } from '../../i18n';
+import type { ControlTreeIndex } from '../types';
+
+export interface QuickActionActivationContext {
+    controlIndex: ControlTreeIndex;
+    actionService: ActionService;
+    manifest: Manifest;
+}
+
+export interface QuickActionContext {
+    controlIndex: ControlTreeIndex;
+    actionService: ActionService;
+    resourceBundle: TextBundle;
+    view: XMLView;
+    key: string;
+
+    /**
+     * RTA should not be used directly by quick actions.
+     *
+     * Currently it is only used for actions opening ADP dialogs,
+     * but this should be removed in the future.
+     *
+     * @deprecated
+     */
+    rta: RuntimeAuthoring;
+    flexSettings: FlexSettings;
+    manifest: Manifest;
+}
+
+export type QuickActionActivationData = {
+    isActive: boolean;
+    title: string;
+};
+
+interface QuickActionDefinitionBase {
+    /**
+     * Used to identify between different Quick Action definitions.
+     */
+    readonly type: string;
+    /**
+     * Used to identify Quick Action instances.
+     * All currently loaded actions must have unique ids.
+     */
+    readonly id: string;
+    /**
+     * Most actions have side effects that already triggers Quick Action reload,
+     * however if that is not the case this property should be set to "true" to force Quick Action reload after the action is executed.
+     */
+    readonly forceRefreshAfterExecution?: boolean;
+    /**
+     * Indicates that the Quick Action is applicable to the given context and should be displayed.
+     */
+    isActive: boolean;
+    /**
+     * Initializes the action and checks if it should be enabled in current context.
+     */
+    initialize: () => void | Promise<void>;
+}
+
+export interface SimpleQuickActionDefinition extends QuickActionDefinitionBase {
+    readonly kind: typeof SIMPLE_QUICK_ACTION_KIND;
+    /**
+     * Creates a UI representation object for the action.
+     *
+     * @returns UI representation object for the action.
+     */
+    getActionObject: () => SimpleQuickAction;
+
+    /**
+     * Executes the Quick Action.
+     */
+    execute: () => FlexCommand[] | Promise<FlexCommand[]>;
+}
+
+export interface NestedQuickActionDefinition extends QuickActionDefinitionBase {
+    readonly kind: typeof NESTED_QUICK_ACTION_KIND;
+
+    /**
+     * Creates a UI representation object for the action.
+     *
+     * @returns UI representation object for the action.
+     */
+    getActionObject: () => NestedQuickAction;
+    /**
+     * Executes the Quick Action.
+     *
+     * @param path - Path to the specific child action that needs to be executed (e.g '0/1').
+     */
+    execute: (path: string) => FlexCommand[] | Promise<FlexCommand[]>;
+}
+export type QuickActionDefinition = SimpleQuickActionDefinition | NestedQuickActionDefinition;
+
+export interface QuickActionDefinitionConstructor<T extends QuickActionDefinition> {
+    new (context: QuickActionContext): T;
+}
+
+export interface QuickActionDefinitionGroup {
+    title: string;
+    definitions: QuickActionDefinitionConstructor<QuickActionDefinition>[];
+    view: XMLView;
+    key: string;
+}

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

@@ -0,0 +1,101 @@
+'use strict';
+sap.ui.define([
+    'sap/base/Log',
+    'open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common',
+    '../../i18n'
+], function (Log, ___sap_ux_private_control_property_editor_common, ____i18n) {
+    '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 getTextBundle = ____i18n['getTextBundle'];
+    class QuickActionService {
+        sendAction = () => {
+        };
+        actions = [];
+        constructor(rta, outlineService, registries) {
+            this.rta = rta;
+            this.outlineService = outlineService;
+            this.registries = registries;
+        }
+        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.filter(quickActionDefinition => quickActionDefinition.id === action.payload.id).pop();
+                    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()));
+                    }
+                }
+            });
+            this.outlineService.onOutlineChange(async event => {
+                await this.reloadQuickActions(event.detail.controlIndex);
+            });
+        }
+        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
+                    };
+                    for (const Definition of definitions) {
+                        try {
+                            const instance = new Definition(actionContext);
+                            await instance.initialize();
+                            this.addAction(group, instance);
+                        } catch {
+                            Log.warning(`Failed to initialize ${ Definition.name } quick action.`);
+                        }
+                    }
+                    groups.push(group);
+                }
+            }
+            this.sendAction(quickActionListChanged(groups));
+        }
+        addAction(group, instance) {
+            if (instance.isActive) {
+                const quickAction = instance.getActionObject();
+                group.actions.push(quickAction);
+                this.actions.push(instance);
+            }
+        }
+        executeAction(actionInstance, payload) {
+            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 Promise.resolve([]);
+        }
+    }
+    var __exports = { __esModule: true };
+    __exports.QuickActionService = QuickActionService;
+    return __exports;
+});

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

@@ -0,0 +1,142 @@
+import RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import { ActionService } from 'sap/ui/rta/service/Action';
+import Log from 'sap/base/Log';
+
+import {
+    executeQuickAction,
+    ExternalAction,
+    quickActionListChanged,
+    SIMPLE_QUICK_ACTION_KIND,
+    NESTED_QUICK_ACTION_KIND,
+    QuickActionExecutionPayload,
+    QuickActionGroup,
+    updateQuickAction
+} from '@sap-ux-private/control-property-editor-common';
+
+import { ActionSenderFunction, ControlTreeIndex, Service, SubscribeFunction } from '../types';
+
+import { QuickActionActivationContext, QuickActionContext, QuickActionDefinition } from './quick-action-definition';
+import { QuickActionDefinitionRegistry } from './registry';
+import { OutlineService } from '../outline/service';
+import { getTextBundle, TextBundle } from '../../i18n';
+
+/**
+ * Service providing Quick Actions.
+ */
+export class QuickActionService implements Service {
+    private sendAction: ActionSenderFunction = () => {};
+    private actions: QuickActionDefinition[] = [];
+
+    private actionService: ActionService;
+    private texts: TextBundle;
+
+    /**
+     * Qucik action service constructor.zrf
+     * 
+     * @param rta - RTA object.
+     * @param outlineService - Outline service instance.
+     * @param registries - Quick action registries.
+     */
+    constructor(
+        private readonly rta: RuntimeAuthoring,
+        private readonly outlineService: OutlineService,
+        private readonly registries: QuickActionDefinitionRegistry<string>[]
+    ) {}
+
+    /**
+     * 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
+                    .filter((quickActionDefinition) => quickActionDefinition.id === action.payload.id)
+                    .pop();
+                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()));
+                }
+            }
+        });
+
+        this.outlineService.onOutlineChange(async (event) => {
+            await this.reloadQuickActions(event.detail.controlIndex);
+        });
+    }
+
+    /**
+     * 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
+                };
+                for (const Definition of definitions) {
+                    try {
+                        const instance = new Definition(actionContext);
+                        await instance.initialize();
+                        this.addAction(group, instance);
+                    } catch {
+                        Log.warning(`Failed to initialize ${Definition.name} quick action.`);
+                    }
+                }
+                groups.push(group);
+            }
+        }
+
+        this.sendAction(quickActionListChanged(groups));
+    }
+
+    private addAction(group: QuickActionGroup, instance: QuickActionDefinition): void {
+        if (instance.isActive) {
+            const quickAction = instance.getActionObject();
+            group.actions.push(quickAction);
+            this.actions.push(instance);
+        }
+    }
+
+    private executeAction(actionInstance: QuickActionDefinition, payload: QuickActionExecutionPayload) {
+        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 Promise.resolve([]);
+    }
+}

package/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", "../../utils/core", "../utils"], function (NavContainer, FlexibleColumnLayout, sap_f_library, Log, ____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) {
+      return page;
+    }
+
+    /**
+     * 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);
+          if (container) {
+            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