@sapui5/sap.fe.core 1.99.0 → 1.101.1

package/src/sap/fe/core/controls/ConditionalWrapper.ts

@@ -0,0 +1,74 @@
+import Control from "sap/ui/core/Control";
+import { aggregation, association, defineUI5Class, implementInterface, property } from "sap/fe/core/helpers/ClassSupport";
+import { CSSSize, IFormContent } from "sap/ui/core/library";
+import RenderManager from "sap/ui/core/RenderManager";
+
+@defineUI5Class("sap.fe.core.controls.ConditionalWrapper")
+class ConditionalWrapper extends Control implements IFormContent {
+	@implementInterface("sap.ui.core.IFormContent")
+	__implements__sap_ui_core_IFormContent: boolean = true;
+
+	@property({ type: "sap.ui.core.CSSSize", defaultValue: null })
+	width!: CSSSize;
+
+	@property({ type: "boolean", defaultValue: false })
+	formDoNotAdjustWidth!: boolean;
+
+	@property({ type: "boolean", defaultValue: false })
+	condition!: boolean;
+
+	/**
+	 * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).
+	 */
+	@association({ type: "sap.ui.core.Control", multiple: true, singularName: "ariaLabelledBy" })
+	ariaLabelledBy!: Control[];
+
+	@aggregation({ type: "sap.ui.core.Control", multiple: false, isDefault: true })
+	contentTrue!: Control;
+
+	@aggregation({ type: "sap.ui.core.Control", multiple: false })
+	contentFalse!: Control;
+
+	enhanceAccessibilityState(oElement: any, mAriaProps: any) {
+		const oParent = this.getParent() as any;
+
+		if (oParent && oParent.enhanceAccessibilityState) {
+			oParent.enhanceAccessibilityState(this, mAriaProps);
+		}
+
+		return mAriaProps;
+	}
+	_setAriaLabelledBy(oContent: any) {
+		if (oContent && oContent.addAriaLabelledBy) {
+			const aAriaLabelledBy = this.ariaLabelledBy;
+
+			for (let i = 0; i < aAriaLabelledBy.length; i++) {
+				const sId = aAriaLabelledBy[i];
+				const aAriaLabelledBys = oContent.getAriaLabelledBy() || [];
+				if (aAriaLabelledBys.indexOf(sId) === -1) {
+					oContent.addAriaLabelledBy(sId);
+				}
+			}
+		}
+	}
+	onBeforeRendering() {
+		// before calling the renderer of the ConditionalWrapper parent control may have set ariaLabelledBy
+		// we ensure it is passed to its inner controls
+		this._setAriaLabelledBy(this.contentTrue);
+		this._setAriaLabelledBy(this.contentFalse);
+	}
+	static render(oRm: RenderManager, oControl: ConditionalWrapper) {
+		oRm.openStart("div", oControl);
+		oRm.style("width", oControl.width);
+		oRm.style("display", "inline-block");
+		oRm.openEnd();
+		if (oControl.condition) {
+			oRm.renderControl(oControl.contentTrue);
+		} else {
+			oRm.renderControl(oControl.contentFalse);
+		}
+		oRm.close("div"); // end of the complete Control
+	}
+}
+
+export default ConditionalWrapper;

package/src/sap/fe/core/controls/CustomFilterFieldContentWrapper.js

@@ -0,0 +1,366 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/fe/core/helpers/SemanticDateOperators", "sap/ui/base/ManagedObjectObserver", "sap/ui/core/Control", "sap/ui/mdc/condition/Condition", "sap/ui/mdc/enum/ConditionValidated", "sap/ui/mdc/field/ConditionsType", "sap/ui/model/json/JSONModel"], function (ClassSupport, SemanticDateOperators, ManagedObjectObserver, Control, Condition, ConditionValidated, ConditionsType, JSONModel) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _class3, _temp;
+
+  var _exports = {};
+  var property = ClassSupport.property;
+  var implementInterface = ClassSupport.implementInterface;
+  var event = ClassSupport.event;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  var aggregation = ClassSupport.aggregation;
+
+  function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+
+  function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); }
+
+  var CustomFilterFieldContentWrapper = (
+  /**
+   * @class
+   * Creates an <code>sap.fe.core.controls.CustomFilterFieldContentWrapper</code> object.
+   * This is used in the {@link sap.ui.mdc.FilterField FilterField} as a filter content.
+   * @extends sap.ui.core.Control
+   * @private
+   * @alias sap.fe.core.controls.CustomFilterFieldContentWrapper
+   */
+  _dec = defineUI5Class("sap.fe.core.controls.CustomFilterFieldContentWrapper"), _dec2 = implementInterface("sap.ui.core.IFormContent"), _dec3 = property({
+    type: "sap.ui.core.CSSSize",
+    defaultValue: null
+  }), _dec4 = property({
+    type: "boolean",
+    defaultValue: false
+  }), _dec5 = property({
+    type: "object[]",
+    defaultValue: []
+  }), _dec6 = aggregation({
+    type: "sap.ui.core.Control",
+    multiple: false,
+    isDefault: true
+  }), _dec7 = event(), _dec(_class = (_class2 = (_temp = _class3 = /*#__PURE__*/function (_Control) {
+    _inheritsLoose(CustomFilterFieldContentWrapper, _Control);
+
+    function CustomFilterFieldContentWrapper() {
+      var _this;
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _Control.call.apply(_Control, [this].concat(args)) || this;
+
+      _initializerDefineProperty(_this, "__implements__sap_ui_core_IFormContent", _descriptor, _assertThisInitialized(_this));
+
+      _initializerDefineProperty(_this, "width", _descriptor2, _assertThisInitialized(_this));
+
+      _initializerDefineProperty(_this, "formDoNotAdjustWidth", _descriptor3, _assertThisInitialized(_this));
+
+      _initializerDefineProperty(_this, "conditions", _descriptor4, _assertThisInitialized(_this));
+
+      _initializerDefineProperty(_this, "content", _descriptor5, _assertThisInitialized(_this));
+
+      _initializerDefineProperty(_this, "conditionsChange", _descriptor6, _assertThisInitialized(_this));
+
+      return _this;
+    }
+
+    _exports = CustomFilterFieldContentWrapper;
+
+    CustomFilterFieldContentWrapper.render = function render(renderManager, control) {
+      renderManager.openStart("div", control);
+      renderManager.style("min-height", "1rem");
+      renderManager.style("width", control.width);
+      renderManager.openEnd();
+      renderManager.renderControl(control.getContent()); // render the child Control
+
+      renderManager.close("div"); // end of the complete Control
+    }
+    /**
+     * Maps an array of filter values to an array of conditions.
+     *
+     * @param {Array | string} filterValues Array of filter value bindings or a filter value string
+     * @param {string} [operator] The operator to be used (optional) - if not set, the default operator (EQ) will be used
+     * @private
+     * @returns {Array} Array of filter conditions
+     */
+    ;
+
+    CustomFilterFieldContentWrapper._filterValuesToConditions = function _filterValuesToConditions(filterValues, operator) {
+      var formatOptions = {
+        operators: []
+      },
+          conditions = [];
+
+      if (operator) {
+        formatOptions = {
+          operators: [operator]
+        };
+      }
+
+      if (filterValues === "") {
+        filterValues = [];
+      } else if (typeof filterValues === "object" && filterValues.hasOwnProperty("operator") && filterValues.hasOwnProperty("values")) {
+        formatOptions = {
+          operators: [filterValues.operator]
+        };
+        filterValues = filterValues.values;
+      } else if (filterValues !== undefined && typeof filterValues !== "object" && typeof filterValues !== "string") {
+        throw new Error("FilterUtils.js#_filterValuesToConditions: Unexpected type of input parameter vValues: " + typeof filterValues);
+      }
+
+      var conditionsType = new ConditionsType(formatOptions);
+      var conditionValues = Array.isArray(filterValues) ? filterValues : [filterValues]; // Shortcut for operator without values and semantic date operations
+
+      if (typeof operator === "string" && (conditionValues.length === 0 || SemanticDateOperators.getSemanticDateOperations().includes(operator))) {
+        conditions = [Condition.createCondition(operator, conditionValues, null, null, ConditionValidated.NotValidated)];
+      } else {
+        conditions = conditionValues.map(function (conditionValue) {
+          var stringValue = conditionValue === null || conditionValue === void 0 ? void 0 : conditionValue.toString(),
+              parsedConditions = conditionsType.parseValue(stringValue, "any");
+          return parsedConditions === null || parsedConditions === void 0 ? void 0 : parsedConditions[0];
+        }).filter(function (conditionValue) {
+          return conditionValue !== undefined;
+        });
+      }
+
+      return conditions;
+    }
+    /**
+     * Maps an array of conditions to a comma separated list of filter values.
+     *
+     * @param {object[]} conditions Array of filter conditions
+     * @param {object} formatOptions Format options that specifies a condition type
+     * @private
+     * @returns {string} Concatenated string of filter values
+     */
+    ;
+
+    CustomFilterFieldContentWrapper._conditionsToFilterModelString = function _conditionsToFilterModelString(conditions, formatOptions) {
+      var conditionsType = new ConditionsType(formatOptions);
+      return conditions.map(function (condition) {
+        return conditionsType.formatValue([condition], "any") || "";
+      }).filter(function (stringValue) {
+        return stringValue !== "";
+      }).join(",");
+    }
+    /**
+     * Listens to filter model changes and updates wrapper property "conditions".
+     *
+     * @param {object} changeEvent Event triggered by a filter model change
+     * @private
+     */
+    ;
+
+    var _proto = CustomFilterFieldContentWrapper.prototype;
+
+    _proto._handleFilterModelChange = function _handleFilterModelChange(changeEvent) {
+      var propertyPath = this.getObjectBinding("filterValues").getPath(),
+          values = changeEvent.getSource().getProperty(propertyPath);
+      this.updateConditionsByFilterValues(values, "");
+    }
+    /**
+     * Listens to "conditions" changes and updates the filter model.
+     *
+     * @param {object} conditions Event triggered by a "conditions" change
+     * @private
+     */
+    ;
+
+    _proto._handleConditionsChange = function _handleConditionsChange(conditions) {
+      this.updateFilterModelByConditions(conditions);
+    }
+    /**
+     * Initialize CustomFilterFieldContentWrapper control and register observer.
+     */
+    ;
+
+    _proto.init = function init() {
+      _Control.prototype.init.call(this);
+
+      this._conditionsObserver = new ManagedObjectObserver(this._observeChanges.bind(this));
+
+      this._conditionsObserver.observe(this, {
+        properties: ["conditions"]
+      });
+    }
+    /**
+     * Listens to property changes.
+     *
+     * @param {any} changes Property changes
+     * @private
+     */
+    ;
+
+    _proto._observeChanges = function _observeChanges(changes) {
+      if (changes.name === "conditions") {
+        this._handleConditionsChange(changes.current);
+      }
+    }
+    /**
+     * Registers the internal filter model (alias 'filterValues').
+     *
+     * @private
+     */
+    ;
+
+    _proto._registerFilterModel = function _registerFilterModel() {
+      if (!this._filterModel) {
+        this._filterModel = new JSONModel();
+
+        this._filterModel.attachPropertyChange(this._handleFilterModelChange, this);
+
+        this.setModel(this._filterModel, CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS);
+      }
+    }
+    /**
+     * Gets the content of this wrapper control.
+     *
+     * @returns {sap.ui.core.Control} The wrapper content
+     * @private
+     */
+    ;
+
+    _proto.getContent = function getContent() {
+      this._registerFilterModel();
+
+      return this.getAggregation("content");
+    }
+    /**
+     * Gets the value for control property 'conditions'.
+     *
+     * @returns {object[]} Array of filter conditions
+     * @private
+     */
+    ;
+
+    _proto.getConditions = function getConditions() {
+      return this.getProperty("conditions");
+    }
+    /**
+     * Sets the value for control property 'conditions'.
+     *
+     * @param {Array} conditions Array of filter conditions
+     * @private
+     */
+    ;
+
+    _proto.setConditions = function setConditions(conditions) {
+      this.setProperty("conditions", conditions);
+    }
+    /**
+     * Gets the filter model alias 'filterValues'.
+     *
+     * @returns {string} The filter model
+     * @private
+     */
+    ;
+
+    _proto.getFilterModelAlias = function getFilterModelAlias() {
+      return CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS;
+    }
+    /**
+     * Updates the property "conditions" with filter values
+     * sent by ExtensionAPI#setFilterValues().
+     *
+     * @param {any} values The filter values
+     * @param {string} operator The operator name
+     * @private
+     */
+    ;
+
+    _proto.updateConditionsByFilterValues = function updateConditionsByFilterValues(values, operator) {
+      var conditions = CustomFilterFieldContentWrapper._filterValuesToConditions(values, operator);
+
+      this.setConditions(conditions);
+    }
+    /**
+     * Updates filter model with conditions
+     * sent by the {@link sap.ui.mdc.FilterField FilterField}.
+     *
+     * @param {Array} conditions Array of filter conditions
+     * @private
+     */
+    ;
+
+    _proto.updateFilterModelByConditions = function updateFilterModelByConditions(conditions) {
+      var _conditions$;
+
+      // When the filter field is created via "Adapt Filter"
+      // this handler is fired before the filter model is created
+      // -> in general, create it, if needed!
+      // TODO: Consider using method Control#clone() to register filter model
+      this._registerFilterModel();
+
+      var operator = ((_conditions$ = conditions[0]) === null || _conditions$ === void 0 ? void 0 : _conditions$.operator) || "";
+      var formatOptions = operator !== "" ? {
+        operators: [operator]
+      } : {
+        operators: []
+      };
+
+      if (this.getBindingContext(CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS)) {
+        var _this$getBindingConte;
+
+        var stringValue = CustomFilterFieldContentWrapper._conditionsToFilterModelString(conditions, formatOptions);
+
+        this._filterModel.setProperty((_this$getBindingConte = this.getBindingContext(CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS)) === null || _this$getBindingConte === void 0 ? void 0 : _this$getBindingConte.getPath(), stringValue);
+      }
+    } // TODO: Check, if implementation of _setAriaLabelledBy() is needed ?
+    ;
+
+    _proto.getAccessibilityInfo = function getAccessibilityInfo() {
+      var _content$getAccessibi;
+
+      var content = this.getContent();
+      return (content === null || content === void 0 ? void 0 : (_content$getAccessibi = content.getAccessibilityInfo) === null || _content$getAccessibi === void 0 ? void 0 : _content$getAccessibi.call(content)) || {};
+    };
+
+    return CustomFilterFieldContentWrapper;
+  }(Control), _class3.FILTER_MODEL_ALIAS = "filterValues", _temp), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "__implements__sap_ui_core_IFormContent", [_dec2], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: function () {
+      return true;
+    }
+  }), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "width", [_dec3], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "formDoNotAdjustWidth", [_dec4], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "conditions", [_dec5], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor5 = _applyDecoratedDescriptor(_class2.prototype, "content", [_dec6], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor6 = _applyDecoratedDescriptor(_class2.prototype, "conditionsChange", [_dec7], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  })), _class2)) || _class);
+  _exports = CustomFilterFieldContentWrapper;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CustomFilterFieldContentWrapper.ts"],"names":["CustomFilterFieldContentWrapper","defineUI5Class","implementInterface","property","type","defaultValue","aggregation","multiple","isDefault","event","render","renderManager","control","openStart","style","width","openEnd","renderControl","getContent","close","_filterValuesToConditions","filterValues","operator","formatOptions","operators","conditions","hasOwnProperty","values","undefined","Error","conditionsType","ConditionsType","conditionValues","Array","isArray","length","SemanticDateOperators","getSemanticDateOperations","includes","Condition","createCondition","ConditionValidated","NotValidated","map","conditionValue","stringValue","toString","parsedConditions","parseValue","filter","_conditionsToFilterModelString","condition","formatValue","join","_handleFilterModelChange","changeEvent","propertyPath","getObjectBinding","getPath","getSource","getProperty","updateConditionsByFilterValues","_handleConditionsChange","updateFilterModelByConditions","init","_conditionsObserver","ManagedObjectObserver","_observeChanges","bind","observe","properties","changes","name","current","_registerFilterModel","_filterModel","JSONModel","attachPropertyChange","setModel","FILTER_MODEL_ALIAS","getAggregation","getConditions","setConditions","setProperty","getFilterModelAlias","getBindingContext","getAccessibilityInfo","content","Control"],"mappings":"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","sourceRoot":".","sourcesContent":["/*!\n * ${copyright}\n */\nimport { aggregation, defineUI5Class, event, implementInterface, property } from \"sap/fe/core/helpers/ClassSupport\";\nimport SemanticDateOperators from \"sap/fe/core/helpers/SemanticDateOperators\";\nimport ManagedObjectObserver from \"sap/ui/base/ManagedObjectObserver\";\nimport Control from \"sap/ui/core/Control\";\nimport { IFormContent } from \"sap/ui/core/library\";\nimport RenderManager from \"sap/ui/core/RenderManager\";\nimport Condition, { ConditionObject } from \"sap/ui/mdc/condition/Condition\";\nimport ConditionValidated from \"sap/ui/mdc/enum/ConditionValidated\";\nimport ConditionsType from \"sap/ui/mdc/field/ConditionsType\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\n\n/**\n * Type used for format options\n *\n * @typedef FormatOptionsType\n */\ntype FormatOptionsType = {\n\toperators: string[];\n};\n\n/**\n * @class\n * Creates an <code>sap.fe.core.controls.CustomFilterFieldContentWrapper</code> object.\n * This is used in the {@link sap.ui.mdc.FilterField FilterField} as a filter content.\n * @extends sap.ui.core.Control\n * @private\n * @alias sap.fe.core.controls.CustomFilterFieldContentWrapper\n */\n@defineUI5Class(\"sap.fe.core.controls.CustomFilterFieldContentWrapper\")\nexport default class CustomFilterFieldContentWrapper extends Control implements IFormContent {\n\t@implementInterface(\"sap.ui.core.IFormContent\")\n\t// eslint-disable-next-line camelcase\n\t__implements__sap_ui_core_IFormContent = true;\n\n\t@property({ type: \"sap.ui.core.CSSSize\", defaultValue: null })\n\twidth!: string;\n\n\t@property({ type: \"boolean\", defaultValue: false })\n\tformDoNotAdjustWidth!: boolean;\n\n\t@property({ type: \"object[]\", defaultValue: [] })\n\tconditions!: ConditionObject[];\n\n\t@aggregation({ type: \"sap.ui.core.Control\", multiple: false, isDefault: true })\n\tcontent!: Control;\n\n\t@event()\n\tconditionsChange!: Function;\n\n\t// TODO: Consider using FieldBase as base control (instead of Control)\n\t// TODO: If FieldBase is used, add 'change' event & corresponding handler to bubble it\n\n\tprivate _filterModel: any;\n\tprivate _conditionsObserver: any;\n\tprivate static readonly FILTER_MODEL_ALIAS = \"filterValues\";\n\n\tstatic render(renderManager: RenderManager, control: CustomFilterFieldContentWrapper): void {\n\t\trenderManager.openStart(\"div\", control);\n\t\trenderManager.style(\"min-height\", \"1rem\");\n\t\trenderManager.style(\"width\", control.width);\n\t\trenderManager.openEnd();\n\t\trenderManager.renderControl(control.getContent()); // render the child Control\n\t\trenderManager.close(\"div\"); // end of the complete Control\n\t}\n\n\t/**\n\t * Maps an array of filter values to an array of conditions.\n\t *\n\t * @param {Array | string} filterValues Array of filter value bindings or a filter value string\n\t * @param {string} [operator] The operator to be used (optional) - if not set, the default operator (EQ) will be used\n\t * @private\n\t * @returns {Array} Array of filter conditions\n\t */\n\tstatic _filterValuesToConditions(filterValues: any | any[], operator?: string): ConditionObject[] {\n\t\tlet formatOptions: FormatOptionsType = { operators: [] },\n\t\t\tconditions = [];\n\n\t\tif (operator) {\n\t\t\tformatOptions = { operators: [operator] };\n\t\t}\n\t\tif (filterValues === \"\") {\n\t\t\tfilterValues = [];\n\t\t} else if (typeof filterValues === \"object\" && filterValues.hasOwnProperty(\"operator\") && filterValues.hasOwnProperty(\"values\")) {\n\t\t\tformatOptions = { operators: [filterValues.operator] };\n\t\t\tfilterValues = filterValues.values;\n\t\t} else if (filterValues !== undefined && typeof filterValues !== \"object\" && typeof filterValues !== \"string\") {\n\t\t\tthrow new Error(\"FilterUtils.js#_filterValuesToConditions: Unexpected type of input parameter vValues: \" + typeof filterValues);\n\t\t}\n\n\t\tconst conditionsType: any = new ConditionsType(formatOptions);\n\t\tconst conditionValues = Array.isArray(filterValues) ? filterValues : [filterValues];\n\n\t\t// Shortcut for operator without values and semantic date operations\n\t\tif (\n\t\t\ttypeof operator === \"string\" &&\n\t\t\t(conditionValues.length === 0 || SemanticDateOperators.getSemanticDateOperations().includes(operator))\n\t\t) {\n\t\t\tconditions = [Condition.createCondition(operator, conditionValues, null, null, ConditionValidated.NotValidated)];\n\t\t} else {\n\t\t\tconditions = conditionValues\n\t\t\t\t.map((conditionValue) => {\n\t\t\t\t\tconst stringValue = conditionValue?.toString(),\n\t\t\t\t\t\tparsedConditions = conditionsType.parseValue(stringValue, \"any\");\n\t\t\t\t\treturn parsedConditions?.[0];\n\t\t\t\t})\n\t\t\t\t.filter((conditionValue) => conditionValue !== undefined);\n\t\t}\n\n\t\treturn conditions;\n\t}\n\n\t/**\n\t * Maps an array of conditions to a comma separated list of filter values.\n\t *\n\t * @param {object[]} conditions Array of filter conditions\n\t * @param {object} formatOptions Format options that specifies a condition type\n\t * @private\n\t * @returns {string} Concatenated string of filter values\n\t */\n\tstatic _conditionsToFilterModelString(conditions: object[], formatOptions: FormatOptionsType): string {\n\t\tconst conditionsType = new ConditionsType(formatOptions);\n\n\t\treturn conditions\n\t\t\t.map((condition) => {\n\t\t\t\treturn conditionsType.formatValue([condition], \"any\") || \"\";\n\t\t\t})\n\t\t\t.filter((stringValue) => {\n\t\t\t\treturn stringValue !== \"\";\n\t\t\t})\n\t\t\t.join(\",\");\n\t}\n\n\t/**\n\t * Listens to filter model changes and updates wrapper property \"conditions\".\n\t *\n\t * @param {object} changeEvent Event triggered by a filter model change\n\t * @private\n\t */\n\t_handleFilterModelChange(changeEvent: any): void {\n\t\tconst propertyPath = this.getObjectBinding(\"filterValues\").getPath(),\n\t\t\tvalues = changeEvent.getSource().getProperty(propertyPath);\n\t\tthis.updateConditionsByFilterValues(values, \"\");\n\t}\n\n\t/**\n\t * Listens to \"conditions\" changes and updates the filter model.\n\t *\n\t * @param {object} conditions Event triggered by a \"conditions\" change\n\t * @private\n\t */\n\t_handleConditionsChange(conditions: any): void {\n\t\tthis.updateFilterModelByConditions(conditions);\n\t}\n\n\t/**\n\t * Initialize CustomFilterFieldContentWrapper control and register observer.\n\t */\n\tinit(): void {\n\t\tsuper.init();\n\t\tthis._conditionsObserver = new ManagedObjectObserver(this._observeChanges.bind(this));\n\t\tthis._conditionsObserver.observe(this, {\n\t\t\tproperties: [\"conditions\"]\n\t\t});\n\t}\n\n\t/**\n\t * Listens to property changes.\n\t *\n\t * @param {any} changes Property changes\n\t * @private\n\t */\n\t_observeChanges(changes: any): void {\n\t\tif (changes.name === \"conditions\") {\n\t\t\tthis._handleConditionsChange(changes.current);\n\t\t}\n\t}\n\n\t/**\n\t * Registers the internal filter model (alias 'filterValues').\n\t *\n\t * @private\n\t */\n\t_registerFilterModel(): void {\n\t\tif (!this._filterModel) {\n\t\t\tthis._filterModel = new JSONModel();\n\t\t\tthis._filterModel.attachPropertyChange(this._handleFilterModelChange, this);\n\t\t\tthis.setModel(this._filterModel, CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS);\n\t\t}\n\t}\n\n\t/**\n\t * Gets the content of this wrapper control.\n\t *\n\t * @returns {sap.ui.core.Control} The wrapper content\n\t * @private\n\t */\n\tgetContent(): Control {\n\t\tthis._registerFilterModel();\n\t\treturn this.getAggregation(\"content\") as Control;\n\t}\n\n\t/**\n\t * Gets the value for control property 'conditions'.\n\t *\n\t * @returns {object[]} Array of filter conditions\n\t * @private\n\t */\n\tgetConditions(): object[] {\n\t\treturn this.getProperty(\"conditions\");\n\t}\n\n\t/**\n\t * Sets the value for control property 'conditions'.\n\t *\n\t * @param {Array} conditions Array of filter conditions\n\t * @private\n\t */\n\tsetConditions(conditions: object[]): void {\n\t\tthis.setProperty(\"conditions\", conditions);\n\t}\n\n\t/**\n\t * Gets the filter model alias 'filterValues'.\n\t *\n\t * @returns {string} The filter model\n\t * @private\n\t */\n\tgetFilterModelAlias(): string {\n\t\treturn CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS;\n\t}\n\n\t/**\n\t * Updates the property \"conditions\" with filter values\n\t * sent by ExtensionAPI#setFilterValues().\n\t *\n\t * @param {any} values The filter values\n\t * @param {string} operator The operator name\n\t * @private\n\t */\n\tupdateConditionsByFilterValues(values: any, operator: string): void {\n\t\tconst conditions = CustomFilterFieldContentWrapper._filterValuesToConditions(values, operator);\n\t\tthis.setConditions(conditions);\n\t}\n\n\t/**\n\t * Updates filter model with conditions\n\t * sent by the {@link sap.ui.mdc.FilterField FilterField}.\n\t *\n\t * @param {Array} conditions Array of filter conditions\n\t * @private\n\t */\n\tupdateFilterModelByConditions(conditions: any[]): void {\n\t\t// When the filter field is created via \"Adapt Filter\"\n\t\t// this handler is fired before the filter model is created\n\t\t// -> in general, create it, if needed!\n\t\t// TODO: Consider using method Control#clone() to register filter model\n\t\tthis._registerFilterModel();\n\t\tconst operator = conditions[0]?.operator || \"\";\n\t\tconst formatOptions: FormatOptionsType = operator !== \"\" ? { operators: [operator] } : { operators: [] };\n\t\tif (this.getBindingContext(CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS)) {\n\t\t\tconst stringValue = CustomFilterFieldContentWrapper._conditionsToFilterModelString(conditions, formatOptions);\n\t\t\tthis._filterModel.setProperty(\n\t\t\t\tthis.getBindingContext(CustomFilterFieldContentWrapper.FILTER_MODEL_ALIAS)?.getPath(),\n\t\t\t\tstringValue\n\t\t\t);\n\t\t}\n\t}\n\n\t// TODO: Check, if implementation of _setAriaLabelledBy() is needed ?\n\n\tgetAccessibilityInfo(): any {\n\t\tconst content = this.getContent();\n\t\treturn content?.getAccessibilityInfo?.() || {};\n\t}\n}\n"]}