@sapui5/sap.fe.core 1.124.2 → 1.126.0

package/src/sap/fe/core/type/DateTimeWithTimezone.js

@@ -2,7 +2,7 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2024 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/model/odata/type/DateTimeWithTimezone"], function (ClassSupport, _DateTimeWithTimezone) {
+sap.ui.define(["sap/fe/base/ClassSupport", "sap/ui/model/odata/type/DateTimeWithTimezone"], function (ClassSupport, _DateTimeWithTimezone) {
   "use strict";
 
   var _dec, _class;
@@ -32,4 +32,4 @@ sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/model/odata/type/Date
   }(_DateTimeWithTimezone)) || _class);
   return DateTimeWithTimezone;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJEYXRlVGltZVdpdGhUaW1lem9uZSIsImRlZmluZVVJNUNsYXNzIiwib0Zvcm1hdE9wdGlvbnMiLCJvQ29uc3RyYWludHMiLCJiU2hvd1RpbWV6b25lRm9yRW1wdHlWYWx1ZXMiLCJzaG93VGltZXpvbmVGb3JFbXB0eVZhbHVlcyIsImZvcm1hdFZhbHVlIiwiYVZhbHVlcyIsInNUYXJnZXRUeXBlIiwib1RpbWVzdGFtcCIsInVuZGVmaW5lZCIsIl9EYXRlVGltZVdpdGhUaW1lem9uZSJdLCJzb3VyY2VSb290IjoiLiIsInNvdXJjZXMiOlsiRGF0ZVRpbWVXaXRoVGltZXpvbmUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmaW5lVUk1Q2xhc3MgfSBmcm9tIFwic2FwL2ZlL2Jhc2UvQ2xhc3NTdXBwb3J0XCI7XG5pbXBvcnQgX0RhdGVUaW1lV2l0aFRpbWV6b25lIGZyb20gXCJzYXAvdWkvbW9kZWwvb2RhdGEvdHlwZS9EYXRlVGltZVdpdGhUaW1lem9uZVwiO1xuXG5AZGVmaW5lVUk1Q2xhc3MoXCJzYXAuZmUuY29yZS50eXBlLkRhdGVUaW1lV2l0aFRpbWV6b25lXCIpXG5jbGFzcyBEYXRlVGltZVdpdGhUaW1lem9uZSBleHRlbmRzIF9EYXRlVGltZVdpdGhUaW1lem9uZSB7XG5cdHByaXZhdGUgYlNob3dUaW1lem9uZUZvckVtcHR5VmFsdWVzOiBib29sZWFuO1xuXG5cdGNvbnN0cnVjdG9yKG9Gb3JtYXRPcHRpb25zPzogb2JqZWN0ICYgeyBzaG93VGltZXpvbmVGb3JFbXB0eVZhbHVlcz86IGJvb2xlYW4gfSwgb0NvbnN0cmFpbnRzPzogb2JqZWN0KSB7XG5cdFx0c3VwZXIob0Zvcm1hdE9wdGlvbnMsIG9Db25zdHJhaW50cyk7XG5cdFx0dGhpcy5iU2hvd1RpbWV6b25lRm9yRW1wdHlWYWx1ZXMgPSBvRm9ybWF0T3B0aW9ucz8uc2hvd1RpbWV6b25lRm9yRW1wdHlWYWx1ZXMgPz8gdHJ1ZTtcblx0fVxuXG5cdGZvcm1hdFZhbHVlKGFWYWx1ZXM6IHVua25vd25bXSwgc1RhcmdldFR5cGU6IHN0cmluZyk6IHVua25vd24gfCBudWxsIHtcblx0XHRjb25zdCBvVGltZXN0YW1wID0gYVZhbHVlcyAmJiBhVmFsdWVzWzBdO1xuXHRcdGlmIChcblx0XHRcdG9UaW1lc3RhbXAgPT09IHVuZGVmaW5lZCB8fCAvLyBkYXRhIGlzIG5vdCB5ZXQgYXZhaWxhYmxlXG5cdFx0XHQvLyBpZiB0aW1lIHpvbmUgaXMgbm90IHNob3duIGZhbHN5IHRpbWVzdGFtcHMgY2Fubm90IGJlIGZvcm1hdHRlZCAtPiByZXR1cm4gbnVsbFxuXHRcdFx0KCFvVGltZXN0YW1wICYmICF0aGlzLmJTaG93VGltZXpvbmVGb3JFbXB0eVZhbHVlcylcblx0XHQpIHtcblx0XHRcdHJldHVybiBudWxsO1xuXHRcdH1cblx0XHRyZXR1cm4gc3VwZXIuZm9ybWF0VmFsdWUoYVZhbHVlcywgc1RhcmdldFR5cGUpO1xuXHR9XG59XG5leHBvcnQgZGVmYXVsdCBEYXRlVGltZVdpdGhUaW1lem9uZTtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQUE7QUFBQTs7Ozs7Ozs7TUFJTUEsb0JBQW9CLFdBRHpCQyxjQUFjLENBQUMsdUNBQXVDLENBQUM7SUFBQTtJQUl2RCw4QkFBWUMsY0FBa0UsRUFBRUMsWUFBcUIsRUFBRTtNQUFBO01BQ3RHLDBDQUFNRCxjQUFjLEVBQUVDLFlBQVksQ0FBQztNQUNuQyxNQUFLQywyQkFBMkIsR0FBRyxDQUFBRixjQUFjLGFBQWRBLGNBQWMsdUJBQWRBLGNBQWMsQ0FBRUcsMEJBQTBCLEtBQUksSUFBSTtNQUFDO0lBQ3ZGO0lBQUM7SUFBQSxPQUVEQyxXQUFXLEdBQVgscUJBQVlDLE9BQWtCLEVBQUVDLFdBQW1CLEVBQWtCO01BQ3BFLE1BQU1DLFVBQVUsR0FBR0YsT0FBTyxJQUFJQSxPQUFPLENBQUMsQ0FBQyxDQUFDO01BQ3hDLElBQ0NFLFVBQVUsS0FBS0MsU0FBUztNQUFJO01BQzVCO01BQ0MsQ0FBQ0QsVUFBVSxJQUFJLENBQUMsSUFBSSxDQUFDTCwyQkFBNEIsRUFDakQ7UUFDRCxPQUFPLElBQUk7TUFDWjtNQUNBLHdDQUFhRSxXQUFXLFlBQUNDLE9BQU8sRUFBRUMsV0FBVztJQUM5QyxDQUFDO0lBQUE7RUFBQSxFQWxCaUNHLHFCQUFxQjtFQUFBLE9Bb0J6Q1gsb0JBQW9CO0FBQUEifQ==

package/src/sap/fe/core/type/DateTimeWithTimezone.ts

@@ -1,4 +1,4 @@
-import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
+import { defineUI5Class } from "sap/fe/base/ClassSupport";
 import _DateTimeWithTimezone from "sap/ui/model/odata/type/DateTimeWithTimezone";
 
 @defineUI5Class("sap.fe.core.type.DateTimeWithTimezone")

package/src/sap/fe/core/type/Email.js

@@ -2,7 +2,7 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2024 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/core/Lib", "sap/ui/model/odata/type/String", "sap/ui/model/ValidateException"], function (ClassSupport, Library, ODataStringType, ValidateException) {
+sap.ui.define(["sap/fe/base/ClassSupport", "sap/ui/core/Lib", "sap/ui/model/odata/type/String", "sap/ui/model/ValidateException"], function (ClassSupport, Library, ODataStringType, ValidateException) {
   "use strict";
 
   var _dec, _class;
@@ -26,4 +26,4 @@ sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/core/Lib", "sap/ui/mo
   }(ODataStringType)) || _class);
   return EmailType;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJlbWFpbFczQ1JlZ2V4cCIsIkVtYWlsVHlwZSIsImRlZmluZVVJNUNsYXNzIiwidmFsaWRhdGVWYWx1ZSIsInNWYWx1ZSIsInRlc3QiLCJWYWxpZGF0ZUV4Y2VwdGlvbiIsIkxpYnJhcnkiLCJnZXRSZXNvdXJjZUJ1bmRsZUZvciIsImdldFRleHQiLCJPRGF0YVN0cmluZ1R5cGUiXSwic291cmNlUm9vdCI6Ii4iLCJzb3VyY2VzIjpbIkVtYWlsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmluZVVJNUNsYXNzIH0gZnJvbSBcInNhcC9mZS9jb3JlL2hlbHBlcnMvQ2xhc3NTdXBwb3J0XCI7XG5pbXBvcnQgTGlicmFyeSBmcm9tIFwic2FwL3VpL2NvcmUvTGliXCI7XG5pbXBvcnQgT0RhdGFTdHJpbmdUeXBlIGZyb20gXCJzYXAvdWkvbW9kZWwvb2RhdGEvdHlwZS9TdHJpbmdcIjtcbmltcG9ydCBWYWxpZGF0ZUV4Y2VwdGlvbiBmcm9tIFwic2FwL3VpL21vZGVsL1ZhbGlkYXRlRXhjZXB0aW9uXCI7XG5cbmNvbnN0IGVtYWlsVzNDUmVnZXhwID0gL15bYS16QS1aMC05LiEjJCUm4oCZKisvPT9eX2B7fH1+LV0rQFthLXpBLVowLTktXSsoPzouW2EtekEtWjAtOS1dKykqJC87XG5AZGVmaW5lVUk1Q2xhc3MoXCJzYXAuZmUuY29yZS50eXBlLkVtYWlsXCIpXG5jbGFzcyBFbWFpbFR5cGUgZXh0ZW5kcyBPRGF0YVN0cmluZ1R5cGUge1xuXHR2YWxpZGF0ZVZhbHVlKHNWYWx1ZTogc3RyaW5nKTogdm9pZCB7XG5cdFx0aWYgKHNWYWx1ZSAmJiAhZW1haWxXM0NSZWdleHAudGVzdChzVmFsdWUpKSB7XG5cdFx0XHR0aHJvdyBuZXcgVmFsaWRhdGVFeGNlcHRpb24oTGlicmFyeS5nZXRSZXNvdXJjZUJ1bmRsZUZvcihcInNhcC5mZS5jb3JlXCIpIS5nZXRUZXh0KFwiVF9FTUFJTFRZUEVfSU5WQUxJRF9WQUxVRVwiKSk7XG5cdFx0fVxuXHRcdHN1cGVyLnZhbGlkYXRlVmFsdWUoc1ZhbHVlKTtcblx0fVxufVxuZXhwb3J0IGRlZmF1bHQgRW1haWxUeXBlO1xuIl0sIm1hcHBpbmdzIjoiO0FBQUE7QUFBQTtBQUFBOzs7Ozs7OztFQUtBLE1BQU1BLGNBQWMsR0FBRyxxRUFBcUU7RUFBQyxJQUV2RkMsU0FBUyxXQURkQyxjQUFjLENBQUMsd0JBQXdCLENBQUM7SUFBQTtJQUFBO01BQUE7SUFBQTtJQUFBO0lBQUEsT0FFeENDLGFBQWEsR0FBYix1QkFBY0MsTUFBYyxFQUFRO01BQ25DLElBQUlBLE1BQU0sSUFBSSxDQUFDSixjQUFjLENBQUNLLElBQUksQ0FBQ0QsTUFBTSxDQUFDLEVBQUU7UUFDM0MsTUFBTSxJQUFJRSxpQkFBaUIsQ0FBQ0MsT0FBTyxDQUFDQyxvQkFBb0IsQ0FBQyxhQUFhLENBQUMsQ0FBRUMsT0FBTyxDQUFDLDJCQUEyQixDQUFDLENBQUM7TUFDL0c7TUFDQSwyQkFBTU4sYUFBYSxZQUFDQyxNQUFNO0lBQzNCLENBQUM7SUFBQTtFQUFBLEVBTnNCTSxlQUFlO0VBQUEsT0FReEJULFNBQVM7QUFBQSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJlbWFpbFczQ1JlZ2V4cCIsIkVtYWlsVHlwZSIsImRlZmluZVVJNUNsYXNzIiwidmFsaWRhdGVWYWx1ZSIsInNWYWx1ZSIsInRlc3QiLCJWYWxpZGF0ZUV4Y2VwdGlvbiIsIkxpYnJhcnkiLCJnZXRSZXNvdXJjZUJ1bmRsZUZvciIsImdldFRleHQiLCJPRGF0YVN0cmluZ1R5cGUiXSwic291cmNlUm9vdCI6Ii4iLCJzb3VyY2VzIjpbIkVtYWlsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmluZVVJNUNsYXNzIH0gZnJvbSBcInNhcC9mZS9iYXNlL0NsYXNzU3VwcG9ydFwiO1xuaW1wb3J0IExpYnJhcnkgZnJvbSBcInNhcC91aS9jb3JlL0xpYlwiO1xuaW1wb3J0IE9EYXRhU3RyaW5nVHlwZSBmcm9tIFwic2FwL3VpL21vZGVsL29kYXRhL3R5cGUvU3RyaW5nXCI7XG5pbXBvcnQgVmFsaWRhdGVFeGNlcHRpb24gZnJvbSBcInNhcC91aS9tb2RlbC9WYWxpZGF0ZUV4Y2VwdGlvblwiO1xuXG5jb25zdCBlbWFpbFczQ1JlZ2V4cCA9IC9eW2EtekEtWjAtOS4hIyQlJuKAmSorLz0/Xl9ge3x9fi1dK0BbYS16QS1aMC05LV0rKD86LlthLXpBLVowLTktXSspKiQvO1xuQGRlZmluZVVJNUNsYXNzKFwic2FwLmZlLmNvcmUudHlwZS5FbWFpbFwiKVxuY2xhc3MgRW1haWxUeXBlIGV4dGVuZHMgT0RhdGFTdHJpbmdUeXBlIHtcblx0dmFsaWRhdGVWYWx1ZShzVmFsdWU6IHN0cmluZyk6IHZvaWQge1xuXHRcdGlmIChzVmFsdWUgJiYgIWVtYWlsVzNDUmVnZXhwLnRlc3Qoc1ZhbHVlKSkge1xuXHRcdFx0dGhyb3cgbmV3IFZhbGlkYXRlRXhjZXB0aW9uKExpYnJhcnkuZ2V0UmVzb3VyY2VCdW5kbGVGb3IoXCJzYXAuZmUuY29yZVwiKSEuZ2V0VGV4dChcIlRfRU1BSUxUWVBFX0lOVkFMSURfVkFMVUVcIikpO1xuXHRcdH1cblx0XHRzdXBlci52YWxpZGF0ZVZhbHVlKHNWYWx1ZSk7XG5cdH1cbn1cbmV4cG9ydCBkZWZhdWx0IEVtYWlsVHlwZTtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQUE7QUFBQTs7Ozs7Ozs7RUFLQSxNQUFNQSxjQUFjLEdBQUcscUVBQXFFO0VBQUMsSUFFdkZDLFNBQVMsV0FEZEMsY0FBYyxDQUFDLHdCQUF3QixDQUFDO0lBQUE7SUFBQTtNQUFBO0lBQUE7SUFBQTtJQUFBLE9BRXhDQyxhQUFhLEdBQWIsdUJBQWNDLE1BQWMsRUFBUTtNQUNuQyxJQUFJQSxNQUFNLElBQUksQ0FBQ0osY0FBYyxDQUFDSyxJQUFJLENBQUNELE1BQU0sQ0FBQyxFQUFFO1FBQzNDLE1BQU0sSUFBSUUsaUJBQWlCLENBQUNDLE9BQU8sQ0FBQ0Msb0JBQW9CLENBQUMsYUFBYSxDQUFDLENBQUVDLE9BQU8sQ0FBQywyQkFBMkIsQ0FBQyxDQUFDO01BQy9HO01BQ0EsMkJBQU1OLGFBQWEsWUFBQ0MsTUFBTTtJQUMzQixDQUFDO0lBQUE7RUFBQSxFQU5zQk0sZUFBZTtFQUFBLE9BUXhCVCxTQUFTO0FBQUEifQ==

package/src/sap/fe/core/type/Email.ts

@@ -1,4 +1,4 @@
-import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
+import { defineUI5Class } from "sap/fe/base/ClassSupport";
 import Library from "sap/ui/core/Lib";
 import ODataStringType from "sap/ui/model/odata/type/String";
 import ValidateException from "sap/ui/model/ValidateException";

package/src/sap/fe/core/type/FiscalDate.js

@@ -2,7 +2,7 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2024 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/base/i18n/date/CalendarType", "sap/fe/core/formatters/FiscalFormat", "sap/fe/core/helpers/ClassSupport", "sap/ui/core/Lib", "sap/ui/model/ValidateException", "sap/ui/model/odata/type/String"], function (CalendarType, FiscalFormat, ClassSupport, Library, ValidateException, ODataStringType) {
+sap.ui.define(["sap/base/i18n/date/CalendarType", "sap/fe/base/ClassSupport", "sap/fe/core/formatters/FiscalFormat", "sap/ui/core/Lib", "sap/ui/model/ValidateException", "sap/ui/model/odata/type/String"], function (CalendarType, ClassSupport, FiscalFormat, Library, ValidateException, ODataStringType) {
   "use strict";
 
   var _dec, _class, _class2;
@@ -174,4 +174,4 @@ sap.ui.define(["sap/base/i18n/date/CalendarType", "sap/fe/core/formatters/Fiscal
   }, _class2)) || _class);
   return FiscalDate;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["FiscalDate","defineUI5Class","formatOptions","constraints","fiscalType","maxLength","annotationType","format","dateFormats","formatter","FiscalFormat","getDateInstance","calendarType","CalendarType","Gregorian","getPattern","formatValue","value","targetType","parseValue","sourceType","parse","validateValue","error","validate","ValidateException","getErrorMessage","sValue","fullYear","Date","getFullYear","toString","Library","getResourceBundleFor","getText","getName","getFormatter","ODataStringType"],"sourceRoot":".","sources":["FiscalDate.ts"],"sourcesContent":["import { CommonAnnotationTerms } from \"@sap-ux/vocabularies-types/vocabularies/Common\";\nimport CalendarType from \"sap/base/i18n/date/CalendarType\";\nimport FiscalFormat from \"sap/fe/core/formatters/FiscalFormat\";\nimport { defineUI5Class } from \"sap/fe/core/helpers/ClassSupport\";\nimport Library from \"sap/ui/core/Lib\";\nimport ValidateException from \"sap/ui/model/ValidateException\";\nimport ODataStringType from \"sap/ui/model/odata/type/String\";\n\n/**\n * Define the UI5 class for a type of fiscal date.\n *\n * The data type Fiscal Date supports the parsing and formatting of fiscal dates that follow the pattern 'yM'.\n *\n * @since 1.110.0\n * @experimental\n */\n@defineUI5Class(\"sap.fe.core.type.FiscalDate\")\nclass FiscalDate extends ODataStringType {\n\tprivate annotationType: string | undefined;\n\n\tprivate fullYear: string | undefined;\n\n\tprivate static dateFormats = {\n\t\t[CommonAnnotationTerms.IsFiscalYear]: \"YYYY\",\n\t\t[CommonAnnotationTerms.IsFiscalPeriod]: \"PPP\",\n\t\t[CommonAnnotationTerms.IsFiscalYearPeriod]: \"YYYYPPP\",\n\t\t[CommonAnnotationTerms.IsFiscalQuarter]: \"Q\",\n\t\t[CommonAnnotationTerms.IsFiscalYearQuarter]: \"YYYYQ\",\n\t\t[CommonAnnotationTerms.IsFiscalWeek]: \"WW\",\n\t\t[CommonAnnotationTerms.IsFiscalYearWeek]: \"YYYYWW\",\n\t\t[CommonAnnotationTerms.IsDayOfFiscalYear]: \"d\",\n\t\t[CommonAnnotationTerms.IsFiscalYearVariant]: \"\"\n\t};\n\n\tprivate formatter: FiscalFormat | undefined;\n\n\t/**\n\t * @param formatOptions Format options\n\t * @param formatOptions.fiscalType String with a fiscal annotation type\n\t * @param formatOptions.parseKeepsEmptyString Whether empty string should be kept or not\n\t * @param constraints Constraints\n\t * @param constraints.maxLength Maximum length of the field\n\t */\n\tconstructor(formatOptions: { fiscalType: string; parseKeepsEmptyString?: boolean }, constraints?: { maxLength?: number }) {\n\t\tif (\n\t\t\t(formatOptions.fiscalType === CommonAnnotationTerms.IsFiscalYearPeriod ||\n\t\t\t\tformatOptions.fiscalType === CommonAnnotationTerms.IsFiscalYearQuarter ||\n\t\t\t\tformatOptions.fiscalType === CommonAnnotationTerms.IsFiscalYearWeek) &&\n\t\t\tconstraints?.maxLength\n\t\t) {\n\t\t\t// We increase maxLength for +1 for any fiscal type that have delimiter in locale format.\n\t\t\t// It's necessary for validation to work correctly.\n\t\t\t// Also for validation to function properly user also should specify constraints.isDigitSequence = true\n\t\t\t// isDigitSequence and maxLength combination ensures that missing characters will be populated with leading zeros\n\t\t\t// that will ensure user will receive correct validation results.\n\t\t\tconstraints.maxLength = constraints.maxLength + 1;\n\t\t}\n\t\tsuper(formatOptions, constraints);\n\t\tthis.annotationType = formatOptions.fiscalType;\n\t\tconst format = FiscalDate.dateFormats[this.annotationType as keyof typeof FiscalDate.dateFormats];\n\t\tif (format) {\n\t\t\tthis.formatter = FiscalFormat.getDateInstance({\n\t\t\t\tformat,\n\t\t\t\tcalendarType: CalendarType.Gregorian\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Return pattern for fiscal date type.\n\t *\n\t * @returns The fiscal date pattern\n\t */\n\tpublic getPattern(): string | undefined {\n\t\treturn this.formatter?.getPattern();\n\t}\n\n\t/**\n\t * Formats the given value to the given fiscal type.\n\t *\n\t * @param value The value to be formatted\n\t * @returns The formatted output value; <code>undefined</code> is always formatted to <code>null</code>\n\t * @override\n\t */\n\tpublic formatValue(value: string, targetType: string): string | number | boolean {\n\t\treturn this.formatter ? this.formatter.format(super.formatValue(value, targetType)) : super.formatValue(value, targetType);\n\t}\n\n\t/**\n\t * Parses the given value, which is expected to be of the fiscal type, to a string.\n\t *\n\t * @param value The value to be parsed\n\t * @returns The parsed value\n\t * @override\n\t */\n\tpublic parseValue(value: string | number | boolean, sourceType: string): string {\n\t\treturn this.formatter ? this.formatter.parse(super.parseValue(value, sourceType)) : super.parseValue(value, sourceType);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic validateValue(value: string): void {\n\t\ttry {\n\t\t\tsuper.validateValue(value);\n\t\t} catch (error) {\n\t\t\tif (!this.formatter) {\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t\tif (!this.formatter.validate(value)) {\n\t\t\t\tthrow new ValidateException(this.getErrorMessage(this.annotationType));\n\t\t\t}\n\t\t}\n\n\t\tif (!this.formatter || value === \"\" || value === null) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.formatter.validate(value)) {\n\t\t\tthrow new ValidateException(this.getErrorMessage(this.annotationType));\n\t\t}\n\t}\n\n\t/**\n\t * Returns the matching locale-dependent error message for the type based on the fiscal annotation.\n\t *\n\t * @param annotationType The fiscal annotation type\n\t * @returns The locale-dependent error message\n\t */\n\tpublic getErrorMessage(annotationType: string | undefined): string {\n\t\tlet sValue = \"\";\n\t\tthis.fullYear = this.fullYear || new Date().getFullYear().toString();\n\n\t\tswitch (annotationType) {\n\t\t\tcase CommonAnnotationTerms.IsFiscalYear:\n\t\t\t\tsValue = this.fullYear;\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalPeriod:\n\t\t\t\tsValue = \"001\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearPeriod:\n\t\t\t\tsValue = this.fullYear + \"001\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalQuarter:\n\t\t\t\tsValue = \"1\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearQuarter:\n\t\t\t\tsValue = this.fullYear + \"1\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalWeek:\n\t\t\t\tsValue = \"01\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearWeek:\n\t\t\t\tsValue = this.fullYear + \"01\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsDayOfFiscalYear:\n\t\t\t\tsValue = \"1\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearVariant:\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tsValue = this.fullYear;\n\t\t}\n\n\t\treturn Library.getResourceBundleFor(\"sap.fe.core\")!.getText(\"FISCAL_VALIDATION_FAILS\", [this.formatValue(sValue, \"string\")]);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getName(): string {\n\t\treturn \"sap.fe.core.type.FiscalDate\";\n\t}\n\n\t/**\n\t * Returns the formatter that is assigned to this particular FiscalDate type.\n\t *\n\t * @returns The assigned instance of FiscalFormat\n\t */\n\tpublic getFormatter(): FiscalFormat | undefined {\n\t\treturn this.formatter;\n\t}\n}\nexport default FiscalDate;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["FiscalDate","defineUI5Class","formatOptions","constraints","fiscalType","maxLength","annotationType","format","dateFormats","formatter","FiscalFormat","getDateInstance","calendarType","CalendarType","Gregorian","getPattern","formatValue","value","targetType","parseValue","sourceType","parse","validateValue","error","validate","ValidateException","getErrorMessage","sValue","fullYear","Date","getFullYear","toString","Library","getResourceBundleFor","getText","getName","getFormatter","ODataStringType"],"sourceRoot":".","sources":["FiscalDate.ts"],"sourcesContent":["import { CommonAnnotationTerms } from \"@sap-ux/vocabularies-types/vocabularies/Common\";\nimport CalendarType from \"sap/base/i18n/date/CalendarType\";\nimport { defineUI5Class } from \"sap/fe/base/ClassSupport\";\nimport FiscalFormat from \"sap/fe/core/formatters/FiscalFormat\";\nimport Library from \"sap/ui/core/Lib\";\nimport ValidateException from \"sap/ui/model/ValidateException\";\nimport ODataStringType from \"sap/ui/model/odata/type/String\";\n\n/**\n * Define the UI5 class for a type of fiscal date.\n *\n * The data type Fiscal Date supports the parsing and formatting of fiscal dates that follow the pattern 'yM'.\n *\n * @since 1.110.0\n * @experimental\n */\n@defineUI5Class(\"sap.fe.core.type.FiscalDate\")\nclass FiscalDate extends ODataStringType {\n\tprivate annotationType: string | undefined;\n\n\tprivate fullYear: string | undefined;\n\n\tprivate static dateFormats = {\n\t\t[CommonAnnotationTerms.IsFiscalYear]: \"YYYY\",\n\t\t[CommonAnnotationTerms.IsFiscalPeriod]: \"PPP\",\n\t\t[CommonAnnotationTerms.IsFiscalYearPeriod]: \"YYYYPPP\",\n\t\t[CommonAnnotationTerms.IsFiscalQuarter]: \"Q\",\n\t\t[CommonAnnotationTerms.IsFiscalYearQuarter]: \"YYYYQ\",\n\t\t[CommonAnnotationTerms.IsFiscalWeek]: \"WW\",\n\t\t[CommonAnnotationTerms.IsFiscalYearWeek]: \"YYYYWW\",\n\t\t[CommonAnnotationTerms.IsDayOfFiscalYear]: \"d\",\n\t\t[CommonAnnotationTerms.IsFiscalYearVariant]: \"\"\n\t};\n\n\tprivate formatter: FiscalFormat | undefined;\n\n\t/**\n\t * @param formatOptions Format options\n\t * @param formatOptions.fiscalType String with a fiscal annotation type\n\t * @param formatOptions.parseKeepsEmptyString Whether empty string should be kept or not\n\t * @param constraints Constraints\n\t * @param constraints.maxLength Maximum length of the field\n\t */\n\tconstructor(formatOptions: { fiscalType: string; parseKeepsEmptyString?: boolean }, constraints?: { maxLength?: number }) {\n\t\tif (\n\t\t\t(formatOptions.fiscalType === CommonAnnotationTerms.IsFiscalYearPeriod ||\n\t\t\t\tformatOptions.fiscalType === CommonAnnotationTerms.IsFiscalYearQuarter ||\n\t\t\t\tformatOptions.fiscalType === CommonAnnotationTerms.IsFiscalYearWeek) &&\n\t\t\tconstraints?.maxLength\n\t\t) {\n\t\t\t// We increase maxLength for +1 for any fiscal type that have delimiter in locale format.\n\t\t\t// It's necessary for validation to work correctly.\n\t\t\t// Also for validation to function properly user also should specify constraints.isDigitSequence = true\n\t\t\t// isDigitSequence and maxLength combination ensures that missing characters will be populated with leading zeros\n\t\t\t// that will ensure user will receive correct validation results.\n\t\t\tconstraints.maxLength = constraints.maxLength + 1;\n\t\t}\n\t\tsuper(formatOptions, constraints);\n\t\tthis.annotationType = formatOptions.fiscalType;\n\t\tconst format = FiscalDate.dateFormats[this.annotationType as keyof typeof FiscalDate.dateFormats];\n\t\tif (format) {\n\t\t\tthis.formatter = FiscalFormat.getDateInstance({\n\t\t\t\tformat,\n\t\t\t\tcalendarType: CalendarType.Gregorian\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Return pattern for fiscal date type.\n\t *\n\t * @returns The fiscal date pattern\n\t */\n\tpublic getPattern(): string | undefined {\n\t\treturn this.formatter?.getPattern();\n\t}\n\n\t/**\n\t * Formats the given value to the given fiscal type.\n\t *\n\t * @param value The value to be formatted\n\t * @returns The formatted output value; <code>undefined</code> is always formatted to <code>null</code>\n\t * @override\n\t */\n\tpublic formatValue(value: string, targetType: string): string | number | boolean {\n\t\treturn this.formatter ? this.formatter.format(super.formatValue(value, targetType)) : super.formatValue(value, targetType);\n\t}\n\n\t/**\n\t * Parses the given value, which is expected to be of the fiscal type, to a string.\n\t *\n\t * @param value The value to be parsed\n\t * @returns The parsed value\n\t * @override\n\t */\n\tpublic parseValue(value: string | number | boolean, sourceType: string): string {\n\t\treturn this.formatter ? this.formatter.parse(super.parseValue(value, sourceType)) : super.parseValue(value, sourceType);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic validateValue(value: string): void {\n\t\ttry {\n\t\t\tsuper.validateValue(value);\n\t\t} catch (error) {\n\t\t\tif (!this.formatter) {\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t\tif (!this.formatter.validate(value)) {\n\t\t\t\tthrow new ValidateException(this.getErrorMessage(this.annotationType));\n\t\t\t}\n\t\t}\n\n\t\tif (!this.formatter || value === \"\" || value === null) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.formatter.validate(value)) {\n\t\t\tthrow new ValidateException(this.getErrorMessage(this.annotationType));\n\t\t}\n\t}\n\n\t/**\n\t * Returns the matching locale-dependent error message for the type based on the fiscal annotation.\n\t *\n\t * @param annotationType The fiscal annotation type\n\t * @returns The locale-dependent error message\n\t */\n\tpublic getErrorMessage(annotationType: string | undefined): string {\n\t\tlet sValue = \"\";\n\t\tthis.fullYear = this.fullYear || new Date().getFullYear().toString();\n\n\t\tswitch (annotationType) {\n\t\t\tcase CommonAnnotationTerms.IsFiscalYear:\n\t\t\t\tsValue = this.fullYear;\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalPeriod:\n\t\t\t\tsValue = \"001\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearPeriod:\n\t\t\t\tsValue = this.fullYear + \"001\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalQuarter:\n\t\t\t\tsValue = \"1\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearQuarter:\n\t\t\t\tsValue = this.fullYear + \"1\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalWeek:\n\t\t\t\tsValue = \"01\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearWeek:\n\t\t\t\tsValue = this.fullYear + \"01\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsDayOfFiscalYear:\n\t\t\t\tsValue = \"1\";\n\t\t\t\tbreak;\n\t\t\tcase CommonAnnotationTerms.IsFiscalYearVariant:\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tsValue = this.fullYear;\n\t\t}\n\n\t\treturn Library.getResourceBundleFor(\"sap.fe.core\")!.getText(\"FISCAL_VALIDATION_FAILS\", [this.formatValue(sValue, \"string\")]);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getName(): string {\n\t\treturn \"sap.fe.core.type.FiscalDate\";\n\t}\n\n\t/**\n\t * Returns the formatter that is assigned to this particular FiscalDate type.\n\t *\n\t * @returns The assigned instance of FiscalFormat\n\t */\n\tpublic getFormatter(): FiscalFormat | undefined {\n\t\treturn this.formatter;\n\t}\n}\nexport default FiscalDate;\n"],"mappings":"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"}

package/src/sap/fe/core/type/FiscalDate.ts

@@ -1,7 +1,7 @@
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import CalendarType from "sap/base/i18n/date/CalendarType";
+import { defineUI5Class } from "sap/fe/base/ClassSupport";
 import FiscalFormat from "sap/fe/core/formatters/FiscalFormat";
-import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
 import Library from "sap/ui/core/Lib";
 import ValidateException from "sap/ui/model/ValidateException";
 import ODataStringType from "sap/ui/model/odata/type/String";

package/src/sap/fe/core/type/InputMask.js

@@ -0,0 +1,124 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2024 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/base/ClassSupport", "sap/ui/core/Lib", "sap/ui/model/ValidateException", "sap/ui/model/odata/type/String"], function (ClassSupport, Library, ValidateException, ODataStringType) {
+  "use strict";
+
+  var _dec, _class;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+  let InputMaskType = (_dec = defineUI5Class("sap.fe.core.type.InputMask"), _dec(_class = /*#__PURE__*/function (_ODataStringType) {
+    _inheritsLoose(InputMaskType, _ODataStringType);
+    function InputMaskType(oFormatOptions) {
+      return _ODataStringType.call(this, oFormatOptions) || this;
+    }
+    var _proto = InputMaskType.prototype;
+    /**
+     * Validates the value against the mask. If the value is not provided for any of the mask characters, it throws an error.
+     *
+     * @param value String value received from the parseValue method without the mask.
+     */
+    _proto.validateValue = function validateValue(value) {
+      // Reuse the formatValue to validate if the value does not match the mask and throw an error in that case
+      const maskedValue = this.formatValue(value);
+      if (maskedValue.includes(this.oFormatOptions.placeholderSymbol)) {
+        let text = Library.getResourceBundleFor("sap.fe.core").getText("T_MASKEDINPUT_INVALID_VALUE");
+        if (!text) {
+          text = "";
+        }
+        throw new ValidateException(text);
+      }
+      _ODataStringType.prototype.validateValue.call(this, value);
+    }
+    /**
+     * Parse the value by removing the mask characters.
+     *
+     * @param value String value from the control with the mask
+     * @returns String value without the mask
+     */;
+    _proto.parseValue = function parseValue(value) {
+      var _this$oFormatOptions;
+      // Remove the mask characters from the value
+      let parsedValue = "";
+      let parsedValueIndex = 0;
+      const mask = (_this$oFormatOptions = this.oFormatOptions) === null || _this$oFormatOptions === void 0 ? void 0 : _this$oFormatOptions.mask;
+      if (mask) {
+        for (let i = 0; i <= mask.length; i++) {
+          if (this.doesMakingRuleExists(this.oFormatOptions.maskRule, mask[i])) {
+            const maskRule = this.oFormatOptions.maskRule.find(rule => rule.symbol === mask[i]);
+            if (value[parsedValueIndex] && maskRule && value[parsedValueIndex].match(new RegExp(maskRule.regex))) {
+              parsedValue += value[parsedValueIndex++];
+            }
+          } else if (mask[i] === "^") {
+            // check if the character is ^, then skip the next character in value and increment the loop i++ as we don't want to add the escaped character to the parsed value
+            i++;
+            parsedValueIndex++;
+          } else {
+            parsedValueIndex++;
+          }
+        }
+      }
+      return parsedValue;
+    }
+    /**
+     * Checks if the mask rule exists for the given mask character.
+     *
+     * @param maskRule Array of mask rules
+     * @param maskCharacter Single mask character
+     * @returns True or False based on the result
+     */;
+    _proto.doesMakingRuleExists = function doesMakingRuleExists(maskRule, maskCharacter) {
+      for (const rule of maskRule) {
+        if (rule.symbol === maskCharacter) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+     * Format the value by applying the mask.
+     *
+     * @param value String value from the model without the mask
+     * @returns String value with the mask
+     */;
+    _proto.formatValue = function formatValue(value) {
+      if (!value) return value;
+      const maskRulesPerCharacter = {};
+      let formatValue = "";
+      // Create a map of mask rules per character
+      if (this.oFormatOptions.maskRule) {
+        for (const rule of this.oFormatOptions.maskRule) {
+          maskRulesPerCharacter[rule.symbol] = rule.regex;
+        }
+        let valueIndex = 0;
+        let formattedValue = "";
+        const mask = this.oFormatOptions.mask;
+        for (let i = 0; i < mask.length; i++) {
+          // Process character by character, comparing with the mask rules
+          // If the character matches a mask rule, replace it with the character from the value and increment the value index;
+          // Otherwise replace it with the character from the mask
+          if (maskRulesPerCharacter[mask[i]]) {
+            if (value[valueIndex] && value[valueIndex].match(new RegExp(maskRulesPerCharacter[mask[i]]))) {
+              formattedValue += value[valueIndex++];
+            } else {
+              formattedValue += this.oFormatOptions.placeholderSymbol;
+            }
+          } else if (mask[i] === "^") {
+            // if the mask character is ^ then add the character after it to the formatted value and increment the value i++
+            formattedValue += mask[i + 1];
+            i++;
+          } else {
+            formattedValue += mask[i];
+          }
+        }
+        formatValue = formattedValue;
+      }
+      return formatValue;
+    };
+    return InputMaskType;
+  }(ODataStringType)) || _class);
+  return InputMaskType;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["InputMaskType","defineUI5Class","oFormatOptions","validateValue","value","maskedValue","formatValue","includes","placeholderSymbol","text","Library","getResourceBundleFor","getText","ValidateException","parseValue","parsedValue","parsedValueIndex","mask","i","length","doesMakingRuleExists","maskRule","find","rule","symbol","match","RegExp","regex","maskCharacter","maskRulesPerCharacter","valueIndex","formattedValue","ODataStringType"],"sourceRoot":".","sources":["InputMask.ts"],"sourcesContent":["import { defineUI5Class } from \"sap/fe/base/ClassSupport\";\nimport Library from \"sap/ui/core/Lib\";\nimport ValidateException from \"sap/ui/model/ValidateException\";\nimport ODataStringType from \"sap/ui/model/odata/type/String\";\n\nexport type InputMaskRule = {\n\tsymbol: string;\n\tregex: string;\n};\nexport type InputMaskFormatOptions = {\n\tmask: string;\n\tplaceholderSymbol: string;\n\tmaskRule: InputMaskRule[];\n};\n\n@defineUI5Class(\"sap.fe.core.type.InputMask\")\nclass InputMaskType extends ODataStringType {\n\tconstructor(oFormatOptions: InputMaskFormatOptions & { parseKeepsEmptyString?: boolean }) {\n\t\tsuper(oFormatOptions);\n\t}\n\n\toFormatOptions!: InputMaskFormatOptions;\n\n\t/**\n\t * Validates the value against the mask. If the value is not provided for any of the mask characters, it throws an error.\n\t *\n\t * @param value String value received from the parseValue method without the mask.\n\t */\n\n\tvalidateValue(value: string): void {\n\t\t// Reuse the formatValue to validate if the value does not match the mask and throw an error in that case\n\t\tconst maskedValue = this.formatValue(value);\n\t\tif (maskedValue.includes(this.oFormatOptions.placeholderSymbol)) {\n\t\t\tlet text = Library.getResourceBundleFor(\"sap.fe.core\")!.getText(\"T_MASKEDINPUT_INVALID_VALUE\");\n\t\t\tif (!text) {\n\t\t\t\ttext = \"\";\n\t\t\t}\n\t\t\tthrow new ValidateException(text);\n\t\t}\n\t\tsuper.validateValue(value);\n\t}\n\t/**\n\t * Parse the value by removing the mask characters.\n\t *\n\t * @param value String value from the control with the mask\n\t * @returns String value without the mask\n\t */\n\n\tparseValue(value: string): string {\n\t\t// Remove the mask characters from the value\n\t\tlet parsedValue = \"\";\n\t\tlet parsedValueIndex = 0;\n\t\tconst mask = this.oFormatOptions?.mask;\n\t\tif (mask) {\n\t\t\tfor (let i = 0; i <= mask.length; i++) {\n\t\t\t\tif (this.doesMakingRuleExists(this.oFormatOptions.maskRule, mask[i])) {\n\t\t\t\t\tconst maskRule = this.oFormatOptions.maskRule.find((rule) => rule.symbol === mask[i]);\n\t\t\t\t\tif (value[parsedValueIndex] && maskRule && value[parsedValueIndex].match(new RegExp(maskRule.regex))) {\n\t\t\t\t\t\tparsedValue += value[parsedValueIndex++];\n\t\t\t\t\t}\n\t\t\t\t} else if (mask[i] === \"^\") {\n\t\t\t\t\t// check if the character is ^, then skip the next character in value and increment the loop i++ as we don't want to add the escaped character to the parsed value\n\t\t\t\t\ti++;\n\t\t\t\t\tparsedValueIndex++;\n\t\t\t\t} else {\n\t\t\t\t\tparsedValueIndex++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn parsedValue;\n\t}\n\t/**\n\t * Checks if the mask rule exists for the given mask character.\n\t *\n\t * @param maskRule Array of mask rules\n\t * @param maskCharacter Single mask character\n\t * @returns True or False based on the result\n\t */\n\n\tdoesMakingRuleExists(maskRule: InputMaskRule[], maskCharacter: string): boolean {\n\t\tfor (const rule of maskRule) {\n\t\t\tif (rule.symbol === maskCharacter) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\t/**\n\t * Format the value by applying the mask.\n\t *\n\t * @param value String value from the model without the mask\n\t * @returns String value with the mask\n\t */\n\n\tformatValue(value: string): string {\n\t\tif (!value) return value;\n\n\t\tconst maskRulesPerCharacter: Record<string, string> = {};\n\t\tlet formatValue = \"\";\n\t\t// Create a map of mask rules per character\n\t\tif (this.oFormatOptions.maskRule) {\n\t\t\tfor (const rule of this.oFormatOptions.maskRule) {\n\t\t\t\tmaskRulesPerCharacter[rule.symbol] = rule.regex;\n\t\t\t}\n\t\t\tlet valueIndex = 0;\n\t\t\tlet formattedValue = \"\";\n\t\t\tconst mask = this.oFormatOptions.mask;\n\t\t\tfor (let i = 0; i < mask.length; i++) {\n\t\t\t\t// Process character by character, comparing with the mask rules\n\t\t\t\t// If the character matches a mask rule, replace it with the character from the value and increment the value index;\n\t\t\t\t// Otherwise replace it with the character from the mask\n\t\t\t\tif (maskRulesPerCharacter[mask[i]]) {\n\t\t\t\t\tif (value[valueIndex] && value[valueIndex].match(new RegExp(maskRulesPerCharacter[mask[i]]))) {\n\t\t\t\t\t\tformattedValue += value[valueIndex++];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tformattedValue += this.oFormatOptions.placeholderSymbol;\n\t\t\t\t\t}\n\t\t\t\t} else if (mask[i] === \"^\") {\n\t\t\t\t\t// if the mask character is ^ then add the character after it to the formatted value and increment the value i++\n\t\t\t\t\tformattedValue += mask[i + 1];\n\t\t\t\t\ti++;\n\t\t\t\t} else {\n\t\t\t\t\tformattedValue += mask[i];\n\t\t\t\t}\n\t\t\t}\n\t\t\tformatValue = formattedValue;\n\t\t}\n\t\treturn formatValue;\n\t}\n}\nexport default InputMaskType;\n"],"mappings":"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"}

package/src/sap/fe/core/type/InputMask.ts

@@ -0,0 +1,131 @@
+import { defineUI5Class } from "sap/fe/base/ClassSupport";
+import Library from "sap/ui/core/Lib";
+import ValidateException from "sap/ui/model/ValidateException";
+import ODataStringType from "sap/ui/model/odata/type/String";
+
+export type InputMaskRule = {
+	symbol: string;
+	regex: string;
+};
+export type InputMaskFormatOptions = {
+	mask: string;
+	placeholderSymbol: string;
+	maskRule: InputMaskRule[];
+};
+
+@defineUI5Class("sap.fe.core.type.InputMask")
+class InputMaskType extends ODataStringType {
+	constructor(oFormatOptions: InputMaskFormatOptions & { parseKeepsEmptyString?: boolean }) {
+		super(oFormatOptions);
+	}
+
+	oFormatOptions!: InputMaskFormatOptions;
+
+	/**
+	 * Validates the value against the mask. If the value is not provided for any of the mask characters, it throws an error.
+	 *
+	 * @param value String value received from the parseValue method without the mask.
+	 */
+
+	validateValue(value: string): void {
+		// Reuse the formatValue to validate if the value does not match the mask and throw an error in that case
+		const maskedValue = this.formatValue(value);
+		if (maskedValue.includes(this.oFormatOptions.placeholderSymbol)) {
+			let text = Library.getResourceBundleFor("sap.fe.core")!.getText("T_MASKEDINPUT_INVALID_VALUE");
+			if (!text) {
+				text = "";
+			}
+			throw new ValidateException(text);
+		}
+		super.validateValue(value);
+	}
+	/**
+	 * Parse the value by removing the mask characters.
+	 *
+	 * @param value String value from the control with the mask
+	 * @returns String value without the mask
+	 */
+
+	parseValue(value: string): string {
+		// Remove the mask characters from the value
+		let parsedValue = "";
+		let parsedValueIndex = 0;
+		const mask = this.oFormatOptions?.mask;
+		if (mask) {
+			for (let i = 0; i <= mask.length; i++) {
+				if (this.doesMakingRuleExists(this.oFormatOptions.maskRule, mask[i])) {
+					const maskRule = this.oFormatOptions.maskRule.find((rule) => rule.symbol === mask[i]);
+					if (value[parsedValueIndex] && maskRule && value[parsedValueIndex].match(new RegExp(maskRule.regex))) {
+						parsedValue += value[parsedValueIndex++];
+					}
+				} else if (mask[i] === "^") {
+					// check if the character is ^, then skip the next character in value and increment the loop i++ as we don't want to add the escaped character to the parsed value
+					i++;
+					parsedValueIndex++;
+				} else {
+					parsedValueIndex++;
+				}
+			}
+		}
+		return parsedValue;
+	}
+	/**
+	 * Checks if the mask rule exists for the given mask character.
+	 *
+	 * @param maskRule Array of mask rules
+	 * @param maskCharacter Single mask character
+	 * @returns True or False based on the result
+	 */
+
+	doesMakingRuleExists(maskRule: InputMaskRule[], maskCharacter: string): boolean {
+		for (const rule of maskRule) {
+			if (rule.symbol === maskCharacter) {
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	 * Format the value by applying the mask.
+	 *
+	 * @param value String value from the model without the mask
+	 * @returns String value with the mask
+	 */
+
+	formatValue(value: string): string {
+		if (!value) return value;
+
+		const maskRulesPerCharacter: Record<string, string> = {};
+		let formatValue = "";
+		// Create a map of mask rules per character
+		if (this.oFormatOptions.maskRule) {
+			for (const rule of this.oFormatOptions.maskRule) {
+				maskRulesPerCharacter[rule.symbol] = rule.regex;
+			}
+			let valueIndex = 0;
+			let formattedValue = "";
+			const mask = this.oFormatOptions.mask;
+			for (let i = 0; i < mask.length; i++) {
+				// Process character by character, comparing with the mask rules
+				// If the character matches a mask rule, replace it with the character from the value and increment the value index;
+				// Otherwise replace it with the character from the mask
+				if (maskRulesPerCharacter[mask[i]]) {
+					if (value[valueIndex] && value[valueIndex].match(new RegExp(maskRulesPerCharacter[mask[i]]))) {
+						formattedValue += value[valueIndex++];
+					} else {
+						formattedValue += this.oFormatOptions.placeholderSymbol;
+					}
+				} else if (mask[i] === "^") {
+					// if the mask character is ^ then add the character after it to the formatted value and increment the value i++
+					formattedValue += mask[i + 1];
+					i++;
+				} else {
+					formattedValue += mask[i];
+				}
+			}
+			formatValue = formattedValue;
+		}
+		return formatValue;
+	}
+}
+export default InputMaskType;

package/ui5.yaml

@@ -6,6 +6,7 @@ framework:
     name: SAPUI5
     libraries:
         - name: sap.f
+        - name: sap.fe.base
         - name: sap.fe.navigation
         - name: sap.fe.placeholder
         - name: sap.m
@@ -13,3 +14,21 @@ framework:
         - name: sap.ui.layout
         - name: themelib_sap_fiori_3
           optional: true
+builder:
+    bundles:
+        - bundleDefinition:
+              name: sap/fe/core/library-preload.js
+              sections:
+                  - mode: preload
+                    name: sap/fe/core-lib-preload
+                    filters:
+                        - sap/fe/core/**/*
+                        - sap/fe/base/**/*
+                        - "!sap/fe/**/*.designtime.js"
+                        - "!sap/fe/designtime/**/*"
+                    resolve: false
+                    renderer: true
+                    sort: true
+          bundleOptions:
+              optimize: true
+              usePredefineCalls: true

package/src/sap/fe/core/controllerextensions/editFlow/operations/_internal.js

@@ -1,81 +0,0 @@
-/*!
- * SAP UI development toolkit for HTML5 (SAPUI5)
- *      (c) Copyright 2009-2024 SAP SE. All rights reserved
- */
-sap.ui.define(["sap/ui/core/library", "sap/ui/core/message/Message", "sap/ui/core/Messaging"], function (library, Message, Messaging) {
-  "use strict";
-
-  var _exports = {};
-  var MessageType = library.MessageType;
-  /**
-   * Adds error messages for an action parameter field to the message manager.
-   *
-   * @param messageParameters Information identifying an action parameter and messages refering to this parameter
-   */
-  // in case of missing mandaotory parameter, message currently differs per parameter, as it superfluously contains the label as parameter. Possiblky this could be removed in future, in that case, interface could be simplified to ActionParameterInfo[], string
-  function _addMessageForActionParameter(messageParameters) {
-    Messaging.addMessages(messageParameters.map(messageParameter => {
-      const binding = messageParameter.actionParameterInfo.field.getBinding(messageParameter.actionParameterInfo.isMultiValue ? "items" : "value");
-      return new Message({
-        message: messageParameter.message,
-        type: MessageType.Error,
-        processor: binding === null || binding === void 0 ? void 0 : binding.getModel(),
-        persistent: true,
-        target: binding === null || binding === void 0 ? void 0 : binding.getResolvedPath()
-      });
-    }));
-  }
-
-  /**
-   * Checks if all required action parameters contain data and checks for all action parameters if the
-   * contained data is valid.
-   *
-   *
-   * @param actionParameterInfos Information identifying an action parameter
-   * @param resourceModel The model to load text resources
-   * @returns A promise that indicate if the properties are valid or not
-   */
-  _exports._addMessageForActionParameter = _addMessageForActionParameter;
-  async function _validateProperties(actionParameterInfos, resourceModel) {
-    await Promise.allSettled(actionParameterInfos.map(async actionParameterInfo => actionParameterInfo.validationPromise));
-    const requiredParameterInfos = actionParameterInfos.filter(actionParameterInfo => actionParameterInfo.field.getRequired());
-
-    /* Hint: The boolean false is a valid value */
-    const emptyRequiredFields = requiredParameterInfos.filter(requiredParameterInfo => {
-      if (requiredParameterInfo.isMultiValue) {
-        return requiredParameterInfo.value === undefined || !requiredParameterInfo.value.length;
-      } else {
-        const fieldValue = requiredParameterInfo.field.getValue();
-        return fieldValue === undefined || fieldValue === null || fieldValue === "";
-      }
-    });
-
-    // message contains label per field for historical reason (originally, it was shown in additional popup, now it's directly added to the field)
-    // if this was not the case (and hopefully, in future this might be subject to change), interface of _addMessageForActionParameter could be simplified to just pass emptyRequiredFields and a constant message here
-    _addMessageForActionParameter(emptyRequiredFields.map(actionParameterInfo => {
-      var _actionParameterInfo$;
-      return {
-        actionParameterInfo: actionParameterInfo,
-        message: resourceModel.getText("C_OPERATIONS_ACTION_PARAMETER_DIALOG_MISSING_MANDATORY_MSG", [((_actionParameterInfo$ = actionParameterInfo.field.getParent()) === null || _actionParameterInfo$ === void 0 ? void 0 : _actionParameterInfo$.getAggregation("label")).getText()])
-      };
-    }));
-
-    /* Check value state of all parameter */
-    const firstInvalidActionParameter = actionParameterInfos.find(
-    // unfortunately, _addMessageForActionParameter sets valueState only asynchroneously, thus checking emptyRequiredFields and hasError additionally:
-    // - checking hasError: user has changed field to invalid value, validation promise has been rejected, therefore we are adding message to message model
-    // which in turn sets value state to 'Error' but this last step might not have happened yet due to asynchronity in model.
-    // - also checking value state: also out parameter of another action parameter could change field and it's value state without sending change event.
-
-    actionParameterInfo => actionParameterInfo.hasError || actionParameterInfo.field.getValueState() === "Error" || emptyRequiredFields.includes(actionParameterInfo));
-    if (firstInvalidActionParameter) {
-      firstInvalidActionParameter.field.focus();
-      return false;
-    } else {
-      return true;
-    }
-  }
-  _exports._validateProperties = _validateProperties;
-  return _exports;
-}, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_addMessageForActionParameter","messageParameters","Messaging","addMessages","map","messageParameter","binding","actionParameterInfo","field","getBinding","isMultiValue","Message","message","type","MessageType","Error","processor","getModel","persistent","target","getResolvedPath","_validateProperties","actionParameterInfos","resourceModel","Promise","allSettled","validationPromise","requiredParameterInfos","filter","getRequired","emptyRequiredFields","requiredParameterInfo","value","undefined","length","fieldValue","getValue","getText","getParent","getAggregation","firstInvalidActionParameter","find","hasError","getValueState","includes","focus"],"sourceRoot":".","sources":["_internal.ts"],"sourcesContent":["import type ResourceModel from \"sap/fe/core/ResourceModel\";\nimport type Label from \"sap/m/Label\";\nimport { MessageType } from \"sap/ui/core/library\";\nimport Message from \"sap/ui/core/message/Message\";\nimport Messaging from \"sap/ui/core/Messaging\";\nimport type Field from \"sap/ui/mdc/Field\";\nimport type MultiValueFieldItem from \"sap/ui/mdc/field/MultiValueFieldItem\";\nimport type MultiValueField from \"sap/ui/mdc/MultiValueField\";\n\n/**\n * NON of these export must be imported anywhere outside of the ./operations module.\n * They are only exposed to simplify testing until the operations.ts file has been refactored\n */\n\n// this type is meant to describe the meta information for one ActionParameter (i.e. its object in metaModel)\nexport type ActionParameter = {\n\t$Name: string;\n\t$Type: string;\n\t$isCollection: boolean;\n\t// currently runtime information is written into the metamodel:\n\t// - in the press handler of the action button on the parameter dialog, the value of each parameter is added\n\t// - in setActionParameterDefaultValue, this information is used and transferred to the context (in ODataModel) created for the action execution\n\t// this is quite odd, and it would make much more sense to take the value from actionParameterInfos\n\t// - however, setActionParameterDefaultValue (or rather the surrounding _executeAction) is also called from other places\n\t// => for the time being, adding value here to avoid ts errors, subject to refactoring\n\t// in case of Field, the value is string, in case of MultiValueField, it's MultiValueFieldItem[]\n\tvalue: string | boolean | number | MultiValueFieldItem[] | undefined;\n};\n\nexport type ActionParameterInfo = {\n\tparameter: ActionParameter;\n\tfield: Field | MultiValueField;\n\tisMultiValue: boolean;\n\tvalue?: string | MultiValueFieldItem[];\n\tvalidationPromise?: Promise<string | MultiValueFieldItem[]>;\n\thasError?: boolean;\n};\n\n/**\n * Adds error messages for an action parameter field to the message manager.\n *\n * @param messageParameters Information identifying an action parameter and messages refering to this parameter\n */\n// in case of missing mandaotory parameter, message currently differs per parameter, as it superfluously contains the label as parameter. Possiblky this could be removed in future, in that case, interface could be simplified to ActionParameterInfo[], string\nexport function _addMessageForActionParameter(messageParameters: { actionParameterInfo: ActionParameterInfo; message: string }[]): void {\n\tMessaging.addMessages(\n\t\tmessageParameters.map((messageParameter) => {\n\t\t\tconst binding = messageParameter.actionParameterInfo.field.getBinding(\n\t\t\t\tmessageParameter.actionParameterInfo.isMultiValue ? \"items\" : \"value\"\n\t\t\t);\n\t\t\treturn new Message({\n\t\t\t\tmessage: messageParameter.message,\n\t\t\t\ttype: MessageType.Error,\n\t\t\t\tprocessor: binding?.getModel(),\n\t\t\t\tpersistent: true,\n\t\t\t\ttarget: binding?.getResolvedPath()\n\t\t\t});\n\t\t})\n\t);\n}\n\n/**\n * Checks if all required action parameters contain data and checks for all action parameters if the\n * contained data is valid.\n *\n *\n * @param actionParameterInfos Information identifying an action parameter\n * @param resourceModel The model to load text resources\n * @returns A promise that indicate if the properties are valid or not\n */\nexport async function _validateProperties(actionParameterInfos: ActionParameterInfo[], resourceModel: ResourceModel): Promise<boolean> {\n\tawait Promise.allSettled(\n\t\tactionParameterInfos.map(async (actionParameterInfo: ActionParameterInfo) => actionParameterInfo.validationPromise)\n\t);\n\tconst requiredParameterInfos = actionParameterInfos.filter((actionParameterInfo) => actionParameterInfo.field.getRequired());\n\n\t/* Hint: The boolean false is a valid value */\n\tconst emptyRequiredFields = requiredParameterInfos.filter((requiredParameterInfo) => {\n\t\tif (requiredParameterInfo.isMultiValue) {\n\t\t\treturn requiredParameterInfo.value === undefined || !requiredParameterInfo.value.length;\n\t\t} else {\n\t\t\tconst fieldValue = (requiredParameterInfo.field as Field).getValue();\n\t\t\treturn fieldValue === undefined || fieldValue === null || fieldValue === \"\";\n\t\t}\n\t});\n\n\t// message contains label per field for historical reason (originally, it was shown in additional popup, now it's directly added to the field)\n\t// if this was not the case (and hopefully, in future this might be subject to change), interface of _addMessageForActionParameter could be simplified to just pass emptyRequiredFields and a constant message here\n\t_addMessageForActionParameter(\n\t\temptyRequiredFields.map((actionParameterInfo) => ({\n\t\t\tactionParameterInfo: actionParameterInfo,\n\t\t\tmessage: resourceModel.getText(\"C_OPERATIONS_ACTION_PARAMETER_DIALOG_MISSING_MANDATORY_MSG\", [\n\t\t\t\t(actionParameterInfo.field.getParent()?.getAggregation(\"label\") as Label).getText()\n\t\t\t])\n\t\t}))\n\t);\n\n\t/* Check value state of all parameter */\n\tconst firstInvalidActionParameter = actionParameterInfos.find(\n\t\t// unfortunately, _addMessageForActionParameter sets valueState only asynchroneously, thus checking emptyRequiredFields and hasError additionally:\n\t\t// - checking hasError: user has changed field to invalid value, validation promise has been rejected, therefore we are adding message to message model\n\t\t// which in turn sets value state to 'Error' but this last step might not have happened yet due to asynchronity in model.\n\t\t// - also checking value state: also out parameter of another action parameter could change field and it's value state without sending change event.\n\n\t\t(actionParameterInfo) =>\n\t\t\tactionParameterInfo.hasError ||\n\t\t\tactionParameterInfo.field.getValueState() === \"Error\" ||\n\t\t\temptyRequiredFields.includes(actionParameterInfo)\n\t);\n\n\tif (firstInvalidActionParameter) {\n\t\tfirstInvalidActionParameter.field.focus();\n\t\treturn false;\n\t} else {\n\t\treturn true;\n\t}\n}\n"],"mappings":";AAAA;AAAA;AAAA;;;;;;EAsCA;AACA;AACA;AACA;AACA;EACA;EACO,SAASA,6BAA6B,CAACC,iBAAkF,EAAQ;IACvIC,SAAS,CAACC,WAAW,CACpBF,iBAAiB,CAACG,GAAG,CAAEC,gBAAgB,IAAK;MAC3C,MAAMC,OAAO,GAAGD,gBAAgB,CAACE,mBAAmB,CAACC,KAAK,CAACC,UAAU,CACpEJ,gBAAgB,CAACE,mBAAmB,CAACG,YAAY,GAAG,OAAO,GAAG,OAAO,CACrE;MACD,OAAO,IAAIC,OAAO,CAAC;QAClBC,OAAO,EAAEP,gBAAgB,CAACO,OAAO;QACjCC,IAAI,EAAEC,WAAW,CAACC,KAAK;QACvBC,SAAS,EAAEV,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEW,QAAQ,EAAE;QAC9BC,UAAU,EAAE,IAAI;QAChBC,MAAM,EAAEb,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEc,eAAe;MACjC,CAAC,CAAC;IACH,CAAC,CAAC,CACF;EACF;;EAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EARA;EASO,eAAeC,mBAAmB,CAACC,oBAA2C,EAAEC,aAA4B,EAAoB;IACtI,MAAMC,OAAO,CAACC,UAAU,CACvBH,oBAAoB,CAAClB,GAAG,CAAC,MAAOG,mBAAwC,IAAKA,mBAAmB,CAACmB,iBAAiB,CAAC,CACnH;IACD,MAAMC,sBAAsB,GAAGL,oBAAoB,CAACM,MAAM,CAAErB,mBAAmB,IAAKA,mBAAmB,CAACC,KAAK,CAACqB,WAAW,EAAE,CAAC;;IAE5H;IACA,MAAMC,mBAAmB,GAAGH,sBAAsB,CAACC,MAAM,CAAEG,qBAAqB,IAAK;MACpF,IAAIA,qBAAqB,CAACrB,YAAY,EAAE;QACvC,OAAOqB,qBAAqB,CAACC,KAAK,KAAKC,SAAS,IAAI,CAACF,qBAAqB,CAACC,KAAK,CAACE,MAAM;MACxF,CAAC,MAAM;QACN,MAAMC,UAAU,GAAIJ,qBAAqB,CAACvB,KAAK,CAAW4B,QAAQ,EAAE;QACpE,OAAOD,UAAU,KAAKF,SAAS,IAAIE,UAAU,KAAK,IAAI,IAAIA,UAAU,KAAK,EAAE;MAC5E;IACD,CAAC,CAAC;;IAEF;IACA;IACAnC,6BAA6B,CAC5B8B,mBAAmB,CAAC1B,GAAG,CAAEG,mBAAmB;MAAA;MAAA,OAAM;QACjDA,mBAAmB,EAAEA,mBAAmB;QACxCK,OAAO,EAAEW,aAAa,CAACc,OAAO,CAAC,4DAA4D,EAAE,CAC5F,0BAAC9B,mBAAmB,CAACC,KAAK,CAAC8B,SAAS,EAAE,0DAArC,sBAAuCC,cAAc,CAAC,OAAO,CAAC,EAAWF,OAAO,EAAE,CACnF;MACF,CAAC;IAAA,CAAC,CAAC,CACH;;IAED;IACA,MAAMG,2BAA2B,GAAGlB,oBAAoB,CAACmB,IAAI;IAC5D;IACA;IACA;IACA;;IAEClC,mBAAmB,IACnBA,mBAAmB,CAACmC,QAAQ,IAC5BnC,mBAAmB,CAACC,KAAK,CAACmC,aAAa,EAAE,KAAK,OAAO,IACrDb,mBAAmB,CAACc,QAAQ,CAACrC,mBAAmB,CAAC,CAClD;IAED,IAAIiC,2BAA2B,EAAE;MAChCA,2BAA2B,CAAChC,KAAK,CAACqC,KAAK,EAAE;MACzC,OAAO,KAAK;IACb,CAAC,MAAM;MACN,OAAO,IAAI;IACZ;EACD;EAAC;EAAA;AAAA"}