@openui5/sap.m 1.103.1 → 1.104.0

package/src/sap/m/p13n/SortController.js

@@ -0,0 +1,153 @@
+/*
+ * ! OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define([
+	'sap/m/p13n/SelectionController',  'sap/m/p13n/SortPanel', 'sap/m/p13n/modules/xConfigAPI'
+], function (BaseController, SortPanel, xConfigAPI) {
+	"use strict";
+
+     /**
+	 * Constructor for a new <code>SortController</code>.
+	 *
+	 * @param {string} [sId] ID for the new control, generated automatically if no ID is given
+	 * @param {object} [mSettings] Initial settings for the new control
+     * @param {sap.ui.core.Control} mSettings.control The control instance to be personalized by this controller
+	 *
+	 * @class
+	 * The <code>SortController</code> serves as base class to create sort specific personalization implementations.
+	 *
+	 * @extends sap.ui.base.Object
+	 *
+	 * @author SAP SE
+	 * @version 1.104.0
+	 *
+	 * @public
+	 * @experimental Since 1.104. Please note that the API of this control is not yet finalized!
+	 * @alias sap.m.p13n.SortController
+	 */
+    var SortController = BaseController.extend("sap.m.p13n.SortController", {
+        constructor: function() {
+			BaseController.apply(this, arguments);
+			this._bResetEnabled = true;
+		}
+    });
+
+    SortController.prototype.getStateKey = function() {
+        return "sorters";
+    };
+
+    SortController.prototype.getDelta = function(mPropertyBag) {
+        mPropertyBag.deltaAttributes.push("descending");
+        return BaseController.prototype.getDelta.apply(this, arguments);
+    };
+
+    SortController.prototype.initAdaptationUI = function(oPropertyHelper){
+
+        var oSortPanel;
+
+        oSortPanel = new SortPanel();
+
+        var oAdaptationData = this.mixInfoAndState(oPropertyHelper);
+        oSortPanel.setP13nData(oAdaptationData.items);
+        this._oPanel = oSortPanel;
+
+        return Promise.resolve(oSortPanel);
+    };
+
+    SortController.prototype.model2State = function() {
+        var aItems = [];
+        if (this._oPanel) {
+            this._oPanel.getP13nData(true).forEach(function(oItem){
+                if (oItem.sorted){
+                    aItems.push({
+                        key: oItem.key
+                    });
+                }
+            });
+            return aItems;
+        }
+    };
+
+    SortController.prototype.getChangeOperations = function() {
+        return {
+            add: "addSort",
+            remove: "removeSort"
+        };
+    };
+
+    SortController.prototype.getCurrentState = function(bExternalize) {
+        var oXConfig = xConfigAPI.readConfig(this.getAdaptationControl()) || {};
+        var aSortConditions = oXConfig.hasOwnProperty("properties") ? oXConfig.properties.sortConditions : [];
+
+        return aSortConditions || [];
+    };
+
+    SortController.prototype._createAddRemoveChange = function(oControl, sOperation, oContent){
+        var oAddRemoveChange = {
+            selectorElement: oControl,
+            changeSpecificData: {
+                changeType: sOperation,
+                content: oContent
+            }
+        };
+        return oAddRemoveChange;
+    };
+
+    SortController.prototype._createMoveChange = function(sId, sPropertykey, iNewIndex, sMoveOperation, oControl, bPersistId){
+        var oMoveChange =  {
+            selectorElement: oControl,
+            changeSpecificData: {
+                changeType: sMoveOperation,
+                content: {
+                    id: sId,
+                    key: sPropertykey,
+                    index: iNewIndex
+                }
+            }
+        };
+
+        if (!bPersistId) {
+            delete oMoveChange.changeSpecificData.content.id;
+        }
+
+        return oMoveChange;
+    };
+
+    SortController.prototype._getPresenceAttribute = function(bexternalAppliance){
+        return "sorted";
+    };
+
+    SortController.prototype.mixInfoAndState = function(oPropertyHelper) {
+
+        var aItemState = this.getCurrentState();
+        var mExistingSorters = this.arrayToMap(aItemState);
+
+        var oP13nData = this.prepareAdaptationData(oPropertyHelper, function(mItem, oProperty){
+
+            var oExistingSorter = mExistingSorters[oProperty.key];
+
+            mItem.sorted = oExistingSorter ? true : false;
+            mItem.sortPosition = oExistingSorter ? oExistingSorter.position : -1;
+            mItem.descending = oExistingSorter ? !!oExistingSorter.descending : false;
+
+            return !(oProperty.sortable === false);
+        });
+
+        this.sortP13nData({
+            visible: "sorted",
+            position: "sortPosition"
+        }, oP13nData.items);
+
+        oP13nData.presenceAttribute = this._getPresenceAttribute();
+
+        oP13nData.items.forEach(function(oItem){delete oItem.sortPosition;});
+
+        return oP13nData;
+    };
+
+	return SortController;
+
+});

package/src/sap/m/p13n/SortPanel.js

@@ -21,7 +21,7 @@ sap.ui.define([
 	 * @extends sap.m.p13n.QueryPanel
 	 *
 	 * @author SAP SE
-	 * @version 1.103.1
+	 * @version 1.104.0
 	 *
 	 * @public
 	 * @experimental Since 1.96.
@@ -31,6 +31,16 @@ sap.ui.define([
 
 	var SortPanel = QueryPanel.extend("sap.m.p13n.SortPanel", {
 		metadata: {
+			properties: {
+				/**
+				 * A short text describing the panel.
+				 * <b>Note:</b> This text will only be displayed if the panel is being used in a <code>sap.m.p13n.Popup</code>.
+				 */
+				 title: {
+					type: "string",
+					defaultValue: sap.ui.getCore().getLibraryResourceBundle("sap.m").getText("p13n.DEFAULT_TITLE_SORT")
+				}
+			},
 			library: "sap.m"
 		},
 		renderer: {

package/src/sap/m/p13n/enum/PersistenceMode.js

@@ -0,0 +1,43 @@
+/*
+ * OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+sap.ui.define(function () {
+    "use strict";
+    /**
+     * Enumeration of the preferred persistence mode for personalization changes.
+     *
+     * @enum {string}
+     * @since 1.104
+     * @alias sap.m.p13n.enum.PersistenceMode
+     */
+    var PersistenceMode = {
+        /**
+         * Personalization changes are created in the flexibility layer using <code>ignoreVariantManagement: true</code>
+         *
+         * @private
+         * @ui5-restricted sap.ui.mdc
+         */
+        Global: "Global",
+
+        /**
+         * Personalization changes are created and implicitly persisted only in case no additional <code>VariantManagement</code>
+         * control reference could be found. If a <code>sap.ui.fl.variants.VariantManagement</code> has been found,
+         * it will be used instead.
+         *
+         * @ui5-restricted sap.fe
+         */
+        Auto: "Auto",
+
+        /**
+         * Personalization changes are not persisted
+         *
+         * @private
+         * @ui5-restricted sap.ui.mdc
+         */
+        Transient: "Transient"
+    };
+
+    return PersistenceMode;
+}, /* bExport= */ true);

package/src/sap/m/p13n/handler/xConfigHandler.js

@@ -0,0 +1,166 @@
+/*
+ * ! OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define([
+    'sap/m/p13n/Engine'
+], function(Engine) {
+	"use strict";
+
+	/**
+	 * @class Utility class for generic mdc xConfig handling by utilizing the
+     * <code>sap.m.p13n.Engine</code> and its <code>Modificationhandler</code>.
+     * This class should be used to handle property changes that should be persisted
+     * as flex changes for MDC control while enabling preprocessing via customdata.
+	 *
+	 * @author SAP SE
+	 * @private
+	 * @alias sap.m.flexibility.xConfigHandler
+	 */
+    var xConfigHandler = {};
+
+    var fConfigModified = function(oControl) {
+        if (!oControl._bWaitForModificationChanges && oControl.isA) {
+            oControl._bWaitForModificationChanges = true;
+            sap.m.p13n.Engine.getInstance().waitForChanges(oControl).then(function() {
+                delete oControl._bWaitForModificationChanges;
+                sap.m.p13n.Engine.getInstance().fireStateChange(oControl);
+            });
+        }
+	};
+
+    var fnQueueChange = function(oControl, fTask) {
+		var fCleanupPromiseQueue = function(pOriginalPromise) {
+			if (oControl._pQueue === pOriginalPromise){
+				delete oControl._pQueue;
+			}
+		};
+
+		oControl._pQueue = oControl._pQueue instanceof Promise ? oControl._pQueue.then(fTask) : fTask();
+		oControl._pQueue.then(fCleanupPromiseQueue.bind(null, oControl._pQueue));
+
+		return oControl._pQueue;
+	};
+
+    /**
+     * Creates a changehandler specific to the provided aggregation and property name,
+     * to enhance the xConfig object for a given mdc control instance.
+     *
+     * The enhanced object can be accesed using <code>Engine#readAggregationConfig</code>.
+     *
+     * @param {object} mMetaConfig A map describing the metadata structure that is affected by this changehandler
+     * @param {boolean} mMetaConfig.aggregationBased Defines whether the aggregation space or the property space should be used in the xConfig object
+     * @param {string} mMetaConfig.property The property name (such as <code>width</code> or <code>label</code>)
+     * @param {string} mMetaConfig.operation The operation to be executed by the handler (add, remove, move, set)
+     *
+     * @returns {object} The created changehandler object
+     */
+    xConfigHandler.createHandler = function(mMetaConfig) {
+
+        if (!mMetaConfig || !mMetaConfig.hasOwnProperty("property")) {
+            throw new Error("Please provide a map containing the affected aggregation and property name!");
+        }
+
+        var sAffectedProperty = mMetaConfig.property;
+        var sAffectedAggregation;
+
+        return {
+            "changeHandler": {
+                applyChange: function (oChange, oControl, mPropertyBag) {
+
+                    return fnQueueChange(oControl, function(){
+                        return sap.m.p13n.Engine.getInstance().readXConfig(oControl, {
+                            propertyBag: mPropertyBag
+                        })
+                        .then(function(oPriorAggregationConfig) {
+
+                            var sOperation = oChange.getChangeType().indexOf("add") > -1 ? "add" : "remove";
+                            sOperation = oChange.getChangeType().indexOf("move") === 0 ? "move" : sOperation;
+
+                            sAffectedAggregation = oChange.getContent().targetAggregation;
+
+                            var sOldValue = sOperation !== "add";
+
+                            if (oPriorAggregationConfig
+                                && oPriorAggregationConfig.aggregations
+                                && oPriorAggregationConfig.aggregations[sAffectedAggregation]
+                                && oPriorAggregationConfig.aggregations[sAffectedAggregation][oChange.getContent().key]
+                                && oPriorAggregationConfig.aggregations[sAffectedAggregation][oChange.getContent().key][sAffectedProperty]
+                                ){
+                                    sOldValue = oPriorAggregationConfig.aggregations[sAffectedAggregation][oChange.getContent().key][sAffectedProperty];
+                            }
+
+                            oChange.setRevertData({
+                                key: oChange.getContent().key,
+                                value: sOldValue
+                            });
+
+                            var oConfig = {
+                                property: sAffectedProperty,
+                                key: oChange.getContent().key,
+                                value: oChange.getContent(),
+                                operation: sOperation,
+                                propertyBag: mPropertyBag
+                            };
+
+                            if (mMetaConfig.aggregationBased) {
+                                oConfig.controlMeta = {
+                                    aggregation: sAffectedAggregation
+                                };
+                            }
+
+                            return sap.m.p13n.Engine.getInstance().enhanceXConfig(oControl, oConfig);
+                        })
+                        .then(function() {
+                            fConfigModified(oControl);
+                        });
+
+                    });
+
+                },
+                completeChangeContent: function (oChange, mChangeSpecificInfo, mPropertyBag) {
+                    // Not used, but needs to be there
+                },
+                revertChange: function (oChange, oControl, mPropertyBag) {
+
+                    var sOperation = oChange.getChangeType().indexOf("add") > -1 ? "remove" : "add";
+                    sOperation = oChange.getChangeType().indexOf("move") === 0 ? "move" : sOperation;
+
+                    sAffectedAggregation = oChange.getContent().targetAggregation;
+
+                    var oConfig = {
+                        controlMeta: {
+                            aggregation: sAffectedAggregation,
+                            property: sAffectedProperty
+                        },
+                        property: sAffectedProperty,
+                        operation: sOperation,
+                        key: oChange.getRevertData().key,
+                        value: oChange.getRevertData(),
+                        propertyBag: mPropertyBag
+                    };
+
+                    if (mMetaConfig.aggregationBased) {
+                        oConfig.controlMeta = {
+                            aggregation: sAffectedAggregation
+                        };
+                    }
+
+                    return sap.m.p13n.Engine.getInstance().enhanceXConfig(oControl, oConfig)
+                    .then(function() {
+                        oChange.resetRevertData();
+                        fConfigModified(oControl);
+                    });
+                }
+            },
+            "layers": {
+                "USER": true
+            }
+        };
+    };
+
+    return xConfigHandler;
+
+});

package/src/sap/m/p13n/modification/FlexModificationHandler.js

@@ -0,0 +1,90 @@
+/*
+* ! OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+*/
+sap.ui.define([
+    "./ModificationHandler",
+    "sap/m/p13n/FlexUtil",
+    "sap/ui/fl/apply/api/FlexRuntimeInfoAPI",
+    "sap/m/p13n/enum/PersistenceMode"
+], function(ModificationHandler, FlexUtil, FlexRuntimeInfoAPI, mode) {
+	"use strict";
+
+    var oFlexModificationHandler;
+
+
+    /**
+	 * @class This class offers <code>sap.ui.fl</code> capabilities.
+     * It should be used as the persistence layer in the {@link sap.m.p13n.Engine#register Engine#register}process.
+	 *
+	 * @author SAP SE
+	 * @public
+     * @experimental Since 1.104.
+	 * @alias sap.m.p13n.modification.FlexModificationHandler
+	 */
+	var FlexModificationHandler = ModificationHandler.extend("sap.m.p13n.modification.FlexModificationHandler");
+
+    FlexModificationHandler.prototype.processChanges = function(aChanges, oModificationPayload){
+        var oControl = aChanges && aChanges[0] ? aChanges[0].selectorElement : undefined;
+
+        var sInternalPersistenceMode = oModificationPayload.mode;
+
+        /**
+         * In case of 'Auto' we internally overwrite the persistence mode to use the VM
+         * in case it has been provided instead of the PP
+         */
+        var bIsAutoGlobal = sInternalPersistenceMode === mode.Auto;
+        if (bIsAutoGlobal) {
+            sInternalPersistenceMode = oModificationPayload.hasVM ? "Standard" : mode.Global;
+        }
+
+        var bIsGlobal = sInternalPersistenceMode === mode.Global;
+
+        var bIsTransient = sInternalPersistenceMode === mode.Transient;
+        var oHandleChangesPromise = FlexUtil.handleChanges.call(this, aChanges, bIsGlobal, bIsTransient);
+        return bIsGlobal ? oHandleChangesPromise.then(function(aDirtyChanges){
+            return FlexUtil.saveChanges.call(this, oControl, aDirtyChanges);
+        }) : oHandleChangesPromise;
+    };
+
+    FlexModificationHandler.prototype.waitForChanges = function(mPropertyBag, oModificationPayload){
+        return FlexRuntimeInfoAPI.waitForChanges.apply(this, arguments);
+    };
+
+    FlexModificationHandler.prototype.reset = function(mPropertyBag, oModificationPayload){
+        var sPersistenceMode = oModificationPayload.mode;
+
+        var bIsGlobal = sPersistenceMode === mode.Global;
+        var bIsAutoGlobal = !oModificationPayload.hasVM && oModificationPayload.hasPP && sPersistenceMode === mode.Auto;
+
+        return (bIsGlobal || bIsAutoGlobal) ? FlexUtil.reset.call(this, mPropertyBag) : FlexUtil.restore.call(this, mPropertyBag);
+    };
+
+    FlexModificationHandler.prototype.isModificationSupported = function(mPropertyBag, oModificationPayload){
+        return FlexRuntimeInfoAPI.isFlexSupported.apply(this, arguments);
+    };
+
+    FlexModificationHandler.prototype.initialize = function(oControl) {
+        return sap.ui.getCore().loadLibrary('sap.ui.fl', {
+			async: true
+		})
+		.then(function() {
+            return this.waitForChanges({
+                element: oControl
+            });
+        }.bind(this))
+        .then(function(){
+            sap.m.p13n.Engine.getInstance().fireStateChange(oControl);
+        });
+    };
+
+    FlexModificationHandler.getInstance = function() {
+        if (!oFlexModificationHandler){
+            oFlexModificationHandler = new FlexModificationHandler();
+        }
+        return oFlexModificationHandler;
+    };
+
+	return FlexModificationHandler;
+});

package/src/sap/m/p13n/modification/LocalStorageModificationHandler.js

@@ -0,0 +1,75 @@
+/*
+* ! OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+*/
+sap.ui.define([
+	"sap/m/p13n/modification/ModificationHandler"
+], function(Modificationhandler) {
+	"use strict";
+
+	var oLocalStorageModificationHandler;
+	var mInitialState = new WeakMap();
+
+	/**
+	 * @class This class offers <code>localStorage</code> capabilities.
+     * It should be used as the persistence layer in the {@link sap.m.p13n.Engine#register Engine#register} process.
+	 *
+	 * @author SAP SE
+	 * @public
+     * @experimental Since 1.104.
+	 * @alias sap.m.p13n.modification.LocalStorageModificationHandler
+	 */
+	var LocalStorageModificationHandler = Modificationhandler.extend("sap.m.p13n.modification.LocalStorageModificationHandler");
+
+	LocalStorageModificationHandler.prototype.processChanges = function(aChanges, oModificationPayload){
+        var pAppliance = Modificationhandler.prototype.processChanges.apply(this, arguments);
+        var oControl = aChanges && aChanges[0] ? aChanges[0].selectorElement : undefined;
+
+        return pAppliance.then(function(){
+            return sap.m.p13n.Engine.getInstance().retrieveState(oControl)
+            .then(function(oState){
+                localStorage.setItem("$p13n.Engine.data--" + oControl.getId(), JSON.stringify(oState));
+            });
+        });
+	};
+
+	LocalStorageModificationHandler.prototype.initialize = function(oControl) {
+        var oInitialState = JSON.parse(localStorage.getItem("$p13n.Engine.data--" + oControl.getId()));
+		var pInitial;
+		if (!oInitialState) {
+			pInitial = sap.m.p13n.Engine.getInstance().retrieveState(oControl)
+			.then(function(oRetrievedState){
+				oInitialState = oRetrievedState;
+			});
+		} else {
+			pInitial = sap.m.p13n.Engine.getInstance().applyState(oControl, oInitialState, true);
+		}
+
+		mInitialState.set(oControl, oInitialState);
+		return pInitial;
+	};
+
+    LocalStorageModificationHandler.prototype.waitForChanges = function(mPropertyBag, oModificationPayload) {
+        return Promise.resolve();
+	};
+
+	LocalStorageModificationHandler.prototype.reset = function(mPropertyBag, oModificationPayload) {
+		var oControl = mPropertyBag.selector;
+		localStorage.removeItem("$p13n.Engine.data--" + oControl.getId());
+		return sap.m.p13n.Engine.getInstance().applyState(oControl, mInitialState.get(oControl), true);
+	};
+
+	LocalStorageModificationHandler.prototype.isModificationSupported = function(mPropertyBag, oModificationPayload){
+		return false;
+	};
+
+	LocalStorageModificationHandler.getInstance = function() {
+		if (!oLocalStorageModificationHandler){
+			oLocalStorageModificationHandler = new LocalStorageModificationHandler();
+		}
+		return oLocalStorageModificationHandler;
+	};
+
+	return LocalStorageModificationHandler;
+});

package/src/sap/m/p13n/modification/ModificationHandler.js

@@ -0,0 +1,133 @@
+/*
+* ! OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+*/
+sap.ui.define([
+	"sap/ui/base/Object",
+	"sap/base/util/merge",
+	"sap/ui/core/util/reflection/JsControlTreeModifier"
+], function(BaseObject, merge, JsControlTreeModifier) {
+	"use strict";
+
+	var oModificationHandler;
+
+	/**
+	 * @class This class offers modification capabilities without persistence.
+     * It should be used as the persistence layer in the {@link sap.m.p13n.Engine#register Engine#register} process.
+	 *
+	 * @author SAP SE
+	 * @public
+     * @experimental Since 1.104.
+	 * @alias sap.m.p13n.modification.ModificationHandler
+	 */
+	var ModificationHandler = BaseObject.extend("sap.m.p13n.modification.ModificationHandler");
+
+	/**
+	 * Should implement the appliance of changes
+	 *
+	 * @param {array} aChanges An array of changes
+	 * @param {object} oModificationPayload An object providing a modification handler specific payload
+	 * @returns {Promise} Returns a <code>Promise</code> reflecting change processing
+	 */
+	ModificationHandler.prototype.processChanges = function(aChanges, oModificationPayload){
+
+		var aChangeAppliance = [];
+
+		aChanges.forEach(function(oChange){
+			var oChangeContent = oChange.changeSpecificData.content;
+			var oControl = oChange.selectorElement;
+			var sChangeType = oChange.changeSpecificData.changeType;
+			// var oItem = sap.ui.getCore().byId(oChangeContent.name);
+			// var sTargetAggregation = oChangeContent.targetAggregation;
+			// var oSelector = oChange.selectorElement;
+			// var oContent = oChange.changeSpecificData.content;
+
+			var oTransientChange = {
+				getContent: function() {
+					return oChangeContent;
+				},
+
+				getChangeType: function() {
+					return sChangeType;
+				},
+
+				getControl: function() {
+					return oControl;
+				},
+
+				setRevertData: function() {
+				}
+			};
+
+			var oPromise = new Promise(function(resolve){
+				sap.ui.require(["sap/m/flexibility/EngineFlex"], function(EngineFlex){
+					var pAppliance = EngineFlex[sChangeType].changeHandler.applyChange(oTransientChange, oControl, {
+						modifier: JsControlTreeModifier
+					});
+
+					resolve(pAppliance);
+				});
+			});
+
+			aChangeAppliance.push(oPromise);
+		});
+
+		return Promise.all(aChangeAppliance);
+	};
+
+	/**
+	 * Should implement a function that returns a promise resolving
+	 * after the current pending changes have been applied.
+	 *
+	 * @private
+	 * @param {object} mPropertyBag A propertybag containing modification specific configuration
+	 * @param {sap.ui.core.Element} mPropertyBag.element The according element which should be checked
+	 * @param {object} oModificationPayload An object providing a modification handler specific payload
+	 * @returns {Promise} Returns a <code>Promise</code> reflecting change appliance
+
+	 */
+	ModificationHandler.prototype.waitForChanges = function(mPropertyBag, oModificationPayload) {
+		return Promise.resolve();
+	};
+
+	/**
+	 * Should implement a function that returns a promise resolving
+	 * after the current pending changes have been reset.
+	 *
+	 * @private
+	 * @param {object} mPropertyBag A propertybag containing modification specific configuration
+	 * @param {sap.ui.core.Element} mPropertyBag.selector The according element which should be checked
+	 * @param {object} oModificationPayload An object providing a modification handler specific payload
+	 * @returns {Promise} Returns a <code>Promise</code> reflecting the reset execution
+	 */
+	ModificationHandler.prototype.reset = function(mPropertyBag, oModificationPayload) {
+		return Promise.resolve();
+	};
+
+	/**
+	 * Should implement a function that returns information ont modification support
+	 *
+	 * @private
+	 * @param {object} mPropertyBag A propertybag containing modification specific configuration
+	 * @param {sap.ui.core.Element} mPropertyBag.selector The according element which should be checked
+	 * @param {object} oModificationPayload An object providing a modification handler specific payload
+ 	 * @returns {boolean} reflects the modification support state
+	 */
+	ModificationHandler.prototype.isModificationSupported = function(mPropertyBag, oModificationPayload){
+		return false;
+	};
+
+	ModificationHandler.prototype.initialize = function(oControl) {
+		return Promise.resolve();
+	};
+
+	ModificationHandler.getInstance = function() {
+		if (!oModificationHandler){
+			oModificationHandler = new ModificationHandler();
+		}
+		return oModificationHandler;
+	};
+
+	return ModificationHandler;
+});