@sap/open.fe 1.99.0 → 1.100.0

package/packages/sap.fe.macros/src/sap/fe/macros/filter/type/Value.ts

@@ -0,0 +1,303 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+        (c) Copyright 2009-2021 SAP SE. All rights reserved
+    
+ */
+import { UI5Class } from "sap/fe/core/helpers/ClassSupport";
+import Type from "sap/ui/model/Type";
+import SimpleType from "sap/ui/model/SimpleType";
+import BooleanType from "sap/ui/model/type/Boolean";
+import DateType from "sap/ui/model/type/Date";
+import FloatType from "sap/ui/model/type/Float";
+import IntegerType from "sap/ui/model/type/Integer";
+import StringType from "sap/ui/model/type/String";
+import Filter from "sap/ui/model/Filter";
+import FilterOperatorUtil from "sap/ui/mdc/condition/FilterOperatorUtil";
+import FieldDisplay from "sap/ui/mdc/enum/FieldDisplay";
+import Operator from "sap/ui/mdc/condition/Operator";
+import { ConditionObject } from "sap/ui/mdc/condition/Condition";
+import Log from "sap/base/Log";
+
+/**
+ * Type used to extend the MDC operator type with hidden fields
+ *
+ * @typedef AugmentedOperator
+ */
+type AugmentedOperator = Operator & {
+	name: string;
+	valueTypes: string[];
+};
+
+/**
+ * Handle format/parse single filter value.
+ */
+// eslint-disable-next-line new-cap
+@UI5Class("sap.fe.macros.filter.type.Value")
+export default class Value extends SimpleType {
+	private static readonly INTERNAL_VALUE_TYPE = "string";
+	private static readonly OPERATOR_VALUE_TYPE_STATIC = "static";
+	protected operator: AugmentedOperator;
+
+	/**
+	 * Creates a new value type instance with the given parameters.
+	 *
+	 * @param {{ operator: string }} formatOptions Format options for this value type
+	 * @param {string?} formatOptions.operator The name of a (possibly custom) operator to use
+	 * @param {object} constraints Constraints for this value type
+	 * @protected
+	 */
+	constructor(formatOptions: { operator?: string }, constraints: object) {
+		super(formatOptions, constraints);
+		const operatorName = formatOptions?.operator || this.getDefaultOperatorName();
+		this.operator = FilterOperatorUtil.getOperator(operatorName) as AugmentedOperator;
+
+		if (!this.operator && operatorName.includes(".")) {
+			this._registerCustomOperator(operatorName);
+		}
+	}
+
+	/**
+	 * Registers a custom binding operator.
+	 *
+	 * @param {string} operatorName The binding operator name
+	 * @private
+	 */
+	private _registerCustomOperator(operatorName: string): void {
+		const handlerFileName = operatorName.substring(0, operatorName.lastIndexOf(".")).replace(/\./g, "/"),
+			methodName = operatorName.substring(operatorName.lastIndexOf(".") + 1);
+
+		sap.ui.require([handlerFileName], (customOperatorHandler: { [key: string]: (value: string | string[]) => Filter }) => {
+			if (!customOperatorHandler) {
+				return;
+			}
+
+			this.operator = new Operator({
+				filterOperator: "",
+				tokenFormat: "",
+				name: operatorName,
+				valueTypes: ["self"],
+				tokenParse: "^(.*)$",
+				format: (value: ConditionObject): ConditionObject => {
+					return {
+						operator: operatorName,
+						values: value.values,
+						validated: undefined
+					};
+				},
+				parse: function(text: ConditionObject, type: Type, displayFormat: FieldDisplay, defaultOperator: boolean) {
+					if (typeof text === "object") {
+						if (text.operator !== operatorName) {
+							throw Error("not matching operator");
+						}
+						return text.values;
+					}
+					return Operator.prototype.parse.apply(this, [text, type, displayFormat, defaultOperator]);
+				},
+				getModelFilter: (condition: ConditionObject): Filter => {
+					return customOperatorHandler[methodName].call(customOperatorHandler, this.formatConditionValues(condition.values));
+				}
+			}) as AugmentedOperator;
+			FilterOperatorUtil.addOperator(this.operator);
+		});
+	}
+
+	/**
+	 * Returns whether the specified operator is a multi-value operator.
+	 *
+	 * @param {AugmentedOperator} operator The binding operator
+	 * @returns {boolean} `true`, if multi-value operator (`false` otherwise)
+	 * @private
+	 */
+	private _isMultiValueOperator(operator: AugmentedOperator): boolean {
+		return (
+			operator.valueTypes.filter(function(valueType: string) {
+				return !!valueType && valueType !== Value.OPERATOR_VALUE_TYPE_STATIC;
+			}).length > 1
+		);
+	}
+
+	/**
+	 * Parses the internal string value to the external value of type 'externalValueType'.
+	 *
+	 * @param {string | string[]} value The internal string value to be parsed
+	 * @param {string | undefined} externalValueType The external value type, e.g. int, float[], string, etc.
+	 * @returns {string[]} The parsed value
+	 * @private
+	 */
+	private _stringToExternal(value: string | string[], externalValueType: string | undefined): string[] {
+		let externalValue;
+		const externalType = this._getTypeInstance(externalValueType);
+
+		if (externalValueType && Value._isArrayType(externalValueType)) {
+			if (!Array.isArray(value)) {
+				value = [value];
+			}
+			externalValue = value.map((valueElement: string) => {
+				return externalType ? externalType.parseValue(valueElement, Value.INTERNAL_VALUE_TYPE) : valueElement;
+			});
+		} else {
+			externalValue = externalType ? externalType.parseValue(value as string, Value.INTERNAL_VALUE_TYPE) : value;
+		}
+
+		return externalValue;
+	}
+
+	/**
+	 * Returns whether target type is an array.
+	 *
+	 * @param {string} targetType The target type name
+	 * @returns {boolean} `true`, if array type (`false` otherwise)
+	 * @private
+	 */
+	private static _isArrayType(targetType: string): boolean {
+		if (!targetType) {
+			return false;
+		}
+		return targetType === "array" || targetType.endsWith("[]");
+	}
+
+	/**
+	 * Returns the external value formatted as the internal string value.
+	 *
+	 * @param {string | string[]} externalValue The value to be parsed
+	 * @param {string | undefined} externalValueType The external value type, e.g. int, float[], string, etc.
+	 * @returns {string} The formatted value
+	 * @private
+	 */
+	private _externalToString(externalValue: string | string[], externalValueType: string | undefined): string {
+		let value;
+		const externalType = this._getTypeInstance(externalValueType);
+
+		if (externalValueType && Value._isArrayType(externalValueType)) {
+			if (!Array.isArray(externalValue)) {
+				externalValue = [externalValue];
+			}
+			value = externalValue.map((valueElement: string) => {
+				return externalType ? externalType.formatValue(valueElement, Value.INTERNAL_VALUE_TYPE) : valueElement;
+			});
+		} else {
+			value = externalType ? externalType.formatValue(externalValue as string, Value.INTERNAL_VALUE_TYPE) : externalValue;
+		}
+
+		return value;
+	}
+
+	/**
+	 * Retrieves the default type instance for given type name.
+	 *
+	 * @param {string | undefined} typeName The name of the type
+	 * @returns {SimpleType} The type instance
+	 * @private
+	 */
+	private _getTypeInstance(typeName: string | undefined): SimpleType {
+		typeName = this.getElementTypeName(typeName) || typeName;
+
+		switch (typeName) {
+			case "string":
+				return new StringType();
+			case "int":
+				return new IntegerType();
+			case "float":
+				return new FloatType();
+			case "date":
+				return new DateType();
+			case "boolean":
+				return new BooleanType();
+			default:
+				Log.error("Unexpected filter type");
+				throw new Error("Unexpected filter type");
+		}
+	}
+
+	/**
+	 * Returns the default operator name ("EQ").
+	 * Should be overridden on demand.
+	 *
+	 * @returns {string} The default operator name
+	 * @protected
+	 */
+	getDefaultOperatorName(): string {
+		return (FilterOperatorUtil.getEQOperator() as AugmentedOperator).name;
+	}
+
+	/**
+	 * Returns first value of array or input.
+	 *
+	 * @param {string[] | string} values Input condition value
+	 * @returns {string[] | string} Unchanged input condition value
+	 * @protected
+	 */
+	formatConditionValues(values: string[] | string): string[] | string {
+		return Array.isArray(values) && values.length ? values[0] : (values as string);
+	}
+
+	/**
+	 * Returns the element type name.
+	 *
+	 * @param {string | undefined} typeName The actual type name
+	 * @returns {string | undefined} The type of its elements
+	 * @protected
+	 */
+	getElementTypeName(typeName: string | undefined): string | undefined {
+		if (typeName?.endsWith("[]")) {
+			return typeName.substring(0, typeName.length - 2);
+		}
+		return undefined;
+	}
+
+	/**
+	 * Returns the string value parsed to the external value type 'this.operator'.
+	 *
+	 * @param {string | undefined} internalValue The internal string value to be formatted
+	 * @param {string | undefined} externalValueType The external value type, e.g. int, float[], string, etc.
+	 * @returns {any} The formatted value
+	 * @protected
+	 */
+	formatValue(internalValue: string | undefined, externalValueType: string | undefined): any {
+		if (!internalValue) {
+			return undefined;
+		}
+		const isMultiValueOperator = this._isMultiValueOperator(this.operator),
+			internalType = this._getTypeInstance(Value.INTERNAL_VALUE_TYPE);
+
+		//  from internal model string with operator
+		const values = this.operator.parse(internalValue || "", internalType, FieldDisplay.Value, false);
+		const value = !isMultiValueOperator && Array.isArray(values) ? values[0] : values;
+
+		return this._stringToExternal(value, externalValueType); // The value bound to a custom filter
+	}
+
+	/**
+	 * Returns the value parsed to the internal string value.
+	 *
+	 * @param {string | string[] | undefined} externalValue The value to be parsed
+	 * @param {string | undefined} externalValueType The external value type, e.g. int, float[], string, etc.
+	 * @returns {any} The parsed value
+	 * @protected
+	 */
+	parseValue(externalValue: string | string[] | undefined, externalValueType: string | undefined): any {
+		if (!externalValue) {
+			return undefined;
+		}
+		const isMultiValueOperator = this._isMultiValueOperator(this.operator),
+			externalType = this._getTypeInstance(externalValueType);
+
+		const value = this._externalToString(externalValue, externalValueType);
+
+		// Format to internal model string with operator
+		const values = isMultiValueOperator ? value : [value];
+		return this.operator.format({ values: values } as ConditionObject, externalType); // The string value stored in the 'filterValues' model
+	}
+
+	/**
+	 * Validates whether the given value in model representation is valid.
+	 *
+	 * @param {?} externalValue The value to be validated
+	 * @returns {void} `true`, if validated (`false` otherwise)
+	 * @protected
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	validateValue(externalValue: unknown): void {
+		return;
+	}
+}

package/packages/sap.fe.macros/src/sap/fe/macros/internal/CollaborationAvatar.fragment.xml

@@ -0,0 +1,15 @@
+<core:FragmentDefinition
+	xmlns:template="http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1"
+	xmlns:core="sap.ui.core"
+	xmlns="sap.m"
+>
+
+<Avatar
+		core:require="{FieldRuntime: 'sap/fe/macros/field/FieldRuntime'}"
+		visible="{this>collaborationHasActivityExpression}"
+		initials="{this>collaborationInitialsExpression}"
+		displaySize="XS"
+		backgroundColor="{this>collaborationColorExpression}"
+	/>
+
+</core:FragmentDefinition>

package/packages/sap.fe.macros/src/sap/fe/macros/internal/CollectionField.metadata-dbg.js

@@ -5,6 +5,9 @@
 sap.ui.define(["sap/fe/macros/MacroMetadata", "sap/fe/core/converters/MetaModelConverter", "sap/fe/core/templating/UIFormatters", "sap/fe/core/converters/helpers/BindingHelper", "sap/fe/macros/field/FieldTemplating", "sap/fe/core/helpers/BindingExpression", "sap/fe/core/templating/DataModelPathHelper"], function (MacroMetadata, MetaModelConverter, UIFormatters, BindingHelper, FieldTemplating, BindingExpression, DataModelPathHelper) {
   "use strict";
 
+  var not = BindingExpression.not;
+  var or = BindingExpression.or;
+  var isConstant = BindingExpression.isConstant;
   var compileBinding = BindingExpression.compileBinding;
   var constant = BindingExpression.constant;
   var annotationExpression = BindingExpression.annotationExpression;
@@ -145,7 +148,16 @@ sap.ui.define(["sap/fe/macros/MacroMetadata", "sap/fe/core/converters/MetaModelC
       }
 
       var bInsertable = DataModelPathHelper.isPathInsertable(oDataModelPath);
-      var bDeletable = DataModelPathHelper.isPathDeletable(oDataModelPath, undefined, true);
+      var bDeleteNavigationRestriction = DataModelPathHelper.isPathDeletable(oDataModelPath, {
+        ignoreTargetCollection: true,
+        authorizeUnresolvable: true
+      });
+      var bDeletePath = DataModelPathHelper.isPathDeletable(oDataModelPath); // deletable:
+      //		if restrictions come from Navigation we apply it
+      //		otherwise we apply restrictions defined on target collection only if it's a constant
+      //      otherwise it's true!
+
+      var bDeletable = ifElse(bDeleteNavigationRestriction._type === "Unresolvable", or(not(isConstant(bDeletePath)), bDeletePath), bDeletePath);
       oProps.editMode = oProps.formatOptions.displayOnly === "true" ? "Display" : compileBinding(ifElse(and(bInsertable, bDeletable, UI.IsEditable), constant("Editable"), constant("Display")));
       oProps.displayMode = getDisplayMode(oPropertyPath, oDataModelPath);
 
@@ -239,4 +251,4 @@ sap.ui.define(["sap/fe/macros/MacroMetadata", "sap/fe/core/converters/MetaModelC
   });
   return CollectionField;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CollectionField.metadata.ts"],"names":["CollectionField","MacroMetadata","extend","name","namespace","fragment","metadata","stereotype","properties","idPrefix","type","vhIdPrefix","defaultValue","_vhFlexId","computed","metaPath","required","$kind","ariaLabelledBy","formatOptions","showEmptyIndicator","displayOnly","contextPath","create","oProps","oDataModelPath","MetaModelConverter","getInvolvedDataModelObjects","oDataFieldConverted","convertMetaModelContext","oPropertyPath","Value","$target","sExtraPath","path","visible","getVisibleExpression","length","DataModelPathHelper","enhanceDataModelPath","bInsertable","isPathInsertable","bDeletable","isPathDeletable","undefined","editMode","compileBinding","ifElse","and","UI","IsEditable","constant","displayMode","getDisplayMode","multiInputSettings","_getMultiInputSettings","text","collection","collectionBindingDisplay","collectionBindingEdit","key","oPropertyDataModelObjectPath","_getPathStructure","collectionPath","itemDataModelObjectPath","oPropertyDefinition","targetObject","commonText","annotations","Common","Text","relativeLocation","getPathRelativeLocation","contextLocation","navigationProperties","map","np","textExpression","annotationExpression","getValueBinding","dataModelObjectPath","firstCollectionPath","currentEntitySet","targetEntitySet","startingEntitySet","navigatedPaths","contextNavsForItem","navProp","some","contextNavProp","fullyQualifiedName","push","navigationPropertyBinding","hasOwnProperty","isCollection","join","Object","assign"],"mappings":"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","sourceRoot":".","sourcesContent":["import { MacroMetadata } from \"sap/fe/macros\";\nimport * as MetaModelConverter from \"sap/fe/core/converters/MetaModelConverter\";\nimport { getDisplayMode } from \"sap/fe/core/templating/UIFormatters\";\nimport { UI } from \"sap/fe/core/converters/helpers/BindingHelper\";\nimport { getVisibleExpression, FieldFormatOptions, getValueBinding } from \"sap/fe/macros/field/FieldTemplating\";\nimport {\n\tand,\n\tifElse,\n\tannotationExpression,\n\tBindingExpression,\n\tconstant,\n\tcompileBinding,\n\tExpression\n} from \"sap/fe/core/helpers/BindingExpression\";\nimport * as DataModelPathHelper from \"sap/fe/core/templating/DataModelPathHelper\";\nimport { NavigationProperty, Property } from \"@sap-ux/annotation-converter\";\n\ntype MultiInputSettings = {\n\ttext: Expression<string> | BindingExpression<string>;\n\tcollectionBindingDisplay: BindingExpression<string>;\n\tcollectionBindingEdit: BindingExpression<string>;\n\tkey: Expression<string> | BindingExpression<string>;\n};\n/**\n * @classdesc\n * Building block for creating a CollectionField based on the metadata provided by OData V4.\n * <br>\n * Usually, a DataField annotation is expected\n *\n * Usage example:\n * <pre>\n * <internalMacro:CollectionField\n *   idPrefix=\"SomePrefix\"\n *   contextPath=\"{entitySet>}\"\n *   metaPath=\"{dataField>}\"\n * />\n * </pre>\n *\n * @class sap.fe.macros.internal.CollectionField\n * @hideconstructor\n * @private\n * @experimental\n * @since 1.94.0\n */\nconst CollectionField = MacroMetadata.extend(\"sap.fe.macros.internal.CollectionField\", {\n\t/**\n\t * Define building block stereotype for documentation\n\t */\n\tname: \"CollectionField\",\n\t/**\n\t * Namespace of the building block\n\t */\n\tnamespace: \"sap.fe.macros.internal\",\n\t/**\n\t * Fragment source of the building block (optional)\n\t */\n\tfragment: \"sap.fe.macros.internal.CollectionField\",\n\n\t/**\n\t * The metadata describing the building block\n\t */\n\tmetadata: {\n\t\t/**\n\t\t * Define building block stereotype for documentation purpose\n\t\t */\n\t\tstereotype: \"xmlmacro\",\n\t\t/**\n\t\t * Properties.\n\t\t */\n\t\tproperties: {\n\t\t\t/**\n\t\t\t * Prefix added to the generated ID of the field\n\t\t\t */\n\t\t\tidPrefix: {\n\t\t\t\ttype: \"string\"\n\t\t\t},\n\t\t\t/**\n\t\t\t * Prefix added to the generated ID of the value help used for the field\n\t\t\t */\n\t\t\tvhIdPrefix: {\n\t\t\t\ttype: \"string\",\n\t\t\t\tdefaultValue: \"FieldValueHelp\"\n\t\t\t},\n\n\t\t\t_vhFlexId: {\n\t\t\t\ttype: \"string\",\n\t\t\t\tcomputed: true\n\t\t\t},\n\t\t\t/**\n\t\t\t * Metadata path to the CollectionField.\n\t\t\t * This property is usually a metadataContext pointing to a DataField having a Value that uses a 1:n navigation\n\t\t\t */\n\t\t\tmetaPath: {\n\t\t\t\ttype: \"sap.ui.model.Context\",\n\t\t\t\trequired: true,\n\t\t\t\t$kind: \"Property\"\n\t\t\t},\n\t\t\t/**\n\t\t\t * Property added to associate the label with the CollectionField\n\t\t\t */\n\t\t\tariaLabelledBy: {\n\t\t\t\ttype: \"string\"\n\t\t\t},\n\t\t\tformatOptions: {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\t/**\n\t\t\t\t\t * If set to 'true', SAP Fiori elements shows an empty indicator in display mode for the text and links\n\t\t\t\t\t */\n\t\t\t\t\tshowEmptyIndicator: {\n\t\t\t\t\t\ttype: \"boolean\",\n\t\t\t\t\t\tdefaultValue: false\n\t\t\t\t\t},\n\t\t\t\t\tdisplayOnly: {\n\t\t\t\t\t\ttype: \"boolean\",\n\t\t\t\t\t\tdefaultValue: false\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t/**\n\t\t\t * Mandatory context to the CollectionField\n\t\t\t */\n\t\t\tcontextPath: {\n\t\t\t\ttype: \"sap.ui.model.Context\",\n\t\t\t\trequired: true,\n\t\t\t\t$kind: [\"EntitySet\", \"NavigationProperty\"]\n\t\t\t}\n\t\t}\n\t},\n\tcreate: function(oProps: any) {\n\t\tlet oDataModelPath = MetaModelConverter.getInvolvedDataModelObjects(oProps.metaPath, oProps.contextPath);\n\t\tconst oDataFieldConverted = MetaModelConverter.convertMetaModelContext(oProps.metaPath);\n\t\tconst oPropertyPath = oDataFieldConverted.Value.$target;\n\t\tconst sExtraPath = oDataFieldConverted.Value.path;\n\n\t\toProps.visible = getVisibleExpression(oDataModelPath, oProps.formatOptions);\n\t\tif (sExtraPath && sExtraPath.length > 0) {\n\t\t\toDataModelPath = DataModelPathHelper.enhanceDataModelPath(oDataModelPath, sExtraPath);\n\t\t}\n\t\tconst bInsertable = DataModelPathHelper.isPathInsertable(oDataModelPath);\n\t\tconst bDeletable = DataModelPathHelper.isPathDeletable(oDataModelPath, undefined, true);\n\t\toProps.editMode =\n\t\t\toProps.formatOptions.displayOnly === \"true\"\n\t\t\t\t? \"Display\"\n\t\t\t\t: compileBinding(ifElse(and(bInsertable, bDeletable, UI.IsEditable), constant(\"Editable\"), constant(\"Display\")));\n\t\toProps.displayMode = getDisplayMode(oPropertyPath, oDataModelPath);\n\n\t\tconst multiInputSettings = CollectionField._getMultiInputSettings(oDataModelPath, oProps.formatOptions);\n\t\toProps.text = multiInputSettings.text;\n\t\toProps.collection =\n\t\t\toProps.editMode === \"Display\" ? multiInputSettings.collectionBindingDisplay : multiInputSettings.collectionBindingEdit;\n\t\toProps.key = multiInputSettings.key;\n\t\treturn oProps;\n\t},\n\t_getMultiInputSettings: function(\n\t\toPropertyDataModelObjectPath: DataModelPathHelper.DataModelObjectPath,\n\t\tformatOptions: FieldFormatOptions\n\t): MultiInputSettings {\n\t\tconst { collectionPath, itemDataModelObjectPath } = CollectionField._getPathStructure(oPropertyDataModelObjectPath);\n\t\tconst collectionBindingDisplay = `{path:'${collectionPath}', templateShareable: false}`;\n\t\tconst collectionBindingEdit = `{path:'${collectionPath}', parameters: {$$ownRequest : true}, templateShareable: false}`;\n\n\t\tconst oPropertyDefinition =\n\t\t\toPropertyDataModelObjectPath.targetObject.type === \"PropertyPath\"\n\t\t\t\t? (oPropertyDataModelObjectPath.targetObject.$target as Property)\n\t\t\t\t: (oPropertyDataModelObjectPath.targetObject as Property);\n\t\tconst commonText = oPropertyDefinition.annotations?.Common?.Text;\n\t\tconst relativeLocation = DataModelPathHelper.getPathRelativeLocation(\n\t\t\toPropertyDataModelObjectPath.contextLocation,\n\t\t\toPropertyDataModelObjectPath.navigationProperties\n\t\t).map(np => np.name);\n\n\t\tconst textExpression = commonText\n\t\t\t? compileBinding(annotationExpression(commonText, relativeLocation) as Expression<string>)\n\t\t\t: getValueBinding(itemDataModelObjectPath, formatOptions, true);\n\t\treturn {\n\t\t\ttext: textExpression,\n\t\t\tcollectionBindingDisplay: collectionBindingDisplay,\n\t\t\tcollectionBindingEdit: collectionBindingEdit,\n\t\t\tkey: getValueBinding(itemDataModelObjectPath, formatOptions, true)\n\t\t};\n\t},\n\t// Process the dataModelPath to find the collection and the relative DataModelPath for the item.\n\t_getPathStructure: function(dataModelObjectPath: DataModelPathHelper.DataModelObjectPath): object {\n\t\tlet firstCollectionPath = \"\";\n\n\t\tlet currentEntitySet = dataModelObjectPath.contextLocation?.targetEntitySet\n\t\t\t? dataModelObjectPath.contextLocation.targetEntitySet\n\t\t\t: dataModelObjectPath.startingEntitySet;\n\t\tconst navigatedPaths: string[] = [];\n\t\tconst contextNavsForItem: NavigationProperty[] = dataModelObjectPath.contextLocation?.navigationProperties || [];\n\t\tfor (const navProp of dataModelObjectPath.navigationProperties) {\n\t\t\tif (\n\t\t\t\t!dataModelObjectPath.contextLocation ||\n\t\t\t\t!dataModelObjectPath.contextLocation?.navigationProperties.some(\n\t\t\t\t\tcontextNavProp => contextNavProp.fullyQualifiedName === navProp.fullyQualifiedName\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\t// in case of relative entitySetPath we don't consider navigationPath that are already in the context\n\t\t\t\tnavigatedPaths.push(navProp.name);\n\t\t\t\tcontextNavsForItem.push(navProp);\n\t\t\t}\n\t\t\tif (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(navProp.name)) {\n\t\t\t\tcurrentEntitySet = currentEntitySet.navigationPropertyBinding[navProp.name];\n\t\t\t\tif (navProp.isCollection) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfirstCollectionPath = `${navigatedPaths.join(\"/\")}`;\n\t\tconst itemDataModelObjectPath = Object.assign({}, dataModelObjectPath);\n\t\tif (itemDataModelObjectPath.contextLocation) {\n\t\t\titemDataModelObjectPath.contextLocation.navigationProperties = contextNavsForItem;\n\t\t}\n\n\t\treturn { collectionPath: firstCollectionPath, itemDataModelObjectPath: itemDataModelObjectPath };\n\t}\n});\n\nexport default CollectionField;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CollectionField.metadata.ts"],"names":["CollectionField","MacroMetadata","extend","name","namespace","fragment","metadata","stereotype","properties","idPrefix","type","vhIdPrefix","defaultValue","_vhFlexId","computed","metaPath","required","$kind","ariaLabelledBy","formatOptions","showEmptyIndicator","displayOnly","contextPath","create","oProps","oDataModelPath","MetaModelConverter","getInvolvedDataModelObjects","oDataFieldConverted","convertMetaModelContext","oPropertyPath","Value","$target","sExtraPath","path","visible","getVisibleExpression","length","DataModelPathHelper","enhanceDataModelPath","bInsertable","isPathInsertable","bDeleteNavigationRestriction","isPathDeletable","ignoreTargetCollection","authorizeUnresolvable","bDeletePath","bDeletable","ifElse","_type","or","not","isConstant","editMode","compileBinding","and","UI","IsEditable","constant","displayMode","getDisplayMode","multiInputSettings","_getMultiInputSettings","text","collection","collectionBindingDisplay","collectionBindingEdit","key","oPropertyDataModelObjectPath","_getPathStructure","collectionPath","itemDataModelObjectPath","oPropertyDefinition","targetObject","commonText","annotations","Common","Text","relativeLocation","getPathRelativeLocation","contextLocation","navigationProperties","map","np","textExpression","annotationExpression","getValueBinding","dataModelObjectPath","firstCollectionPath","currentEntitySet","targetEntitySet","startingEntitySet","navigatedPaths","contextNavsForItem","navProp","some","contextNavProp","fullyQualifiedName","push","navigationPropertyBinding","hasOwnProperty","isCollection","join","Object","assign"],"mappings":"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","sourceRoot":".","sourcesContent":["import { MacroMetadata } from \"sap/fe/macros\";\nimport * as MetaModelConverter from \"sap/fe/core/converters/MetaModelConverter\";\nimport { getDisplayMode } from \"sap/fe/core/templating/UIFormatters\";\nimport { UI } from \"sap/fe/core/converters/helpers/BindingHelper\";\nimport { getVisibleExpression, FieldFormatOptions, getValueBinding } from \"sap/fe/macros/field/FieldTemplating\";\nimport {\n\tand,\n\tifElse,\n\tannotationExpression,\n\tBindingExpression,\n\tconstant,\n\tcompileBinding,\n\tExpression,\n\tisConstant,\n\tor,\n\tnot\n} from \"sap/fe/core/helpers/BindingExpression\";\nimport * as DataModelPathHelper from \"sap/fe/core/templating/DataModelPathHelper\";\nimport { NavigationProperty, Property } from \"@sap-ux/annotation-converter\";\n\ntype MultiInputSettings = {\n\ttext: Expression<string> | BindingExpression<string>;\n\tcollectionBindingDisplay: BindingExpression<string>;\n\tcollectionBindingEdit: BindingExpression<string>;\n\tkey: Expression<string> | BindingExpression<string>;\n};\n/**\n * @classdesc\n * Building block for creating a CollectionField based on the metadata provided by OData V4.\n * <br>\n * Usually, a DataField annotation is expected\n *\n * Usage example:\n * <pre>\n * <internalMacro:CollectionField\n *   idPrefix=\"SomePrefix\"\n *   contextPath=\"{entitySet>}\"\n *   metaPath=\"{dataField>}\"\n * />\n * </pre>\n *\n * @class sap.fe.macros.internal.CollectionField\n * @hideconstructor\n * @private\n * @experimental\n * @since 1.94.0\n */\nconst CollectionField = MacroMetadata.extend(\"sap.fe.macros.internal.CollectionField\", {\n\t/**\n\t * Define building block stereotype for documentation\n\t */\n\tname: \"CollectionField\",\n\t/**\n\t * Namespace of the building block\n\t */\n\tnamespace: \"sap.fe.macros.internal\",\n\t/**\n\t * Fragment source of the building block (optional)\n\t */\n\tfragment: \"sap.fe.macros.internal.CollectionField\",\n\n\t/**\n\t * The metadata describing the building block\n\t */\n\tmetadata: {\n\t\t/**\n\t\t * Define building block stereotype for documentation purpose\n\t\t */\n\t\tstereotype: \"xmlmacro\",\n\t\t/**\n\t\t * Properties.\n\t\t */\n\t\tproperties: {\n\t\t\t/**\n\t\t\t * Prefix added to the generated ID of the field\n\t\t\t */\n\t\t\tidPrefix: {\n\t\t\t\ttype: \"string\"\n\t\t\t},\n\t\t\t/**\n\t\t\t * Prefix added to the generated ID of the value help used for the field\n\t\t\t */\n\t\t\tvhIdPrefix: {\n\t\t\t\ttype: \"string\",\n\t\t\t\tdefaultValue: \"FieldValueHelp\"\n\t\t\t},\n\n\t\t\t_vhFlexId: {\n\t\t\t\ttype: \"string\",\n\t\t\t\tcomputed: true\n\t\t\t},\n\t\t\t/**\n\t\t\t * Metadata path to the CollectionField.\n\t\t\t * This property is usually a metadataContext pointing to a DataField having a Value that uses a 1:n navigation\n\t\t\t */\n\t\t\tmetaPath: {\n\t\t\t\ttype: \"sap.ui.model.Context\",\n\t\t\t\trequired: true,\n\t\t\t\t$kind: \"Property\"\n\t\t\t},\n\t\t\t/**\n\t\t\t * Property added to associate the label with the CollectionField\n\t\t\t */\n\t\t\tariaLabelledBy: {\n\t\t\t\ttype: \"string\"\n\t\t\t},\n\t\t\tformatOptions: {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\t/**\n\t\t\t\t\t * If set to 'true', SAP Fiori elements shows an empty indicator in display mode for the text and links\n\t\t\t\t\t */\n\t\t\t\t\tshowEmptyIndicator: {\n\t\t\t\t\t\ttype: \"boolean\",\n\t\t\t\t\t\tdefaultValue: false\n\t\t\t\t\t},\n\t\t\t\t\tdisplayOnly: {\n\t\t\t\t\t\ttype: \"boolean\",\n\t\t\t\t\t\tdefaultValue: false\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t/**\n\t\t\t * Mandatory context to the CollectionField\n\t\t\t */\n\t\t\tcontextPath: {\n\t\t\t\ttype: \"sap.ui.model.Context\",\n\t\t\t\trequired: true,\n\t\t\t\t$kind: [\"EntitySet\", \"NavigationProperty\"]\n\t\t\t}\n\t\t}\n\t},\n\tcreate: function(oProps: any) {\n\t\tlet oDataModelPath = MetaModelConverter.getInvolvedDataModelObjects(oProps.metaPath, oProps.contextPath);\n\t\tconst oDataFieldConverted = MetaModelConverter.convertMetaModelContext(oProps.metaPath);\n\t\tconst oPropertyPath = oDataFieldConverted.Value.$target;\n\t\tconst sExtraPath = oDataFieldConverted.Value.path;\n\n\t\toProps.visible = getVisibleExpression(oDataModelPath, oProps.formatOptions);\n\t\tif (sExtraPath && sExtraPath.length > 0) {\n\t\t\toDataModelPath = DataModelPathHelper.enhanceDataModelPath(oDataModelPath, sExtraPath);\n\t\t}\n\t\tconst bInsertable = DataModelPathHelper.isPathInsertable(oDataModelPath);\n\t\tconst bDeleteNavigationRestriction = DataModelPathHelper.isPathDeletable(oDataModelPath, {\n\t\t\tignoreTargetCollection: true,\n\t\t\tauthorizeUnresolvable: true\n\t\t});\n\t\tconst bDeletePath = DataModelPathHelper.isPathDeletable(oDataModelPath);\n\t\t// deletable:\n\t\t//\t\tif restrictions come from Navigation we apply it\n\t\t//\t\totherwise we apply restrictions defined on target collection only if it's a constant\n\t\t//      otherwise it's true!\n\t\tconst bDeletable = ifElse(\n\t\t\tbDeleteNavigationRestriction._type === \"Unresolvable\",\n\t\t\tor(not(isConstant(bDeletePath)), bDeletePath),\n\t\t\tbDeletePath\n\t\t);\n\t\toProps.editMode =\n\t\t\toProps.formatOptions.displayOnly === \"true\"\n\t\t\t\t? \"Display\"\n\t\t\t\t: compileBinding(ifElse(and(bInsertable, bDeletable, UI.IsEditable), constant(\"Editable\"), constant(\"Display\")));\n\t\toProps.displayMode = getDisplayMode(oPropertyPath, oDataModelPath);\n\n\t\tconst multiInputSettings = CollectionField._getMultiInputSettings(oDataModelPath, oProps.formatOptions);\n\t\toProps.text = multiInputSettings.text;\n\t\toProps.collection =\n\t\t\toProps.editMode === \"Display\" ? multiInputSettings.collectionBindingDisplay : multiInputSettings.collectionBindingEdit;\n\t\toProps.key = multiInputSettings.key;\n\t\treturn oProps;\n\t},\n\t_getMultiInputSettings: function(\n\t\toPropertyDataModelObjectPath: DataModelPathHelper.DataModelObjectPath,\n\t\tformatOptions: FieldFormatOptions\n\t): MultiInputSettings {\n\t\tconst { collectionPath, itemDataModelObjectPath } = CollectionField._getPathStructure(oPropertyDataModelObjectPath);\n\t\tconst collectionBindingDisplay = `{path:'${collectionPath}', templateShareable: false}`;\n\t\tconst collectionBindingEdit = `{path:'${collectionPath}', parameters: {$$ownRequest : true}, templateShareable: false}`;\n\n\t\tconst oPropertyDefinition =\n\t\t\toPropertyDataModelObjectPath.targetObject.type === \"PropertyPath\"\n\t\t\t\t? (oPropertyDataModelObjectPath.targetObject.$target as Property)\n\t\t\t\t: (oPropertyDataModelObjectPath.targetObject as Property);\n\t\tconst commonText = oPropertyDefinition.annotations?.Common?.Text;\n\t\tconst relativeLocation = DataModelPathHelper.getPathRelativeLocation(\n\t\t\toPropertyDataModelObjectPath.contextLocation,\n\t\t\toPropertyDataModelObjectPath.navigationProperties\n\t\t).map(np => np.name);\n\n\t\tconst textExpression = commonText\n\t\t\t? compileBinding(annotationExpression(commonText, relativeLocation) as Expression<string>)\n\t\t\t: getValueBinding(itemDataModelObjectPath, formatOptions, true);\n\t\treturn {\n\t\t\ttext: textExpression,\n\t\t\tcollectionBindingDisplay: collectionBindingDisplay,\n\t\t\tcollectionBindingEdit: collectionBindingEdit,\n\t\t\tkey: getValueBinding(itemDataModelObjectPath, formatOptions, true)\n\t\t};\n\t},\n\t// Process the dataModelPath to find the collection and the relative DataModelPath for the item.\n\t_getPathStructure: function(dataModelObjectPath: DataModelPathHelper.DataModelObjectPath): object {\n\t\tlet firstCollectionPath = \"\";\n\n\t\tlet currentEntitySet = dataModelObjectPath.contextLocation?.targetEntitySet\n\t\t\t? dataModelObjectPath.contextLocation.targetEntitySet\n\t\t\t: dataModelObjectPath.startingEntitySet;\n\t\tconst navigatedPaths: string[] = [];\n\t\tconst contextNavsForItem: NavigationProperty[] = dataModelObjectPath.contextLocation?.navigationProperties || [];\n\t\tfor (const navProp of dataModelObjectPath.navigationProperties) {\n\t\t\tif (\n\t\t\t\t!dataModelObjectPath.contextLocation ||\n\t\t\t\t!dataModelObjectPath.contextLocation?.navigationProperties.some(\n\t\t\t\t\tcontextNavProp => contextNavProp.fullyQualifiedName === navProp.fullyQualifiedName\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\t// in case of relative entitySetPath we don't consider navigationPath that are already in the context\n\t\t\t\tnavigatedPaths.push(navProp.name);\n\t\t\t\tcontextNavsForItem.push(navProp);\n\t\t\t}\n\t\t\tif (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(navProp.name)) {\n\t\t\t\tcurrentEntitySet = currentEntitySet.navigationPropertyBinding[navProp.name];\n\t\t\t\tif (navProp.isCollection) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfirstCollectionPath = `${navigatedPaths.join(\"/\")}`;\n\t\tconst itemDataModelObjectPath = Object.assign({}, dataModelObjectPath);\n\t\tif (itemDataModelObjectPath.contextLocation) {\n\t\t\titemDataModelObjectPath.contextLocation.navigationProperties = contextNavsForItem;\n\t\t}\n\n\t\treturn { collectionPath: firstCollectionPath, itemDataModelObjectPath: itemDataModelObjectPath };\n\t}\n});\n\nexport default CollectionField;\n"]}

package/packages/sap.fe.macros/src/sap/fe/macros/internal/CollectionField.metadata.js

@@ -2,4 +2,4 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/macros/MacroMetadata","sap/fe/core/converters/MetaModelConverter","sap/fe/core/templating/UIFormatters","sap/fe/core/converters/helpers/BindingHelper","sap/fe/macros/field/FieldTemplating","sap/fe/core/helpers/BindingExpression","sap/fe/core/templating/DataModelPathHelper"],function(M,a,U,B,b,c,D){"use strict";var d=c.compileBinding;var f=c.constant;var g=c.annotationExpression;var h=c.ifElse;var j=c.and;var k=b.getValueBinding;var l=b.getVisibleExpression;var m=B.UI;var p=U.getDisplayMode;function _(o,n){var s=typeof Symbol!=="undefined"&&o[Symbol.iterator]||o["@@iterator"];if(!s){if(Array.isArray(o)||(s=q(o))||n&&o&&typeof o.length==="number"){if(s)o=s;var i=0;var F=function(){};return{s:F,n:function(){if(i>=o.length)return{done:true};return{done:false,value:o[i++]};},e:function(e){throw e;},f:F};}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");}var t=true,u=false,v;return{s:function(){s=s.call(o);},n:function(){var e=s.next();t=e.done;return e;},e:function(e){u=true;v=e;},f:function(){try{if(!t&&s.return!=null)s.return();}finally{if(u)throw v;}}};}function q(o,e){if(!o)return;if(typeof o==="string")return r(o,e);var n=Object.prototype.toString.call(o).slice(8,-1);if(n==="Object"&&o.constructor)n=o.constructor.name;if(n==="Map"||n==="Set")return Array.from(o);if(n==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return r(o,e);}function r(e,n){if(n==null||n>e.length)n=e.length;for(var i=0,o=new Array(n);i<n;i++){o[i]=e[i];}return o;}var C=M.extend("sap.fe.macros.internal.CollectionField",{name:"CollectionField",namespace:"sap.fe.macros.internal",fragment:"sap.fe.macros.internal.CollectionField",metadata:{stereotype:"xmlmacro",properties:{idPrefix:{type:"string"},vhIdPrefix:{type:"string",defaultValue:"FieldValueHelp"},_vhFlexId:{type:"string",computed:true},metaPath:{type:"sap.ui.model.Context",required:true,$kind:"Property"},ariaLabelledBy:{type:"string"},formatOptions:{type:"object",properties:{showEmptyIndicator:{type:"boolean",defaultValue:false},displayOnly:{type:"boolean",defaultValue:false}}},contextPath:{type:"sap.ui.model.Context",required:true,$kind:["EntitySet","NavigationProperty"]}}},create:function(P){var o=a.getInvolvedDataModelObjects(P.metaPath,P.contextPath);var e=a.convertMetaModelContext(P.metaPath);var i=e.Value.$target;var E=e.Value.path;P.visible=l(o,P.formatOptions);if(E&&E.length>0){o=D.enhanceDataModelPath(o,E);}var I=D.isPathInsertable(o);var n=D.isPathDeletable(o,undefined,true);P.editMode=P.formatOptions.displayOnly==="true"?"Display":d(h(j(I,n,m.IsEditable),f("Editable"),f("Display")));P.displayMode=p(i,o);var s=C._getMultiInputSettings(o,P.formatOptions);P.text=s.text;P.collection=P.editMode==="Display"?s.collectionBindingDisplay:s.collectionBindingEdit;P.key=s.key;return P;},_getMultiInputSettings:function(P,e){var i,n;var o=C._getPathStructure(P),s=o.collectionPath,t=o.itemDataModelObjectPath;var u="{path:'".concat(s,"', templateShareable: false}");var v="{path:'".concat(s,"', parameters: {$$ownRequest : true}, templateShareable: false}");var w=P.targetObject.type==="PropertyPath"?P.targetObject.$target:P.targetObject;var x=(i=w.annotations)===null||i===void 0?void 0:(n=i.Common)===null||n===void 0?void 0:n.Text;var y=D.getPathRelativeLocation(P.contextLocation,P.navigationProperties).map(function(A){return A.name;});var z=x?d(g(x,y)):k(t,e,true);return{text:z,collectionBindingDisplay:u,collectionBindingEdit:v,key:k(t,e,true)};},_getPathStructure:function(e){var i,n;var o="";var s=(i=e.contextLocation)!==null&&i!==void 0&&i.targetEntitySet?e.contextLocation.targetEntitySet:e.startingEntitySet;var t=[];var u=((n=e.contextLocation)===null||n===void 0?void 0:n.navigationProperties)||[];var v=_(e.navigationProperties),w;try{var x=function(){var E;var F=w.value;if(!e.contextLocation||!((E=e.contextLocation)!==null&&E!==void 0&&E.navigationProperties.some(function(G){return G.fullyQualifiedName===F.fullyQualifiedName;}))){t.push(F.name);u.push(F);}if(s&&s.navigationPropertyBinding.hasOwnProperty(F.name)){s=s.navigationPropertyBinding[F.name];if(F.isCollection){return"break";}}};for(v.s();!(w=v.n()).done;){var y=x();if(y==="break")break;}}catch(z){v.e(z);}finally{v.f();}o="".concat(t.join("/"));var A=Object.assign({},e);if(A.contextLocation){A.contextLocation.navigationProperties=u;}return{collectionPath:o,itemDataModelObjectPath:A};}});return C;},false);
+sap.ui.define(["sap/fe/macros/MacroMetadata","sap/fe/core/converters/MetaModelConverter","sap/fe/core/templating/UIFormatters","sap/fe/core/converters/helpers/BindingHelper","sap/fe/macros/field/FieldTemplating","sap/fe/core/helpers/BindingExpression","sap/fe/core/templating/DataModelPathHelper"],function(M,a,U,B,b,c,D){"use strict";var d=c.not;var f=c.or;var g=c.isConstant;var h=c.compileBinding;var j=c.constant;var k=c.annotationExpression;var l=c.ifElse;var m=c.and;var p=b.getValueBinding;var q=b.getVisibleExpression;var r=B.UI;var s=U.getDisplayMode;function _(o,n){var v=typeof Symbol!=="undefined"&&o[Symbol.iterator]||o["@@iterator"];if(!v){if(Array.isArray(o)||(v=t(o))||n&&o&&typeof o.length==="number"){if(v)o=v;var i=0;var F=function(){};return{s:F,n:function(){if(i>=o.length)return{done:true};return{done:false,value:o[i++]};},e:function(e){throw e;},f:F};}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");}var w=true,x=false,y;return{s:function(){v=v.call(o);},n:function(){var e=v.next();w=e.done;return e;},e:function(e){x=true;y=e;},f:function(){try{if(!w&&v.return!=null)v.return();}finally{if(x)throw y;}}};}function t(o,e){if(!o)return;if(typeof o==="string")return u(o,e);var n=Object.prototype.toString.call(o).slice(8,-1);if(n==="Object"&&o.constructor)n=o.constructor.name;if(n==="Map"||n==="Set")return Array.from(o);if(n==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return u(o,e);}function u(e,n){if(n==null||n>e.length)n=e.length;for(var i=0,o=new Array(n);i<n;i++){o[i]=e[i];}return o;}var C=M.extend("sap.fe.macros.internal.CollectionField",{name:"CollectionField",namespace:"sap.fe.macros.internal",fragment:"sap.fe.macros.internal.CollectionField",metadata:{stereotype:"xmlmacro",properties:{idPrefix:{type:"string"},vhIdPrefix:{type:"string",defaultValue:"FieldValueHelp"},_vhFlexId:{type:"string",computed:true},metaPath:{type:"sap.ui.model.Context",required:true,$kind:"Property"},ariaLabelledBy:{type:"string"},formatOptions:{type:"object",properties:{showEmptyIndicator:{type:"boolean",defaultValue:false},displayOnly:{type:"boolean",defaultValue:false}}},contextPath:{type:"sap.ui.model.Context",required:true,$kind:["EntitySet","NavigationProperty"]}}},create:function(P){var o=a.getInvolvedDataModelObjects(P.metaPath,P.contextPath);var e=a.convertMetaModelContext(P.metaPath);var i=e.Value.$target;var E=e.Value.path;P.visible=q(o,P.formatOptions);if(E&&E.length>0){o=D.enhanceDataModelPath(o,E);}var I=D.isPathInsertable(o);var n=D.isPathDeletable(o,{ignoreTargetCollection:true,authorizeUnresolvable:true});var v=D.isPathDeletable(o);var w=l(n._type==="Unresolvable",f(d(g(v)),v),v);P.editMode=P.formatOptions.displayOnly==="true"?"Display":h(l(m(I,w,r.IsEditable),j("Editable"),j("Display")));P.displayMode=s(i,o);var x=C._getMultiInputSettings(o,P.formatOptions);P.text=x.text;P.collection=P.editMode==="Display"?x.collectionBindingDisplay:x.collectionBindingEdit;P.key=x.key;return P;},_getMultiInputSettings:function(P,e){var i,n;var o=C._getPathStructure(P),v=o.collectionPath,w=o.itemDataModelObjectPath;var x="{path:'".concat(v,"', templateShareable: false}");var y="{path:'".concat(v,"', parameters: {$$ownRequest : true}, templateShareable: false}");var z=P.targetObject.type==="PropertyPath"?P.targetObject.$target:P.targetObject;var A=(i=z.annotations)===null||i===void 0?void 0:(n=i.Common)===null||n===void 0?void 0:n.Text;var E=D.getPathRelativeLocation(P.contextLocation,P.navigationProperties).map(function(G){return G.name;});var F=A?h(k(A,E)):p(w,e,true);return{text:F,collectionBindingDisplay:x,collectionBindingEdit:y,key:p(w,e,true)};},_getPathStructure:function(e){var i,n;var o="";var v=(i=e.contextLocation)!==null&&i!==void 0&&i.targetEntitySet?e.contextLocation.targetEntitySet:e.startingEntitySet;var w=[];var x=((n=e.contextLocation)===null||n===void 0?void 0:n.navigationProperties)||[];var y=_(e.navigationProperties),z;try{var A=function(){var H;var I=z.value;if(!e.contextLocation||!((H=e.contextLocation)!==null&&H!==void 0&&H.navigationProperties.some(function(J){return J.fullyQualifiedName===I.fullyQualifiedName;}))){w.push(I.name);x.push(I);}if(v&&v.navigationPropertyBinding.hasOwnProperty(I.name)){v=v.navigationPropertyBinding[I.name];if(I.isCollection){return"break";}}};for(y.s();!(z=y.n()).done;){var E=A();if(E==="break")break;}}catch(F){y.e(F);}finally{y.f();}o="".concat(w.join("/"));var G=Object.assign({},e);if(G.contextLocation){G.contextLocation.navigationProperties=x;}return{collectionPath:o,itemDataModelObjectPath:G};}});return C;},false);

package/packages/sap.fe.macros/src/sap/fe/macros/internal/CollectionField.metadata.ts

@@ -10,7 +10,10 @@ import {
 	BindingExpression,
 	constant,
 	compileBinding,
-	Expression
+	Expression,
+	isConstant,
+	or,
+	not
 } from "sap/fe/core/helpers/BindingExpression";
 import * as DataModelPathHelper from "sap/fe/core/templating/DataModelPathHelper";
 import { NavigationProperty, Property } from "@sap-ux/annotation-converter";
@@ -138,7 +141,20 @@ const CollectionField = MacroMetadata.extend("sap.fe.macros.internal.CollectionF
 			oDataModelPath = DataModelPathHelper.enhanceDataModelPath(oDataModelPath, sExtraPath);
 		}
 		const bInsertable = DataModelPathHelper.isPathInsertable(oDataModelPath);
-		const bDeletable = DataModelPathHelper.isPathDeletable(oDataModelPath, undefined, true);
+		const bDeleteNavigationRestriction = DataModelPathHelper.isPathDeletable(oDataModelPath, {
+			ignoreTargetCollection: true,
+			authorizeUnresolvable: true
+		});
+		const bDeletePath = DataModelPathHelper.isPathDeletable(oDataModelPath);
+		// deletable:
+		//		if restrictions come from Navigation we apply it
+		//		otherwise we apply restrictions defined on target collection only if it's a constant
+		//      otherwise it's true!
+		const bDeletable = ifElse(
+			bDeleteNavigationRestriction._type === "Unresolvable",
+			or(not(isConstant(bDeletePath)), bDeletePath),
+			bDeletePath
+		);
 		oProps.editMode =
 			oProps.formatOptions.displayOnly === "true"
 				? "Display"

package/packages/sap.fe.macros/src/sap/fe/macros/internal/DataPoint.fragment.xml

@@ -79,35 +79,18 @@
 				</template:with>
 			</template:elseif>
 			<template:elseif test="{= ${this>formatOptions/defaultDataPointStyle} === 'ObjectNumber'}">
-				<template:if test="{property>$Path@Org.OData.Measures.V1.ISOCurrency}">
-					<template:then>
-						<ObjectNumber
-							unittest:id="ObjectNumberCurrencyTest"
-							id="{= ${this>idPrefix} ? ID.generate([${this>idPrefix}, 'ObjectNumber-Field-display']) : undefined }"
-							state="{this>criticalityColorExpression}"
-							number="{this>objectStatusNumber}"
-							unit="{property>$Path@Org.OData.Measures.V1.ISOCurrency@@MODEL.value}"
-							visible="{this>visible}"
-							emphasized="false"
-							class="sapMObjectNumberLarge"
-							tooltip="{metaPath>@com.sap.vocabularies.Common.v1.QuickInfo@@MODEL.value}"
-						/>
-					</template:then>
-					<template:else>
-						<ObjectNumber
-							unittest:id="ObjectNumberTest"
-							id="{= ${this>idPrefix} ? ID.generate([${this>idPrefix}, 'ObjectNumber-Field-display']) : undefined }"
-							core:require="{FieldRuntime: 'sap/fe/macros/field/FieldRuntime'}"
-							state="{this>criticalityColorExpression}"
-							number="{this>objectStatusNumber}"
-							unit="{= ${property>$Path@Org.OData.Measures.V1.Unit} ? ${property>$Path@Org.OData.Measures.V1.Unit@@MODEL.value} : undefined }"
-							visible="{this>visible}"
-							emphasized="false"
-							class="sapMObjectNumberLarge"
-							tooltip="{metaPath>@com.sap.vocabularies.Common.v1.QuickInfo@@MODEL.value}"
-						/>
-					</template:else>
-				</template:if>
+				<ObjectNumber
+					id="{= ${this>idPrefix} ? ID.generate([${this>idPrefix}, 'ObjectNumber-Field-display']) : undefined }"
+					core:require="{FieldRuntime: 'sap/fe/macros/field/FieldRuntime'}"
+					state="{this>criticalityColorExpression}"
+					number="{this>objectStatusNumber}"
+					unit="{this>unit}"
+					visible="{this>visible}"
+					emphasized="false"
+					class="sapMObjectNumberLarge"
+					tooltip="{metaPath>@com.sap.vocabularies.Common.v1.QuickInfo@@MODEL.value}"
+					emptyIndicatorMode="{this>emptyIndicatorMode}"
+				/>
 			</template:elseif>
 			<template:else>
 				<ObjectStatus

package/packages/sap.fe.macros/src/sap/fe/macros/internal/DataPoint.metadata-dbg.js

@@ -129,6 +129,13 @@ sap.ui.define(
 							measureDisplayMode: {
 								type: "string",
 								allowedValues: ["Hidden", "ReadOnly"]
+							},
+							/**
+							 * If set to 'true', SAP Fiori elements shows an empty indicator in display mode for the ObjectNumber
+							 */
+							showEmptyIndicator: {
+								type: "boolean",
+								defaultValue: false
 							}
 						}
 					},
@@ -158,6 +165,7 @@ sap.ui.define(
 					oProps.objectStatusText = DatapointTemplating.buildFieldBindingExpression(oDataModelPath, oProps.formatOptions, false);
 					oProps.objectStatusNumber = DatapointTemplating.buildFieldBindingExpression(oDataModelPath, oProps.formatOptions, true);
 					oProps.iconExpression = CriticalityFormatters.buildExpressionForCriticalityIcon(oDataPointConverted, oDataModelPath);
+					oProps.unit = DatapointTemplating.buildUnitBindingExpression(oDataModelPath);
 				}
 				if (!oProps.formatOptions) {
 					oProps.formatOptions = {};
@@ -196,6 +204,7 @@ sap.ui.define(
 					oDataPointConverted,
 					oDataModelPath
 				);
+				oProps.emptyIndicatorMode = oProps.formatOptions.showEmptyIndicator ? "On" : undefined;
 				return oProps;
 			}
 		});

package/packages/sap.fe.macros/src/sap/fe/macros/internal/DataPoint.metadata.js

@@ -3,4 +3,4 @@
         (c) Copyright 2009-2021 SAP SE. All rights reserved
     
  */
-sap.ui.define(["../MacroMetadata","sap/fe/macros/internal/helpers/DataPointTemplating","sap/fe/core/converters/MetaModelConverter","sap/fe/core/templating/CriticalityFormatters","sap/fe/macros/field/FieldTemplating","sap/fe/core/templating/DataModelPathHelper","sap/fe/core/helpers/BindingExpression","sap/ui/model/json/JSONModel"],function(M,D,a,C,F,b,B,J){"use strict";return M.extend("sap.fe.macros.internal.DataPoint",{name:"DataPoint",namespace:"sap.fe.macros.internal",fragment:"sap.fe.macros.internal.DataPoint",metadata:{stereotype:"xmlmacro",properties:{idPrefix:{type:"string"},metaPath:{type:"sap.ui.model.Context",required:true,$kind:"Property"},ariaLabelledBy:{type:"string"},formatOptions:{type:"object",properties:{showLabels:{type:"boolean",defaultValue:"false"},iconSize:{type:"string",allowedValues:["1rem","1.375rem","2rem"]},defaultDataPointStyle:{type:"string",allowedValues:["ObjectNumber","ObjectStatus"]},displayMode:{type:"string",allowedValues:["Value","Description","ValueDescription","DescriptionValue"]},measureDisplayMode:{type:"string",allowedValues:["Hidden","ReadOnly"]}}},contextPath:{type:"sap.ui.model.Context",required:true,$kind:["EntitySet","NavigationProperty"]}}},create:function(p,c,s){var d=a.getInvolvedDataModelObjects(p.metaPath,p.contextPath);p.visible=F.getVisibleExpression(d);var o=a.convertMetaModelContext(p.metaPath);var A,e,S=[];if(o&&o.Visualization==="UI.VisualizationType/Progress"){p.displayValue=D.buildExpressionForProgressIndicatorDisplayValue(d);p.percentValue=D.buildExpressionForProgressIndicatorPercentValue(d);}else{p.objectStatusText=D.buildFieldBindingExpression(d,p.formatOptions,false);p.objectStatusNumber=D.buildFieldBindingExpression(d,p.formatOptions,true);p.iconExpression=C.buildExpressionForCriticalityIcon(o,d);}if(!p.formatOptions){p.formatOptions={};}p.visualization=D.getVisualization(d,p.formatOptions.defaultDataPointStyle);if(p.visualization==="LinkWithQuickViewForm"||p.visualization==="LinkWrapper"){p.displayVisible=p.visible;p.entitySet=p.contextPath;p.semanticObject="";if(typeof o.Value==="object"){e=o.Value.path;A=o.Value.$target&&o.Value.$target.annotations&&o.Value.$target.annotations.Common;S=F.getSemanticObjectExpressionToResolve(A);}if(!!p.semanticObject&&p.semanticObject[0]==="{"){S.push({key:p.semanticObject.substr(1,p.semanticObject.length-2),value:p.semanticObject});}p.semanticObjects=F.getSemanticObjects(S);if(e&&e.length>0){d=b.enhanceDataModelPath(d,e);}if(d.targetObject){p.text=F.getTextBinding(d,p.formatOptions);}else{p.text="";}}p.criticalityColorExpression=C.buildExpressionForCriticalityColor(o,d);return p;}});});
+sap.ui.define(["../MacroMetadata","sap/fe/macros/internal/helpers/DataPointTemplating","sap/fe/core/converters/MetaModelConverter","sap/fe/core/templating/CriticalityFormatters","sap/fe/macros/field/FieldTemplating","sap/fe/core/templating/DataModelPathHelper","sap/fe/core/helpers/BindingExpression","sap/ui/model/json/JSONModel"],function(M,D,a,C,F,b,B,J){"use strict";return M.extend("sap.fe.macros.internal.DataPoint",{name:"DataPoint",namespace:"sap.fe.macros.internal",fragment:"sap.fe.macros.internal.DataPoint",metadata:{stereotype:"xmlmacro",properties:{idPrefix:{type:"string"},metaPath:{type:"sap.ui.model.Context",required:true,$kind:"Property"},ariaLabelledBy:{type:"string"},formatOptions:{type:"object",properties:{showLabels:{type:"boolean",defaultValue:"false"},iconSize:{type:"string",allowedValues:["1rem","1.375rem","2rem"]},defaultDataPointStyle:{type:"string",allowedValues:["ObjectNumber","ObjectStatus"]},displayMode:{type:"string",allowedValues:["Value","Description","ValueDescription","DescriptionValue"]},measureDisplayMode:{type:"string",allowedValues:["Hidden","ReadOnly"]},showEmptyIndicator:{type:"boolean",defaultValue:false}}},contextPath:{type:"sap.ui.model.Context",required:true,$kind:["EntitySet","NavigationProperty"]}}},create:function(p,c,s){var d=a.getInvolvedDataModelObjects(p.metaPath,p.contextPath);p.visible=F.getVisibleExpression(d);var o=a.convertMetaModelContext(p.metaPath);var A,e,S=[];if(o&&o.Visualization==="UI.VisualizationType/Progress"){p.displayValue=D.buildExpressionForProgressIndicatorDisplayValue(d);p.percentValue=D.buildExpressionForProgressIndicatorPercentValue(d);}else{p.objectStatusText=D.buildFieldBindingExpression(d,p.formatOptions,false);p.objectStatusNumber=D.buildFieldBindingExpression(d,p.formatOptions,true);p.iconExpression=C.buildExpressionForCriticalityIcon(o,d);p.unit=D.buildUnitBindingExpression(d);}if(!p.formatOptions){p.formatOptions={};}p.visualization=D.getVisualization(d,p.formatOptions.defaultDataPointStyle);if(p.visualization==="LinkWithQuickViewForm"||p.visualization==="LinkWrapper"){p.displayVisible=p.visible;p.entitySet=p.contextPath;p.semanticObject="";if(typeof o.Value==="object"){e=o.Value.path;A=o.Value.$target&&o.Value.$target.annotations&&o.Value.$target.annotations.Common;S=F.getSemanticObjectExpressionToResolve(A);}if(!!p.semanticObject&&p.semanticObject[0]==="{"){S.push({key:p.semanticObject.substr(1,p.semanticObject.length-2),value:p.semanticObject});}p.semanticObjects=F.getSemanticObjects(S);if(e&&e.length>0){d=b.enhanceDataModelPath(d,e);}if(d.targetObject){p.text=F.getTextBinding(d,p.formatOptions);}else{p.text="";}}p.criticalityColorExpression=C.buildExpressionForCriticalityColor(o,d);p.emptyIndicatorMode=p.formatOptions.showEmptyIndicator?"On":undefined;return p;}});});

package/packages/sap.fe.macros/src/sap/fe/macros/internal/Field.fragment.xml

@@ -18,6 +18,7 @@
 				id="{= ${this>_apiId} ? ${this>_apiId} : (${this>idPrefix} ? ID.generate([${this>idPrefix}, 'Field']) : undefined )}"
 				required="{this>requiredExpression}"
 				editable="{this>editableExpression}"
+				collaborationEnabled="{this>collaborationEnabled}"
 			>
 				<core:Fragment fragmentName="sap.fe.macros.internal.field.FieldContent" type="XML" />
 			</macro:FieldAPI>