@ui5/webcomponents-localization 0.0.0-dff5837d7 → 0.0.0-e55c2cec6

package/dist/sap/ui/core/format/TimezoneUtil.js

@@ -0,0 +1,94 @@
+var TimezoneUtil = {};
+var sLocalTimezone = "";
+var aSupportedTimezoneIDs;
+var oIntlDateTimeFormatCache = {
+  _oCache: new Map(),
+  _iCacheLimit: 10,
+  get: function (sTimezone) {
+    var cacheEntry = this._oCache.get(sTimezone);
+    if (cacheEntry) {
+      return cacheEntry;
+    }
+    var oOptions = {
+      hourCycle: "h23",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3,
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric",
+      timeZone: sTimezone,
+      timeZoneName: "short",
+      era: "narrow"
+    };
+    var oInstance = new Intl.DateTimeFormat("en-US", oOptions);
+    if (this._oCache.size === this._iCacheLimit) {
+      this._oCache = new Map();
+    }
+    this._oCache.set(sTimezone, oInstance);
+    return oInstance;
+  }
+};
+TimezoneUtil.isValidTimezone = function (sTimezone) {
+  if (!sTimezone) {
+    return false;
+  }
+  if (Intl.supportedValuesOf) {
+    try {
+      aSupportedTimezoneIDs = aSupportedTimezoneIDs || Intl.supportedValuesOf("timeZone");
+      if (aSupportedTimezoneIDs.includes(sTimezone)) {
+        return true;
+      }
+    } catch (oError) {
+      aSupportedTimezoneIDs = [];
+    }
+  }
+  try {
+    oIntlDateTimeFormatCache.get(sTimezone);
+    return true;
+  } catch (oError) {
+    return false;
+  }
+};
+TimezoneUtil.convertToTimezone = function (oDate, sTargetTimezone) {
+  var oFormatParts = this._getParts(oDate, sTargetTimezone);
+  return TimezoneUtil._getDateFromParts(oFormatParts);
+};
+TimezoneUtil._getParts = function (oDate, sTargetTimezone) {
+  var oIntlDate = oIntlDateTimeFormatCache.get(sTargetTimezone);
+  var oParts = oIntlDate.formatToParts(new Date(oDate.getTime()));
+  var oDateParts = Object.create(null);
+  for (var sKey in oParts) {
+    var oPart = oParts[sKey];
+    if (oPart.type !== "literal") {
+      oDateParts[oPart.type] = oPart.value;
+    }
+  }
+  return oDateParts;
+};
+TimezoneUtil._getDateFromParts = function (oParts) {
+  var oDate = new Date(0);
+  var iUTCYear = parseInt(oParts.year);
+  if (oParts.era === "B") {
+    iUTCYear = iUTCYear * -1 + 1;
+  }
+  oDate.setUTCFullYear(iUTCYear, parseInt(oParts.month) - 1, parseInt(oParts.day));
+  oDate.setUTCHours(parseInt(oParts.hour), parseInt(oParts.minute), parseInt(oParts.second), parseInt(oParts.fractionalSecond || 0));
+  return oDate;
+};
+TimezoneUtil.calculateOffset = function (oDate, sTimezoneSource) {
+  var oFirstGuess = this.convertToTimezone(oDate, sTimezoneSource);
+  var iInitialOffset = oDate.getTime() - oFirstGuess.getTime();
+  var oDateSource = new Date(oDate.getTime() + iInitialOffset);
+  var oDateTarget = this.convertToTimezone(oDateSource, sTimezoneSource);
+  return (oDateSource.getTime() - oDateTarget.getTime()) / 1000;
+};
+TimezoneUtil.getLocalTimezone = function () {
+  if (sLocalTimezone) {
+    return sLocalTimezone;
+  }
+  sLocalTimezone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return sLocalTimezone;
+};
+export default TimezoneUtil;

package/package-scripts.js

@@ -1,25 +1,32 @@
+const resolve = require("resolve");
+const copyUsedModules = resolve.sync("@ui5/webcomponents-tools/lib/copy-list/index.js");
+const replaceGlobalCore = resolve.sync("@ui5/webcomponents-tools/lib/replace-global-core/index.js");
+const esmAbsToRel = resolve.sync("@ui5/webcomponents-tools/lib/esm-abs-to-rel/index.js");
+
 const scripts = {
 	clean: "rimraf dist",
 	lint: "eslint . --config config/.eslintrc.js",
 	build: {
-		"default": "path-exists dist/ || nps build.all",
-		all: "nps lint clean copy.used-modules copy.cldr copy.overlay build.replace-amd build.replace-export-true build.replace-export-false build.amd-to-es6 build.replace-global-core-usage build.esm-abs-to-rel build.jsonImports copy.src",
+		"default": "nps lint clean copy.used-modules copy.cldr copy.overlay build.replace-amd build.replace-export-true build.replace-export-false build.amd-to-es6 build.replace-global-core-usage build.esm-abs-to-rel build.jsonImports build.typescript copy.src",
 		"replace-amd": "replace-in-file sap.ui.define define dist/**/*.js",
 		"replace-export-true": `replace-in-file ", /* bExport= */ true" "" dist/**/*.js`,
 		"replace-export-false": `replace-in-file ", /* bExport= */ false" "" dist/**/*.js`,
 		"amd-to-es6": "amdtoes6 --src=dist --replace --glob=**/*.js",
-		"replace-global-core-usage": "node ./lib/replace-global-core/index.js dist/",
-		"esm-abs-to-rel": "node ./lib/esm-abs-to-rel/index.js dist/",
-		jsonImports: "node ./lib/generate-json-imports/cldr.js",
+		"replace-global-core-usage": `node "${replaceGlobalCore}" dist/`,
+		"esm-abs-to-rel": `node "${esmAbsToRel}" dist/`,
+		typescript: "tsc",
+		jsonImports: "node ./lib/generate-json-imports/cldr.js"
 	},
+	typescript: "tsc",
 	copy: {
-		"used-modules": "node ./lib/copy-list/index.js ./used-modules.txt dist/",
+		"used-modules": `node "${copyUsedModules}" ./used-modules.txt dist/`,
 		cldr: `copy-and-watch "../../node_modules/@openui5/sap.ui.core/src/sap/ui/core/cldr/*.json" dist/generated/assets/cldr/`,
 		overlay: `copy-and-watch "overlay/**/*.js" dist/`,
 		src: `copy-and-watch "src/**/*.js" dist/`,
 	},
 	watch: {
-		default: 'nps watch.src',
+		default: 'concurrently "nps watch.src" "nps watch.typescript" ',
+		typescript: "tsc --watch",
 		src: `nps "copy.src --watch --skip-initial-copy"`,
 	},
 	start: "nps watch",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ui5/webcomponents-localization",
-  "version": "0.0.0-dff5837d7",
+  "version": "0.0.0-e55c2cec6",
   "description": "Localization for UI5 Web Components",
   "author": "SAP SE (https://www.sap.com)",
   "license": "Apache-2.0",
@@ -14,6 +14,11 @@
     "url": "https://github.com/SAP/ui5-webcomponents.git",
     "directory": "packages/localization"
   },
+  "exports": {
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json",
+    "./*": "./dist/*"
+  },
   "scripts": {
     "clean": "nps clean",
     "lint": "nps lint",
@@ -22,20 +27,14 @@
     "prepublishOnly": "npm run clean && npm run build"
   },
   "devDependencies": {
-    "@buxlabs/amd-to-es6": "^0.15.0",
-    "@openui5/sap.ui.core": "1.76.0",
-    "@ui5/webcomponents-tools": "0.0.0-dff5837d7",
-    "chromedriver": "latest",
-    "copy-and-watch": "^0.1.4",
-    "escodegen": "^1.11.0",
-    "esprima": "^4.0.1",
-    "glob": "^7.1.3",
-    "mkdirp": "^0.5.1",
-    "path-exists-cli": "^1.0.0",
-    "replace-in-file": "^3.4.2",
-    "rimraf": "^2.6.2"
+    "@openui5/sap.ui.core": "1.109.0",
+    "@types/openui5": "^1.108.0",
+    "@ui5/webcomponents-tools": "0.0.0-e55c2cec6",
+    "chromedriver": "108.0.0",
+    "mkdirp": "^1.0.4",
+    "resolve": "^1.20.0"
   },
   "dependencies": {
-    "@ui5/webcomponents-base": "0.0.0-dff5837d7"
+    "@ui5/webcomponents-base": "0.0.0-e55c2cec6"
   }
 }

package/src/Assets-static.ts

@@ -0,0 +1,2 @@
+// Currently the base package provides CLDR assets only
+import "./generated/json-imports/LocaleData-static.js";

package/src/DateFormat.ts

@@ -0,0 +1,8 @@
+import type DateFormatT from "sap/ui/core/format/DateFormat";
+// @ts-ignore
+import DateFormatNative from "./sap/ui/core/format/DateFormat.js";
+
+const DateFormatWrapped = DateFormatNative as typeof DateFormatT;
+class DateFormat extends DateFormatWrapped {}
+
+export default DateFormat;

package/src/LocaleData.ts

@@ -0,0 +1,8 @@
+import type LocaleDataOpenUI5T from "sap/ui/core/LocaleData";
+// @ts-ignore
+import LocaleDataNative from "./sap/ui/core/LocaleData.js";
+
+const LocaleDataWrapped = LocaleDataNative as typeof LocaleDataOpenUI5T;
+class LocaleData extends LocaleDataWrapped {}
+
+export default LocaleData;

package/src/dates/{CalendarDate.js → CalendarDate.ts}

@@ -1,23 +1,26 @@
-import UniversalDate from "../sap/ui/core/date/UniversalDate.js";
+import type CalendarType from "@ui5/webcomponents-base/dist/types/CalendarType.js";
+import UniversalDate from "./UniversalDate.js";
 
 class CalendarDate {
-	constructor() {
+	_oUDate!: Date | UniversalDate;
+
+	constructor(year?: number | CalendarDate, month?: number | string, date?: number, calendarType?: string) { // eslint-disable-line
 		let aArgs = arguments, // eslint-disable-line
-			oJSDate,
-			oNow,
-			sCalendarType;
+			oJSDate: Date,
+			oNow: Date,
+			sCalendarType!: CalendarType;
 
 		switch (aArgs.length) {
 		case 0: // defaults to the current date
 			oNow = new Date();
-			return this.constructor(oNow.getFullYear(), oNow.getMonth(), oNow.getDate());
+			return (this.constructor(oNow.getFullYear(), oNow.getMonth(), oNow.getDate()) as CalendarDate);
 
 		case 1: // CalendarDate
 		case 2: // CalendarDate, sCalendarType
 			if (!(aArgs[0] instanceof CalendarDate)) {
-				throw new Error("Invalid arguments: the first argument must be of type sap.ui.unified.calendar.CalendarDate.");
+				throw new Error("Invalid arguments: the first argument must be of type CalendarDate.");
 			}
-			sCalendarType = aArgs[1] ? aArgs[1] : aArgs[0]._oUDate.sCalendarType;
+			sCalendarType = aArgs[1] ? aArgs[1] : (aArgs[0]._oUDate as UniversalDate).sCalendarType;
 			// Use source.valueOf() (returns the same point of time regardless calendar type) instead of
 			// source's getters to avoid non-gregorian Year, Month and Date may be used to construct a Gregorian date
 			oJSDate = new Date(aArgs[0].valueOf());
@@ -31,12 +34,12 @@ class CalendarDate {
 
 		case 3: // year, month, date
 		case 4: // year, month, date, sCalendarType
-			checkNumericLike(aArgs[0], `Invalid year: ${aArgs[0]}`);
-			checkNumericLike(aArgs[1], `Invalid month: ${aArgs[1]}`);
-			checkNumericLike(aArgs[2], `Invalid date: ${aArgs[2]}`);
+			checkNumericLike(aArgs[0] as number, `Invalid year: ${aArgs[0] as number}`);
+			checkNumericLike(aArgs[1] as number, `Invalid month: ${aArgs[1] as number}`);
+			checkNumericLike(aArgs[2] as number, `Invalid date: ${aArgs[2] as number}`);
 
 			oJSDate = new Date(0, 0, 1);
-			oJSDate.setFullYear(aArgs[0], aArgs[1], aArgs[2]); // 2 digits year is not supported. If so, it is considered as full year as well.
+			oJSDate.setFullYear(aArgs[0] as number, aArgs[1] as number, aArgs[2] as number); // 2 digits year is not supported. If so, it is considered as full year as well.
 
 			if (aArgs[3]) {
 				sCalendarType = aArgs[3];
@@ -46,7 +49,7 @@ class CalendarDate {
 
 		default:
 			throw new Error(`${"Invalid arguments. Accepted arguments are: 1) oCalendarDate, (optional)calendarType"
-				+ "or 2) year, month, date, (optional) calendarType"}${aArgs}`);
+				+ "or 2) year, month, date, (optional) calendarType"}${aArgs as unknown as string}`);
 		}
 	}
 
@@ -54,7 +57,7 @@ class CalendarDate {
 		return this._oUDate.getUTCFullYear();
 	}
 
-	setYear(year) {
+	setYear(year: number) {
 		checkNumericLike(year, `Invalid year: ${year}`);
 		this._oUDate.setUTCFullYear(year);
 		return this;
@@ -64,9 +67,29 @@ class CalendarDate {
 		return this._oUDate.getUTCMonth();
 	}
 
-	setMonth(month) {
+	/**
+	 * Sets the given month as ordinal month of the year.
+	 * @param {int} month An integer between 0 and 11, representing the months January through December( or their
+	 * equivalent month names for the given calendar).
+	 * If the specified value is is outside of the expected range, this method attempts to update the date information
+	 * accordingly. For example, if 12 is given as a month, the year will be incremented by 1, and 1 will be used for month.
+	 * @param {int} [date] An integer between 1 and 31, representing the day of the month, but other values are allowed.
+	 * 0 will result in the previous month's last day.
+	 * -1 will result in the day before the previous month's last day.
+	 * 32 will result in:
+	 * - first day of the next month if the current month has 31 days.
+	 * - second day of the next month if the current month has 30 days.
+	 * Other value will result in adding or subtracting days according to the given value.
+	 * @returns {sap.ui.unified.calendar.CalendarDate} <code>this</code> for method chaining.
+	 */
+	setMonth(month: number, date?: number) {
 		checkNumericLike(month, `Invalid month: ${month}`);
-		this._oUDate.setUTCMonth(month);
+		if (date || date === 0) {
+			checkNumericLike(date, `Invalid date: ${date}`);
+			this._oUDate.setUTCMonth(month, date);
+		} else {
+			this._oUDate.setUTCMonth(month);
+		}
 		return this;
 	}
 
@@ -74,7 +97,7 @@ class CalendarDate {
 		return this._oUDate.getUTCDate();
 	}
 
-	setDate(date) {
+	setDate(date: number) {
 		checkNumericLike(date, `Invalid date: ${date}`);
 		this._oUDate.setUTCDate(date);
 		return this;
@@ -85,30 +108,30 @@ class CalendarDate {
 	}
 
 	getCalendarType() {
-		return this._oUDate.sCalendarType;
+		return (this._oUDate as UniversalDate).sCalendarType;
 	}
 
-	isBefore(oCalendarDate) {
+	isBefore(oCalendarDate: CalendarDate) {
 		checkCalendarDate(oCalendarDate);
 		return this.valueOf() < oCalendarDate.valueOf();
 	}
 
-	isAfter(oCalendarDate) {
+	isAfter(oCalendarDate: CalendarDate) {
 		checkCalendarDate(oCalendarDate);
 		return this.valueOf() > oCalendarDate.valueOf();
 	}
 
-	isSameOrBefore(oCalendarDate) {
+	isSameOrBefore(oCalendarDate: CalendarDate) {
 		checkCalendarDate(oCalendarDate);
 		return this.valueOf() <= oCalendarDate.valueOf();
 	}
 
-	isSameOrAfter(oCalendarDate) {
+	isSameOrAfter(oCalendarDate: CalendarDate) {
 		checkCalendarDate(oCalendarDate);
 		return this.valueOf() >= oCalendarDate.valueOf();
 	}
 
-	isSame(oCalendarDate) {
+	isSame(oCalendarDate: CalendarDate) {
 		checkCalendarDate(oCalendarDate);
 		return this.valueOf() === oCalendarDate.valueOf();
 	}
@@ -135,34 +158,40 @@ class CalendarDate {
 	}
 
 	toString() {
-		return `${this._oUDate.sCalendarType}: ${this.getYear()}/${this.getMonth() + 1}/${this.getDate()}`;
+		return `${(this._oUDate as UniversalDate).sCalendarType}: ${this.getYear()}/${this.getMonth() + 1}/${this.getDate()}`;
 	}
 
 	valueOf() {
 		return this._oUDate.getTime();
 	}
 
-	static fromLocalJSDate(oJSDate, sCalendarType) {
+	static fromLocalJSDate(oJSDate: Date, sCalendarType?: CalendarType) {
 		// Cross frame check for a date should be performed here otherwise setDateValue would fail in OPA tests
 		// because Date object in the test is different than the Date object in the application (due to the iframe).
 		// We can use jQuery.type or this method:
-		function isValidDate(date) {
-			return date && Object.prototype.toString.call(date) === "[object Date]" && !isNaN(date); // eslint-disable-line
+		function isValidDate(date: Date) {
+			return date && Object.prototype.toString.call(date) === "[object Date]" && !isNaN(date as unknown as number); // eslint-disable-line
 		}
 		if (!isValidDate(oJSDate)) {
-			throw new Error(`Date parameter must be a JavaScript Date object: [${oJSDate}].`);
+			throw new Error(`Date parameter must be a JavaScript Date object: [${oJSDate as unknown as string}].`);
 		}
 		return new CalendarDate(oJSDate.getFullYear(), oJSDate.getMonth(), oJSDate.getDate(), sCalendarType);
 	}
 
-	static fromTimestamp(iTimestamp, sCalendarType) {
+	static fromTimestamp(iTimestamp: number, sCalendarType?: CalendarType) {
 		const oCalDate = new CalendarDate(0, 0, 1);
-		oCalDate._oUDate = UniversalDate.getInstance(new Date(iTimestamp), sCalendarType);
+		let oUDate;
+		try {
+			oUDate = UniversalDate.getInstance(new Date(iTimestamp), sCalendarType);
+		} catch (e) {
+			oUDate = new Date(NaN); // UniversalDate.getInstance may now throw an Exception - keep the old behavior
+		}
+		oCalDate._oUDate = oUDate;
 		return oCalDate;
 	}
 }
 
-function createUniversalUTCDate(oDate, sCalendarType) {
+function createUniversalUTCDate(oDate: Date, sCalendarType: CalendarType) {
 	if (sCalendarType) {
 		return UniversalDate.getInstance(createUTCDate(oDate), sCalendarType);
 	}
@@ -174,7 +203,7 @@ function createUniversalUTCDate(oDate, sCalendarType) {
  * @param {Date} oDate JavaScript date object. Time related information is cut.
  * @returns {Date} JavaScript date created from the date object, but this time considered as UTC date information.
  */
-function createUTCDate(oDate) {
+function createUTCDate(oDate: Date) {
 	const oUTCDate = new Date(Date.UTC(0, 0, 1));
 
 	oUTCDate.setUTCFullYear(oDate.getFullYear(), oDate.getMonth(), oDate.getDate());
@@ -182,9 +211,9 @@ function createUTCDate(oDate) {
 	return oUTCDate;
 }
 
-function checkCalendarDate(oCalendarDate) {
+function checkCalendarDate(oCalendarDate: CalendarDate) {
 	if (!(oCalendarDate instanceof CalendarDate)) {
-		throw new Error(`Invalid calendar date: [${oCalendarDate}]. Expected: sap.ui.unified.calendar.CalendarDate`);
+		throw new Error(`Invalid calendar date: [${oCalendarDate as unknown as string}]. Expected: CalendarDate`);
 	}
 }
 
@@ -194,7 +223,7 @@ function checkCalendarDate(oCalendarDate) {
  * @param {string} message The message to be used if an error is to be thrown
  * @throws will throw an error if the value is null or undefined or is not like a number
  */
-function checkNumericLike(value, message) {
+function checkNumericLike(value: any, message: string) {
 	if (value === undefined || value === Infinity || isNaN(value)) { // eslint-disable-line
 		throw message;
 	}

package/src/dates/ExtremeDates.ts

@@ -0,0 +1,40 @@
+import CalendarType from "@ui5/webcomponents-base/dist/types/CalendarType.js";
+import CalendarDate from "./CalendarDate.js";
+
+const cache = new Map<string, CalendarDate>();
+
+const getMinCalendarDate = (primaryCalendarType: CalendarType) => {
+	const key = `min ${primaryCalendarType}`;
+
+	if (!cache.has(key)) {
+		const minDate = new CalendarDate(1, 0, 1, primaryCalendarType);
+		minDate.setYear(1);
+		minDate.setMonth(0);
+		minDate.setDate(1);
+		cache.set(key, minDate);
+	}
+
+	return cache.get(key)!;
+};
+
+const getMaxCalendarDate = (primaryCalendarType: CalendarType) => {
+	const key = `max ${primaryCalendarType}`;
+
+	if (!cache.has(key)) {
+		const maxDate = new CalendarDate(1, 0, 1, primaryCalendarType);
+		maxDate.setYear(9999);
+		maxDate.setMonth(11);
+		const tempDate = new CalendarDate(maxDate, primaryCalendarType);
+		tempDate.setDate(1);
+		tempDate.setMonth(tempDate.getMonth() + 1, 0);
+		maxDate.setDate(tempDate.getDate());// 31st for Gregorian Calendar
+		cache.set(key, maxDate);
+	}
+
+	return cache.get(key)!;
+};
+
+export {
+	getMinCalendarDate,
+	getMaxCalendarDate,
+};

package/src/dates/UniversalDate.ts

@@ -0,0 +1,51 @@
+import type CalendarType from "@ui5/webcomponents-base/dist/types/CalendarType.js";
+// @ts-ignore
+import UniversalDateNative from "../sap/ui/core/date/UniversalDate.js";
+
+type UniversalDate = {
+    new (time: number): UniversalDate;
+    oDate: Date,
+    sCalendarType: string,
+    getInstance: (oDate: Date, sCalendarType?: CalendarType) => UniversalDate,
+    getDate: () => number,
+    getMonth: () => number,
+    getFullYear: () => number,
+    getYear: () => number,
+    getDay: () => number,
+    getHours: () => number,
+    getMinutes: () => number,
+    getSeconds: () => number,
+    getMilliseconds: () => number,
+    getUTCDate: () => number,
+    getUTCMonth: () => number,
+    getUTCFullYear: () => number,
+    getUTCDay: () => number,
+    getUTCHours: () => number,
+    getUTCMinutes: () => number,
+    getUTCSeconds: () => number,
+    getUTCMilliseconds: () => number,
+    getTime: () => number,
+    valueOf: () => number,
+    getTimezoneOffset: () => number,
+    toString: () => string,
+    toDateString: () => string,
+    setDate: (dayValue: number) => number,
+    setFullYear: (yearValue: number, monthValue?: number, dateValue?: number) => number,
+    setYear: (yearValue: number) => number,
+    setMonth: (monthValue: number, dayValue?: number) => number,
+    setHours: (hoursValue: number, minutesValue?: number, secondsValue?: number, msValue?: number) => number,
+    setMinutes: (minutesValue: number, secondsValue?: number, msValue?: number) => number,
+    setSeconds: (secondsValue: number, msValue?: number) => number,
+    setMilliseconds: (setMilliseconds: number) => number,
+    setUTCDate:(dayValue: number) => number,
+    setUTCFullYear: (yearValue: number, monthValue?: number, dayValue?: number) => number,
+    setUTCMonth: (monthValue: number, dayValue?: number) => number,
+    setUTCHours: (hoursValue: number, minutesValue?: number, secondsValue?: number, msValue?: number) => number,
+    setUTCMinutes: (minutesValue: number, secondsValue?: number, msValue?: number) => number,
+    setUTCSeconds: (secondsValue: number, msValue?: number) => number,
+    setUTCMilliseconds: (setMilliseconds: number) => number,
+}
+
+const UniversalDate: UniversalDate = UniversalDateNative;
+
+export default UniversalDate;

package/src/dates/{calculateWeekNumber.js → calculateWeekNumber.ts}

@@ -1,9 +1,11 @@
-import UniversalDate from "../sap/ui/core/date/UniversalDate.js";
+import type Locale from "@ui5/webcomponents-base/dist/locale/Locale.js";
+import UniversalDate from "./UniversalDate.js";
+import type LocaleData from "../LocaleData.js";
 
-const calculateWeekNumber = (confFirstDayOfWeek, oDate, iYear, oLocale, oLocaleData) => {
+const calculateWeekNumber = (confFirstDayOfWeek: number | undefined, oDate: Date, iYear: number, oLocale: Locale, oLocaleData: LocaleData) => {
 	let iWeekNum = 0;
 	let iWeekDay = 0;
-	const iFirstDayOfWeek = Number.isInteger(confFirstDayOfWeek) ? confFirstDayOfWeek : oLocaleData.getFirstDayOfWeek();
+	const iFirstDayOfWeek = Number.isInteger(confFirstDayOfWeek) ? confFirstDayOfWeek! : oLocaleData.getFirstDayOfWeek();
 
 	// search Locale for containing "en-US", since sometimes
 	// when any user settings have been defined, subtag "sapufmt" is added to the locale name

package/src/dates/convertMonthNumbersToMonthNames.ts

@@ -0,0 +1,34 @@
+import getLocale from "@ui5/webcomponents-base/dist/locale/getLocale.js";
+import type CalendarType from "@ui5/webcomponents-base/dist/types/CalendarType.js";
+import getCachedLocaleDataInstance from "../getCachedLocaleDataInstance.js";
+
+/**
+ * Convert month number to month name (text).
+ * If the numbers of the two months are the same you will get the name of the month,
+ * otherwise you will get the two names separated by a dash
+ *
+ * @param firstMonth CalendarDate Month
+ * @param lastMonth CalendarDate Month
+ * @param calendarType calendar type
+ * @returns {String}
+ */
+const convertMonthNumbersToMonthNames = (firstMonth: number, lastMonth: number, calendarType?: CalendarType) => {
+	const localeData = getCachedLocaleDataInstance(getLocale());
+	const pattern = localeData.getIntervalPattern("");
+	const secondaryMonthsNames = localeData.getMonthsStandAlone("abbreviated", calendarType) as Array<string>;
+	const secondaryMonthsNamesWide = localeData.getMonthsStandAlone("wide", calendarType) as Array<string>;
+
+	if (firstMonth === lastMonth) {
+		return {
+			text: localeData.getMonths("abbreviated", calendarType)[firstMonth],
+			textInfo: localeData.getMonths("wide", calendarType)[firstMonth],
+		};
+	}
+
+	return {
+		text: pattern.replace(/\{0\}/, secondaryMonthsNames[firstMonth]).replace(/\{1\}/, secondaryMonthsNames[lastMonth]),
+		textInfo: pattern.replace(/\{0\}/, secondaryMonthsNamesWide[firstMonth]).replace(/\{1\}/, secondaryMonthsNamesWide[lastMonth]),
+	};
+};
+
+export default convertMonthNumbersToMonthNames;

package/src/dates/getDaysInMonth.ts

@@ -0,0 +1,11 @@
+import CalendarDate from "./CalendarDate.js";
+
+const getDaysInMonth = (date: CalendarDate) => {
+	const tempCalendarDate = new CalendarDate(date);
+	tempCalendarDate.setDate(1);
+	tempCalendarDate.setMonth(tempCalendarDate.getMonth() + 1);
+	tempCalendarDate.setDate(0);
+	return tempCalendarDate.getDate();
+};
+
+export default getDaysInMonth;

package/src/dates/getRoundedTimestamp.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a timestamp with only the year, month and day (with zero hours, minutes and seconds) and without 000 for milliseconds
+ * @param { number } millisecondsUTC
+ * @returns { number }
+ */
+const getRoundedTimestamp = (millisecondsUTC: number) => {
+	if (!millisecondsUTC) {
+		millisecondsUTC = new Date().getTime();
+	}
+	const rounded = millisecondsUTC - (millisecondsUTC % (24 * 60 * 60 * 1000));
+	return rounded / 1000;
+};
+
+export default getRoundedTimestamp;

package/src/dates/getTodayUTCTimestamp.ts

@@ -0,0 +1,10 @@
+import type CalendarType from "@ui5/webcomponents-base/dist/types/CalendarType.js";
+import CalendarDate from "./CalendarDate.js";
+
+/**
+ * Returns a UTC timestamp representing today
+ * @public
+ */
+const getTodayUTCTimestamp = (primaryCalendarType: CalendarType) => CalendarDate.fromLocalJSDate(new Date(), primaryCalendarType).valueOf() / 1000;
+
+export default getTodayUTCTimestamp;

package/src/dates/modifyDateBy.ts

@@ -0,0 +1,42 @@
+import CalendarDate from "./CalendarDate.js";
+
+/**
+ * Adds or subtracts a given amount of days/months/years from a date.
+ * If minDate or maxDate are given, the result will be enforced within these limits
+ *
+ * @param date CalendarDate instance
+ * @param amount how many days/months/years to add (can be a negative number)
+ * @param unit what to modify: "day", "month" or "year"
+ * @param minDate minimum date to enforce
+ * @param maxDate maximum date to enforce
+ */
+const modifyDateBy = (date: CalendarDate, amount: number, unit: string, minDate?: CalendarDate, maxDate?: CalendarDate) => {
+	const newDate = new CalendarDate(date);
+	if (unit === "day") {
+		newDate.setDate(date.getDate() + amount);
+	} else if (unit === "month") {
+		newDate.setMonth(date.getMonth() + amount);
+		const stillSameMonth = amount === -1 && newDate.getMonth() === date.getMonth(); // f.e. PageUp remained in the same month
+		const monthSkipped = amount === 1 && newDate.getMonth() - date.getMonth() > 1; // f.e. PageDown skipped a whole month
+		if (stillSameMonth || monthSkipped) { // Select the last day of the month in any of these 2 scenarios
+			newDate.setDate(0);
+		}
+	} else {
+		newDate.setYear(date.getYear() + amount);
+		if (newDate.getMonth() !== date.getMonth()) { // f.e. 29th Feb to next/prev year
+			newDate.setDate(0); // Select the last day of the month
+		}
+	}
+
+	if (minDate && newDate.valueOf() < minDate.valueOf()) {
+		return new CalendarDate(minDate);
+	}
+
+	if (maxDate && newDate.valueOf() > maxDate.valueOf()) {
+		return new CalendarDate(maxDate);
+	}
+
+	return newDate;
+};
+
+export default modifyDateBy;