@sap/ux-ui5-tooling 1.20.4 → 1.22.0

package/dist/preview-middleware/dist/client/cpe/control-data.js

@@ -0,0 +1,366 @@
+"use strict";
+
+sap.ui.define(["open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common", "sap/ui/fl/Utils", "./utils", "sap/ui/base/DataType", "../utils/fe-v4"], function (___sap_ux_private_control_property_editor_common, Utils, ___utils, DataType, ___utils_fe_v4) {
+  "use strict";
+
+  const BOOLEAN_VALUE_TYPE = ___sap_ux_private_control_property_editor_common["BOOLEAN_VALUE_TYPE"];
+  const CHECKBOX_EDITOR_TYPE = ___sap_ux_private_control_property_editor_common["CHECKBOX_EDITOR_TYPE"];
+  const DROPDOWN_EDITOR_TYPE = ___sap_ux_private_control_property_editor_common["DROPDOWN_EDITOR_TYPE"];
+  const FLOAT_VALUE_TYPE = ___sap_ux_private_control_property_editor_common["FLOAT_VALUE_TYPE"];
+  const INPUT_EDITOR_TYPE = ___sap_ux_private_control_property_editor_common["INPUT_EDITOR_TYPE"];
+  const INTEGER_VALUE_TYPE = ___sap_ux_private_control_property_editor_common["INTEGER_VALUE_TYPE"];
+  const PropertyType = ___sap_ux_private_control_property_editor_common["PropertyType"];
+  const STRING_VALUE_TYPE = ___sap_ux_private_control_property_editor_common["STRING_VALUE_TYPE"];
+  const convertCamelCaseToPascalCase = ___sap_ux_private_control_property_editor_common["convertCamelCaseToPascalCase"];
+  const getManifestProperties = ___utils["getManifestProperties"];
+  const getV4PageType = ___utils_fe_v4["getV4PageType"];
+  /**
+   * A property is disabled if it is an array or the type is 'any'
+   * - since  we currently don't have a good editor for it Otherwise, it is enabled.
+   *
+   * @param analyzedType - analyzed property type
+   * @returns boolean
+   */
+  function isPropertyEnabled(analyzedType) {
+    return !(analyzedType.isArray || analyzedType.primitiveType === 'any');
+  }
+
+  /**
+   * Return if a control is enabled or not.
+   *
+   * @param analyzedType - analyzed property type
+   * @param hasStableId - given control has stable id.
+   * @param ignore - property that is ignored during design time
+   * @param controlOverlay - element overlay
+   * @returns boolean
+   */
+  function isControlEnabled(analyzedType, hasStableId, ignore, controlOverlay) {
+    return (controlOverlay?.isSelectable() ?? false) && isPropertyEnabled(analyzedType) && hasStableId && !ignore;
+  }
+
+  /**
+   * Match 'src' or any string starting or ending with 'icon' (case insensitive;).
+   *
+   * @param name icon name
+   * @returns boolean
+   */
+  function testIconPattern(name) {
+    // replace `/src|.*icon$|^icon.*/i`.test(property.name);
+    // match 'src' or any string starting or ending with 'icon' (case insensitive;)
+    const nameLc = (name || '').toLowerCase();
+    return nameLc.indexOf('src') >= 0 || nameLc.startsWith('icon') || nameLc.endsWith('icon');
+  }
+
+  /**
+   * Analyze property type string | boolean | enum.
+   *
+   * @param property control property
+   * @returns AnalyzedType|undefined
+   */
+  function analyzePropertyType(property) {
+    const analyzedType = {
+      primitiveType: 'any',
+      ui5Type: null,
+      enumValues: undefined,
+      isArray: false
+    };
+    const propertyType = property?.getType();
+    const typeName = propertyType?.getName();
+    if (!property || !propertyType || !typeName) {
+      return undefined;
+    }
+
+    // Check if array and determine property type (or component type)
+    if (typeName.indexOf('[]') > 0) {
+      analyzedType.primitiveType = typeName.substring(0, typeName.indexOf('[]'));
+      analyzedType.isArray = true;
+    }
+    // Return if object or void type
+    else if (['object', 'void', 'any'].includes(typeName)) {
+      analyzedType.primitiveType = typeName;
+    }
+    // Type of control property is an elementary simple type
+    else if (['boolean', 'string', 'int', 'float'].includes(typeName)) {
+      analyzedType.primitiveType = typeName;
+    }
+    // Control type is a sap.ui.base.DataType or an enumeration type
+    else {
+      // Determine type from iFrame
+      const propertyDataType = DataType.getType(typeName);
+
+      // type which is not a DataType such as Control is not supported
+      if (propertyDataType && !(propertyDataType instanceof DataType)) {
+        return analyzedType;
+      }
+      // enum values are created differently and use DataType as prototype, which only has stubs for instance functions -> getName returns undefined
+      // array and base types also return undefined, but we have already handled those above
+      // https://github.com/SAP/openui5/blob/203ce22763a76e28b7a422f6c635a42480f733f1/src/sap.ui.core/src/sap/ui/base/DataType.js#L430
+
+      const name = Object.getPrototypeOf(propertyDataType).getName();
+      if (!name) {
+        analyzedType.primitiveType = 'enum';
+      } else {
+        analyzedType.primitiveType = name;
+      }
+      analyzedType.ui5Type = typeName;
+
+      // Determine base type for SAP types
+      if (analyzedType.primitiveType === 'enum' && typeof propertyDataType?.getEnumValues === 'function') {
+        analyzedType.enumValues = propertyDataType.getEnumValues();
+      }
+    }
+    return analyzedType;
+  }
+  function analyzeManifestProperty(property) {
+    const analyzedType = {
+      primitiveType: 'any',
+      ui5Type: null,
+      enumValues: undefined,
+      isArray: false
+    };
+    const propertyType = property.type;
+    if (!propertyType) {
+      return undefined;
+    }
+    if (['boolean', 'string', 'int', 'float'].includes(propertyType)) {
+      analyzedType.primitiveType = propertyType;
+    }
+    if (property.enums) {
+      analyzedType.primitiveType = 'enum';
+      analyzedType.enumValues = property.enums.reduce((acc, item) => {
+        acc[item.id] = item.name;
+        return acc;
+      }, {});
+    }
+    return analyzedType;
+  }
+
+  /**
+   * If rawValue is anything except an object like {} or a function, return it as-is,
+   * If it is an object, stringify it.
+   * If it is a function, return empty string.
+   *
+   * @param rawValue property value
+   * @returns string
+   */
+  function normalizeObjectPropertyValue(rawValue) {
+    if (typeof rawValue === 'object' && rawValue instanceof Object && !Array.isArray(rawValue)) {
+      try {
+        return JSON.stringify(rawValue);
+      } catch (e) {
+        if (e instanceof Error && e.message.toLowerCase().includes('converting circular structure to json')) {
+          // some objects can be circular, e.g.:
+          // var obj = {
+          //    key1: value,
+          //    key2: obj
+          // }
+          // and JSON.stringify can't handle that so we reach here.
+          // however, postMessage can't handle that either, and throws:
+          // "Failed to execute 'postMessage' on 'Window': An object could not be cloned".
+          // so we need to check whether this is the failure and if so, don't return the rawValue,
+          // but some default string to act as the property value.
+          return '<Circular JSON cannot be displayed>';
+        }
+        return rawValue;
+      }
+    } else if (typeof rawValue === 'function') {
+      return '';
+    } else {
+      return rawValue;
+    }
+  }
+  /**
+   * Build control data.
+   *
+   * @param control - ui5 control
+   * @param changeService - Changeservice for change stack event handling.
+   * @param controlOverlay - element overlay
+   * @param includeDocumentation - include documentation flag
+   * @returns Promise<Control>
+   */
+  function buildControlData(control, changeService, controlOverlay) {
+    const controlMetadata = control.getMetadata();
+    const selectedControlName = controlMetadata.getName();
+    const hasStableId = Utils.checkControlId(control);
+    const overlayData = controlOverlay?.getDesignTimeMetadata().getData();
+    const controlProperties = controlOverlay ? overlayData?.properties : undefined;
+    const manifestProperties = getManifestProperties(control, changeService, controlOverlay);
+    // Add the control's properties/manifest properties
+    const allProperties = {
+      ...controlMetadata.getAllProperties(),
+      ...manifestProperties
+    };
+    let propertyType;
+    const propertyNames = Object.keys(allProperties);
+    const properties = [];
+    for (const propertyName of propertyNames) {
+      const property = allProperties[propertyName];
+      let analyzedType;
+      let isEnabled = false;
+      let value;
+      if (property && 'configuration' in property) {
+        propertyType = PropertyType.Configuration;
+        analyzedType = analyzeManifestProperty(property);
+        if (!analyzedType || property?.restrictedTo?.length && !property?.restrictedTo?.includes(getV4PageType(control))) {
+          continue;
+        }
+        isEnabled = true;
+        value = property.value;
+      } else {
+        propertyType = PropertyType.ControlProperty;
+        // the default behavior is that the property is enabled
+        // meaning it's not ignored during design time
+        analyzedType = analyzePropertyType(property);
+        if (!analyzedType) {
+          continue;
+        }
+        let ignore = false;
+        if (controlProperties?.[property.name]) {
+          // check whether the property should be ignored in design time or not
+          // if it's 'undefined' then it's not considered when building isEnabled because it's 'true'
+          ignore = controlProperties[property.name].ignore;
+        }
+
+        //updating i18n text for the control if bindingInfo has bindingString
+        const controlNewData = {
+          id: control.getId(),
+          name: property.name,
+          newValue: control.getProperty(property.name)
+        };
+        const bindingInfo = control.getBindingInfo(controlNewData.name);
+        if (bindingInfo?.bindingString !== undefined) {
+          controlNewData.newValue = bindingInfo.bindingString;
+        }
+
+        // A property is enabled if:
+        // 1. The property supports changes
+        // 2. The control has stable ID
+        // 3. It is not configured to be ignored in design time
+        // 4. And control overlay is selectable
+        isEnabled = isControlEnabled(analyzedType, hasStableId, ignore, controlOverlay);
+        value = normalizeObjectPropertyValue(controlNewData.newValue);
+      }
+      const isIcon = testIconPattern(property.name) && selectedControlName !== 'sap.m.Image' && analyzedType.ui5Type === 'sap.ui.core.URI';
+      const ui5Type = analyzedType.ui5Type || undefined;
+      const readableName = convertCamelCaseToPascalCase(property.name);
+      let docu;
+      if ('configuration' in property) {
+        const defValue = ['undefined', 'null'].includes(String(property.defaultValue)) ? '-' : String(property.defaultValue);
+        docu = {
+          description: property.description,
+          propertyName: property.id,
+          type: property.type,
+          defaultValue: defValue || '-'
+        };
+      }
+      switch (analyzedType.primitiveType) {
+        case 'enum':
+          {
+            const values = analyzedType.enumValues ?? {};
+            const options = Object.keys(values).map(key => ({
+              key,
+              text: values[key]
+            }));
+            properties.push({
+              type: STRING_VALUE_TYPE,
+              editor: DROPDOWN_EDITOR_TYPE,
+              propertyType,
+              name: property.name,
+              readableName,
+              value: value,
+              isEnabled,
+              ui5Type,
+              options,
+              ...(docu && {
+                documentation: docu
+              })
+            });
+            break;
+          }
+        case 'string':
+          {
+            properties.push({
+              type: STRING_VALUE_TYPE,
+              editor: INPUT_EDITOR_TYPE,
+              propertyType,
+              name: property.name,
+              readableName,
+              value: value,
+              isEnabled,
+              isIcon,
+              ui5Type,
+              ...(docu && {
+                documentation: docu
+              })
+            });
+            break;
+          }
+        case 'int':
+          {
+            properties.push({
+              type: INTEGER_VALUE_TYPE,
+              editor: INPUT_EDITOR_TYPE,
+              propertyType,
+              name: property.name,
+              readableName,
+              value: value,
+              isEnabled,
+              ui5Type,
+              ...(docu && {
+                documentation: docu
+              })
+            });
+            break;
+          }
+        case 'float':
+          {
+            properties.push({
+              type: FLOAT_VALUE_TYPE,
+              editor: INPUT_EDITOR_TYPE,
+              propertyType,
+              name: property.name,
+              readableName,
+              value: value,
+              isEnabled,
+              ui5Type,
+              ...(docu && {
+                documentation: docu
+              })
+            });
+            break;
+          }
+        case 'boolean':
+          {
+            properties.push({
+              type: BOOLEAN_VALUE_TYPE,
+              editor: CHECKBOX_EDITOR_TYPE,
+              propertyType,
+              name: property.name,
+              readableName,
+              value: value,
+              isEnabled,
+              ui5Type,
+              ...(docu && {
+                documentation: docu
+              })
+            });
+            break;
+          }
+      }
+    }
+    return {
+      id: control.getId(),
+      //the id of the underlying control/aggregation
+      type: selectedControlName,
+      //the name of the ui5 class of the control/aggregation
+      properties: [...properties].sort((a, b) => a.name > b.name ? 1 : -1),
+      name: selectedControlName
+    };
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.buildControlData = buildControlData;
+  return __exports;
+});
+//# sourceMappingURL=control-data.js.map