@sap/ux-ui5-tooling 1.20.4 → 1.21.0

package/dist/preview-middleware/dist/client/adp/add-fragment.js

@@ -0,0 +1,48 @@
+"use strict";
+
+sap.ui.define(["sap/ui/rta/command/CommandFactory", "./utils", "./dialog-factory", "sap/ui/rta/plugin/AddXMLPlugin"], function (CommandFactory, ___utils, ___dialog_factory, AddXMLPlugin) {
+  "use strict";
+
+  const createDeferred = ___utils["createDeferred"];
+  const DialogFactory = ___dialog_factory["DialogFactory"];
+  const DialogNames = ___dialog_factory["DialogNames"];
+  /**
+   * Initializes the AddXMLPlugin and includes it in the Runtime Authoring (RTA) plugins.
+   *
+   * @param rta Runtime Authoring instance
+   */
+  function initAddXMLPlugin(rta) {
+    const flexSettings = rta.getFlexSettings();
+    const commandFactory = new CommandFactory({
+      flexSettings
+    });
+    const plugin = new AddXMLPlugin({
+      commandFactory,
+      fragmentHandler: async overlay => await handleFragmentCreation(rta, overlay)
+    });
+    const plugins = rta.getPlugins();
+    plugins.addXMLPlugin = plugin;
+    rta.setPlugins(plugins);
+  }
+
+  /**
+   * Handles the creation of a fragment 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 handleFragmentCreation(rta, overlay) {
+    const deferred = createDeferred();
+    await DialogFactory.createDialog(overlay, rta, DialogNames.ADD_FRAGMENT, {
+      deferred
+    });
+    return deferred.promise;
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.initAddXMLPlugin = initAddXMLPlugin;
+  return __exports;
+});
+//# sourceMappingURL=add-fragment.js.map

package/dist/preview-middleware/dist/client/adp/add-fragment.ts

@@ -0,0 +1,51 @@
+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 AddXMLPlugin from 'sap/ui/rta/plugin/AddXMLPlugin';
+
+export interface AddFragmentData {
+    deferred: Deferred<DeferredXmlFragmentData>;
+}
+
+export type DeferredXmlFragmentData = {
+    fragment: string;
+    fragmentPath: string;
+    targetAggregation: string;
+    index: number;
+};
+
+/**
+ * Initializes the AddXMLPlugin and includes it in the Runtime Authoring (RTA) plugins.
+ *
+ * @param rta Runtime Authoring instance
+ */
+export function initAddXMLPlugin(rta: RuntimeAuthoring): void {
+    const flexSettings = rta.getFlexSettings();
+    const commandFactory = new CommandFactory({ flexSettings });
+
+    const plugin = new AddXMLPlugin({
+        commandFactory,
+        fragmentHandler: async (overlay: UI5Element) => await handleFragmentCreation(rta, overlay)
+    });
+
+    const plugins = rta.getPlugins();
+    plugins.addXMLPlugin = plugin;
+    rta.setPlugins(plugins);
+}
+
+/**
+ * Handles the creation of a fragment 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 handleFragmentCreation(rta: RuntimeAuthoring, overlay: UI5Element): Promise<DeferredXmlFragmentData> {
+    const deferred = createDeferred<DeferredXmlFragmentData>();
+
+    await DialogFactory.createDialog(overlay, rta, DialogNames.ADD_FRAGMENT, { deferred });
+
+    return deferred.promise;
+}

package/dist/preview-middleware/dist/client/adp/api-handler.js

@@ -0,0 +1,162 @@
+"use strict";
+
+sap.ui.define(["../utils/error"], function (___utils_error) {
+  "use strict";
+
+  const getError = ___utils_error["getError"];
+  var ApiEndpoints = /*#__PURE__*/function (ApiEndpoints) {
+    ApiEndpoints["CHANGES"] = "/preview/api/changes";
+    ApiEndpoints["FRAGMENT"] = "/adp/api/fragment";
+    ApiEndpoints["CONTROLLER"] = "/adp/api/controller";
+    ApiEndpoints["CODE_EXT"] = "/adp/api/code_ext";
+    ApiEndpoints["ANNOTATION_FILE"] = "/adp/api/annotation";
+    ApiEndpoints["MANIFEST_APP_DESCRIPTOR"] = "/manifest.appdescr_variant";
+    return ApiEndpoints;
+  }(ApiEndpoints || {});
+  var RequestMethod = /*#__PURE__*/function (RequestMethod) {
+    RequestMethod["GET"] = "GET";
+    RequestMethod["PUT"] = "PUT";
+    RequestMethod["POST"] = "POST";
+    RequestMethod["PATCH"] = "PATCH";
+    RequestMethod["DELETE"] = "DELETE";
+    return RequestMethod;
+  }(RequestMethod || {});
+  /**
+   * Requests a given endpoint
+   *
+   * @param endpoint API Endpoint
+   * @param method RequestMethod
+   * @param data Data to be sent to the server
+   * @returns Data from the server request
+   */
+  async function request(endpoint, method, data) {
+    const config = {
+      method,
+      body: JSON.stringify(data),
+      headers: {
+        'content-type': 'application/json'
+      }
+    };
+    try {
+      const baseUrl = document.getElementById('root')?.dataset.openUxPreviewBaseUrl ?? '';
+      const response = await fetch(`${baseUrl}${endpoint}`, config);
+      if (!response.ok) {
+        const errorData = await response.json();
+        const message = errorData?.message ? ` Server message: ${errorData.message}.` : '';
+        throw new Error(`Request failed, status: ${response.status}.${message}`);
+      }
+      switch (method) {
+        case RequestMethod.GET:
+          return response.json();
+        case RequestMethod.POST:
+          /**
+           * Since POST usually creates something
+           * and returns nothing (or a message) we just parse the text from res.send(msg)
+           */
+          return response.text();
+        default:
+          return response.json();
+      }
+    } catch (e) {
+      throw getError(e);
+    }
+  }
+
+  /**
+   * Retrieves all XML fragments from the project's workspace
+   *
+   * @returns Generic Promise<T>
+   */
+  async function getFragments() {
+    return request(ApiEndpoints.FRAGMENT, RequestMethod.GET);
+  }
+
+  /**
+   * Writes an XML fragment to the project's workspace
+   *
+   * @param data Data to be send to the server
+   * @returns Generic Promise<T>
+   */
+  async function writeFragment(data) {
+    return request(ApiEndpoints.FRAGMENT, RequestMethod.POST, data);
+  }
+
+  /**
+   * Retrieves manifest.appdescr_variant from the project's workspace
+   *
+   * @returns Generic Promise<T>
+   */
+  async function getManifestAppdescr() {
+    return request(ApiEndpoints.MANIFEST_APP_DESCRIPTOR, RequestMethod.GET);
+  }
+
+  /**
+   * Retrieves all controller extensions from the project's workspace
+   *
+   * @returns Generic Promise<T>
+   */
+  async function readControllers() {
+    return request(ApiEndpoints.CONTROLLER, RequestMethod.GET);
+  }
+
+  /**
+   * Writes a Controller to the project's workspace
+   *
+   * @param data Data to be send to the server
+   * @returns Generic Promise<T>
+   */
+  async function writeController(data) {
+    return request(ApiEndpoints.CONTROLLER, RequestMethod.POST, data);
+  }
+
+  /**
+   * Writes a new annotation file to the project's workspace
+   *
+   * @returns Generic Promise<DataSourceAnnotationMap>
+   */
+  async function getDataSourceAnnotationFileMap() {
+    return request(ApiEndpoints.ANNOTATION_FILE, RequestMethod.GET);
+  }
+
+  /**
+   * Checks for existing controller in the project's workspace
+   *
+   * @param controllerName Name of the controller
+   * @returns {CodeExtResponse} Returns path to existing controller if found
+   */
+  async function getExistingController(controllerName) {
+    const params = new URLSearchParams({
+      name: controllerName
+    });
+    const url = `${ApiEndpoints.CODE_EXT}?${params.toString()}`;
+    return request(url, RequestMethod.GET);
+  }
+
+  /**
+   * Writes a change object to the project's workspace
+   *
+   * @param data Data to be send to the server
+   * @returns Generic Promise<T>
+   */
+  async function writeChange(data) {
+    return request(ApiEndpoints.CHANGES, RequestMethod.POST, {
+      change: data
+    });
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.ApiEndpoints = ApiEndpoints;
+  __exports.RequestMethod = RequestMethod;
+  __exports.request = request;
+  __exports.getFragments = getFragments;
+  __exports.writeFragment = writeFragment;
+  __exports.getManifestAppdescr = getManifestAppdescr;
+  __exports.readControllers = readControllers;
+  __exports.writeController = writeController;
+  __exports.getDataSourceAnnotationFileMap = getDataSourceAnnotationFileMap;
+  __exports.getExistingController = getExistingController;
+  __exports.writeChange = writeChange;
+  return __exports;
+});
+//# sourceMappingURL=api-handler.js.map

package/dist/preview-middleware/dist/client/adp/api-handler.ts

@@ -0,0 +1,188 @@
+import type { Layer } from 'sap/ui/fl';
+import { getError } from '../utils/error';
+
+export const enum ApiEndpoints {
+    CHANGES = '/preview/api/changes',
+    FRAGMENT = '/adp/api/fragment',
+    CONTROLLER = '/adp/api/controller',
+    CODE_EXT = '/adp/api/code_ext',
+    ANNOTATION_FILE = '/adp/api/annotation',
+    MANIFEST_APP_DESCRIPTOR = '/manifest.appdescr_variant'
+}
+
+export const enum RequestMethod {
+    GET = 'GET',
+    PUT = 'PUT',
+    POST = 'POST',
+    PATCH = 'PATCH',
+    DELETE = 'DELETE'
+}
+
+export type Fragments = { fragmentName: string }[];
+export type Controllers = { controllerName: string }[];
+type ResponseMessage = { message?: string };
+
+export interface FragmentsResponse {
+    fragments: Fragments;
+    message: string;
+}
+
+export interface CodeExtResponse {
+    controllerExists: boolean;
+    controllerPath: string;
+    controllerPathFromRoot: string;
+    isRunningInBAS: boolean;
+    isTsSupported: boolean;
+}
+
+export interface AnnotationFileDetails {
+    annotationExistsInWS: boolean;
+    annotationPath: string;
+    annotationPathFromRoot: string | undefined;
+}
+
+export interface AnnotationDataSourceMap {
+    [key: string]: { serviceUrl: string; annotationDetails: AnnotationFileDetails; metadataReadErrorMsg: string };
+}
+
+export interface AnnotationDataSourceResponse {
+    isRunningInBAS: boolean;
+    annotationDataSourceMap: AnnotationDataSourceMap;
+}
+export interface ControllersResponse {
+    controllers: Controllers;
+    message: string;
+}
+
+export interface ManifestAppdescr {
+    fileName: string;
+    layer: Layer;
+    fileType: string;
+    reference: string;
+    id: string;
+    namespace: string;
+    version: string;
+    content: object[];
+}
+
+/**
+ * Requests a given endpoint
+ *
+ * @param endpoint API Endpoint
+ * @param method RequestMethod
+ * @param data Data to be sent to the server
+ * @returns Data from the server request
+ */
+export async function request<T>(endpoint: ApiEndpoints, method: RequestMethod, data?: unknown): Promise<T> {
+    const config: RequestInit = {
+        method,
+        body: JSON.stringify(data),
+        headers: {
+            'content-type': 'application/json'
+        }
+    };
+
+    try {
+        const baseUrl = document.getElementById('root')?.dataset.openUxPreviewBaseUrl ?? '';
+        const response: Response = await fetch(`${baseUrl}${endpoint}`, config);
+
+        if (!response.ok) {
+            const errorData = (await response.json()) as ResponseMessage;
+            const message = errorData?.message ? ` Server message: ${errorData.message}.` : '';
+            throw new Error(`Request failed, status: ${response.status}.${message}`);
+        }
+
+        switch (method) {
+            case RequestMethod.GET:
+                return response.json() as T;
+            case RequestMethod.POST:
+                /**
+                 * Since POST usually creates something
+                 * and returns nothing (or a message) we just parse the text from res.send(msg)
+                 */
+                return response.text() as T;
+            default:
+                return response.json() as T;
+        }
+    } catch (e) {
+        throw getError(e);
+    }
+}
+
+/**
+ * Retrieves all XML fragments from the project's workspace
+ *
+ * @returns Generic Promise<T>
+ */
+export async function getFragments(): Promise<FragmentsResponse> {
+    return request<FragmentsResponse>(ApiEndpoints.FRAGMENT, RequestMethod.GET);
+}
+
+/**
+ * Writes an XML fragment to the project's workspace
+ *
+ * @param data Data to be send to the server
+ * @returns Generic Promise<T>
+ */
+export async function writeFragment<T>(data: T): Promise<T> {
+    return request<T>(ApiEndpoints.FRAGMENT, RequestMethod.POST, data);
+}
+
+/**
+ * Retrieves manifest.appdescr_variant from the project's workspace
+ *
+ * @returns Generic Promise<T>
+ */
+export async function getManifestAppdescr(): Promise<ManifestAppdescr> {
+    return request<ManifestAppdescr>(ApiEndpoints.MANIFEST_APP_DESCRIPTOR, RequestMethod.GET);
+}
+
+/**
+ * Retrieves all controller extensions from the project's workspace
+ *
+ * @returns Generic Promise<T>
+ */
+export async function readControllers<T>(): Promise<T> {
+    return request<T>(ApiEndpoints.CONTROLLER, RequestMethod.GET);
+}
+
+/**
+ * Writes a Controller to the project's workspace
+ *
+ * @param data Data to be send to the server
+ * @returns Generic Promise<T>
+ */
+export async function writeController<T>(data: T): Promise<T> {
+    return request<T>(ApiEndpoints.CONTROLLER, RequestMethod.POST, data);
+}
+
+/**
+ * Writes a new annotation file to the project's workspace
+ *
+ * @returns Generic Promise<DataSourceAnnotationMap>
+ */
+export async function getDataSourceAnnotationFileMap(): Promise<AnnotationDataSourceResponse> {
+    return request<AnnotationDataSourceResponse>(ApiEndpoints.ANNOTATION_FILE, RequestMethod.GET);
+}
+
+/**
+ * Checks for existing controller in the project's workspace
+ *
+ * @param controllerName Name of the controller
+ * @returns {CodeExtResponse} Returns path to existing controller if found
+ */
+export async function getExistingController(controllerName: string): Promise<CodeExtResponse> {
+    const params = new URLSearchParams({ name: controllerName });
+    const url = `${ApiEndpoints.CODE_EXT}?${params.toString()}` as ApiEndpoints;
+    return request<CodeExtResponse>(url, RequestMethod.GET);
+}
+
+/**
+ * Writes a change object to the project's workspace
+ *
+ * @param data Data to be send to the server
+ * @returns Generic Promise<T>
+ */
+export async function writeChange<T>(data: T): Promise<T> {
+    return request<T>(ApiEndpoints.CHANGES, RequestMethod.POST, { change: data });
+}

package/dist/preview-middleware/dist/client/adp/command-executor.js

@@ -0,0 +1,100 @@
+"use strict";
+
+sap.ui.define(["open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common", "sap/ui/rta/command/CommandFactory", "../utils/error", "../utils/info-center-message"], function (___sap_ux_private_control_property_editor_common, CommandFactory, ___utils_error, ___utils_info_center_message) {
+  "use strict";
+
+  const MessageBarType = ___sap_ux_private_control_property_editor_common["MessageBarType"];
+  const getError = ___utils_error["getError"];
+  const sendInfoCenterMessage = ___utils_info_center_message["sendInfoCenterMessage"];
+  /**
+   * Class responsible for handling rta calls
+   */
+  class CommandExecutor {
+    /**
+     *
+     * @param rta Runtime Authoring
+     */
+    constructor(rta) {
+      this.rta = rta;
+    }
+
+    /**
+     * Generates command based on given values
+     *
+     * @param runtimeControl Managed object
+     * @param commandName Command name
+     * @param modifiedValue Modified value/s
+     * @param flexSettings Additional flex settings
+     * @param designMetadata Design time metadata
+     */
+    async getCommand(runtimeControl, commandName, modifiedValue, flexSettings, designMetadata) {
+      try {
+        return await CommandFactory.getCommandFor(runtimeControl, commandName, modifiedValue, designMetadata, flexSettings);
+      } catch (e) {
+        const error = getError(e);
+        await sendInfoCenterMessage({
+          title: {
+            key: 'ADP_GET_COMMAND_FAILURE_TITLE'
+          },
+          description: {
+            key: 'ADP_GET_COMMAND_FAILURE_DESCRIPTION',
+            params: [commandName, error.message]
+          },
+          type: MessageBarType.error
+        });
+        error.message = `Could not get command for '${commandName}'. ${error.message}`;
+        throw error;
+      }
+    }
+
+    /**
+     * Creates composite command without nested commands
+     *
+     * @param runtimeControl Managed object
+     */
+    async createCompositeCommand(runtimeControl) {
+      try {
+        return await CommandFactory.getCommandFor(runtimeControl, 'composite');
+      } catch (e) {
+        const error = getError(e);
+        await sendInfoCenterMessage({
+          title: {
+            key: 'ADP_GET_COMMAND_FAILURE_TITLE'
+          },
+          description: {
+            key: 'ADP_GET_COMPOSITE_COMMAND_FAILURE_DESCRIPTION',
+            params: [error.message]
+          },
+          type: MessageBarType.error
+        });
+        throw error;
+      }
+    }
+
+    /**
+     * Pushed and executes the provided command
+     *
+     * @param command Command
+     */
+    async pushAndExecuteCommand(command) {
+      try {
+        /**
+         * The change will have pending state and will only be saved to the workspace when the user clicks save icon
+         */
+        await this.rta.getCommandStack().pushAndExecute(command);
+      } catch (e) {
+        const error = getError(e);
+        await sendInfoCenterMessage({
+          title: {
+            key: 'ADP_RUN_COMMAND_FAILED_TITLE'
+          },
+          description: error.message,
+          type: MessageBarType.error
+        });
+        throw error;
+      }
+    }
+  }
+  return CommandExecutor;
+});
+//# sourceMappingURL=command-executor.js.map

package/dist/preview-middleware/dist/client/adp/command-executor.ts

@@ -0,0 +1,105 @@
+import { MessageBarType } from '@sap-ux-private/control-property-editor-common';
+import type ManagedObject from 'sap/ui/base/ManagedObject';
+import type DesignTimeMetadata from 'sap/ui/dt/DesignTimeMetadata';
+import CommandFactory from 'sap/ui/rta/command/CommandFactory';
+import type CompositeCommand from 'sap/ui/rta/command/CompositeCommand';
+import type FlexCommand from 'sap/ui/rta/command/FlexCommand';
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import type { FlexSettings } from 'sap/ui/rta/RuntimeAuthoring';
+import { getError } from '../utils/error';
+import { sendInfoCenterMessage } from '../utils/info-center-message';
+type CommandNames = 'addXML' | 'codeExt' | 'appDescriptor';
+
+/**
+ * Class responsible for handling rta calls
+ */
+export default class CommandExecutor {
+    /**
+     *
+     * @param rta Runtime Authoring
+     */
+    constructor(private readonly rta: RuntimeAuthoring) {}
+
+    /**
+     * Generates command based on given values
+     *
+     * @param runtimeControl Managed object
+     * @param commandName Command name
+     * @param modifiedValue Modified value/s
+     * @param flexSettings Additional flex settings
+     * @param designMetadata Design time metadata
+     */
+    public async getCommand<T>(
+        runtimeControl: ManagedObject,
+        commandName: CommandNames,
+        modifiedValue: object,
+        flexSettings: FlexSettings,
+        designMetadata?: DesignTimeMetadata
+    ): Promise<FlexCommand<T>> {
+        try {
+            return await CommandFactory.getCommandFor<FlexCommand<T>>(
+                runtimeControl,
+                commandName,
+                modifiedValue,
+                designMetadata,
+                flexSettings
+            );
+        } catch (e) {
+            const error = getError(e);
+            await sendInfoCenterMessage({
+                title: { key: 'ADP_GET_COMMAND_FAILURE_TITLE' },
+                description: {
+                    key: 'ADP_GET_COMMAND_FAILURE_DESCRIPTION',
+                    params: [commandName, error.message]
+                },
+                type: MessageBarType.error
+            });
+            error.message = `Could not get command for '${commandName}'. ${error.message}`;
+            throw error;
+        }
+    }
+
+    /**
+     * Creates composite command without nested commands
+     *
+     * @param runtimeControl Managed object
+     */
+    public async createCompositeCommand(runtimeControl: ManagedObject): Promise<CompositeCommand> {
+        try {
+            return await CommandFactory.getCommandFor<CompositeCommand>(runtimeControl, 'composite');
+        } catch (e) {
+            const error = getError(e);
+            await sendInfoCenterMessage({
+                title: { key: 'ADP_GET_COMMAND_FAILURE_TITLE' },
+                description: {
+                    key: 'ADP_GET_COMPOSITE_COMMAND_FAILURE_DESCRIPTION',
+                    params: [error.message]
+                },
+                type: MessageBarType.error
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * Pushed and executes the provided command
+     *
+     * @param command Command
+     */
+    public async pushAndExecuteCommand(command: FlexCommand | CompositeCommand): Promise<void> {
+        try {
+            /**
+             * The change will have pending state and will only be saved to the workspace when the user clicks save icon
+             */
+            await this.rta.getCommandStack().pushAndExecute(command);
+        } catch (e) {
+            const error = getError(e);
+            await sendInfoCenterMessage({
+                title: { key: 'ADP_RUN_COMMAND_FAILED_TITLE' },
+                description: error.message,
+                type: MessageBarType.error
+            });
+            throw error;
+        }
+    }
+}

package/dist/preview-middleware/dist/client/adp/control-utils.js

@@ -0,0 +1,46 @@
+"use strict";
+
+sap.ui.define([], function () {
+  "use strict";
+
+  /**
+   * Handles calling control specific functions for retrieving control data
+   */
+  class ControlUtils {
+    /**
+     * Returns ManagedObject runtime control
+     *
+     * @param overlayControl Overlay
+     * @returns {ManagedObject} Managed Object instance
+     */
+    static getRuntimeControl(overlayControl) {
+      let runtimeControl;
+      if (overlayControl.getElementInstance) {
+        runtimeControl = overlayControl.getElementInstance();
+      } else {
+        runtimeControl = overlayControl.getElement();
+      }
+      return runtimeControl;
+    }
+
+    /**
+     * Returns control aggregation names in an array
+     *
+     * @param control Managed Object runtime control
+     * @param name Aggregation name
+     * @returns Array of control aggregations
+     */
+    static getControlAggregationByName(control, name) {
+      let result = [];
+      const aggregation = (control ? control.getMetadata().getAllAggregations() : {})[name];
+      if (aggregation) {
+        // This executes a _sGetter function that can vary from control to control (_sGetter can be: getContent, getItems, etc)
+        const names = aggregation._sGetter && control[aggregation._sGetter]() || [];
+        result = Array.isArray(names) ? names : [names];
+      }
+      return result;
+    }
+  }
+  return ControlUtils;
+});
+//# sourceMappingURL=control-utils.js.map