@ui5/webcomponents-localization 1.7.3 → 1.7.4

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.7.4](https://github.com/SAP/ui5-webcomponents/compare/v1.7.3...v1.7.4) (2022-12-05)
+
+**Note:** Version bump only for package @ui5/webcomponents-localization
+
+
+
+
+
 ## [1.7.2](https://github.com/SAP/ui5-webcomponents/compare/v1.7.1...v1.7.2) (2022-11-07)
 
 **Note:** Version bump only for package @ui5/webcomponents-localization

package/global.d.ts

@@ -0,0 +1,105 @@
+// eslint-disable-next-line
+import "@ui5/webcomponents-base/global";
+import LocaleData from "sap/ui/core/LocaleData";
+
+export {};
+
+declare global {
+
+	module "*./sap/ui/core/LocaleData.js" {
+		const content: LocaleData;
+		export default content;
+	}
+
+
+	// sap/ui/core/format/DateFormat.js
+	// type DateFormatOptions = {
+	// 	calendarType: string
+	// 	strictParsing?: boolean,
+	// 	pattern?: string,
+	// 	style?: string,
+	// }
+
+	// type DateFormatInstance = {
+	// 	format: (JSDate: Date, bUTC: boolean) => string,
+	// 	parse: (value: string, bUTC: boolean, bStrict: boolean) => Date | Array<Date | null | undefined> | null,
+	// }
+
+	// type DateFormat = {
+	// 	getDateInstance: (options: DateFormatOptions) => DateFormatInstance,
+	// 	getInstance: (options: DateFormatOptions) => DateFormatInstance,
+	// }
+
+	// module "*./sap/ui/core/format/DateFormat.js" {
+	// 	const content: DateFormat;
+	// 	export default content;
+	// }
+
+	// sap/ui/core/LocaleData.js
+	// type Locale = {
+	// 	getScript: () => string,
+	// 	getRegion: () => string,
+	// 	getLanguage: () => string,
+	// }
+
+	// type LocaleDataInstance = {
+	// 	getPreferredCalendarType: () => string,
+	// }
+
+	// type LocaleData = {
+	// 	getInstance: (locale: Locale) => LocaleDataInstance,
+	// }
+
+	
+
+	// sap/ui/core/date/UniversalDate.js
+	// type UniversalDate = {
+	// 	new (time: number): UniversalDate;
+	// 	oDate: Date,
+	// 	sCalendarType: string,
+	// 	getInstance: (oDate: Date, sCalendarType: string) => 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,
+	// }
+
+	// module "*../sap/ui/core/date/UniversalDate.js" {
+	// 	const content: UniversalDate;
+	// 	export default content;
+	// }
+
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ui5/webcomponents-localization",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "description": "Localization for UI5 Web Components",
   "author": "SAP SE (https://www.sap.com)",
   "license": "Apache-2.0",
@@ -28,12 +28,12 @@
   },
   "devDependencies": {
     "@openui5/sap.ui.core": "1.101.0",
-    "@ui5/webcomponents-tools": "1.7.3",
+    "@ui5/webcomponents-tools": "1.7.4",
     "chromedriver": "104.0.0",
     "mkdirp": "^1.0.4",
     "resolve": "^1.20.0"
   },
   "dependencies": {
-    "@ui5/webcomponents-base": "1.7.3"
+    "@ui5/webcomponents-base": "1.7.4"
   }
 }

package/src/DateFormat.ts

@@ -0,0 +1,3 @@
+import DateFormat from "./sap/ui/core/format/DateFormat.js";
+
+export default DateFormat;

package/src/LocaleData.ts

@@ -0,0 +1,8 @@
+import LocaleDataOpenUI5 from "./sap/ui/core/LocaleData.js";
+import type Locale from "sap/ui/core/Locale";
+
+type LocaleData = typeof LocaleDataOpenUI5 & {
+	getInstance: (locale: Locale) => LocaleData,
+}
+
+export default LocaleData;

package/src/dates/CalendarDate.ts

@@ -0,0 +1,231 @@
+import UniversalDate from "../sap/ui/core/date/UniversalDate.js";
+
+class CalendarDate {
+	_oUDate!: Date | UniversalDate;
+
+	constructor(year?: number, month?: number, date?: number, calendarType?: string) { // eslint-disable-line
+		let aArgs = arguments, // eslint-disable-line
+			oJSDate: Date,
+			oNow: Date,
+			sCalendarType!: string;
+
+		switch (aArgs.length) {
+		case 0: // defaults to the current date
+			oNow = new Date();
+			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.");
+			}
+			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());
+
+			// Make this date really local. Now getters are safe.
+			oJSDate.setFullYear(oJSDate.getUTCFullYear(), oJSDate.getUTCMonth(), oJSDate.getUTCDate());
+			oJSDate.setHours(oJSDate.getUTCHours(), oJSDate.getUTCMinutes(), oJSDate.getUTCSeconds(), oJSDate.getUTCMilliseconds());
+
+			this._oUDate = createUniversalUTCDate(oJSDate, sCalendarType);
+			break;
+
+		case 3: // year, month, date
+		case 4: // year, month, date, sCalendarType
+			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] 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];
+			}
+			this._oUDate = createUniversalUTCDate(oJSDate, sCalendarType);
+			break;
+
+		default:
+			throw new Error(`${"Invalid arguments. Accepted arguments are: 1) oCalendarDate, (optional)calendarType"
+				+ "or 2) year, month, date, (optional) calendarType"}${aArgs as unknown as string}`);
+		}
+	}
+
+	getYear() {
+		return this._oUDate.getUTCFullYear();
+	}
+
+	setYear(year: number) {
+		checkNumericLike(year, `Invalid year: ${year}`);
+		this._oUDate.setUTCFullYear(year);
+		return this;
+	}
+
+	getMonth() {
+		return this._oUDate.getUTCMonth();
+	}
+
+	/**
+	 * 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}`);
+		if (date || date === 0) {
+			checkNumericLike(date, `Invalid date: ${date}`);
+			this._oUDate.setUTCMonth(month, date);
+		} else {
+			this._oUDate.setUTCMonth(month);
+		}
+		return this;
+	}
+
+	getDate() {
+		return this._oUDate.getUTCDate();
+	}
+
+	setDate(date: number) {
+		checkNumericLike(date, `Invalid date: ${date}`);
+		this._oUDate.setUTCDate(date);
+		return this;
+	}
+
+	getDay() {
+		return this._oUDate.getUTCDay();
+	}
+
+	getCalendarType() {
+		return (this._oUDate as UniversalDate).sCalendarType;
+	}
+
+	isBefore(oCalendarDate: CalendarDate) {
+		checkCalendarDate(oCalendarDate);
+		return this.valueOf() < oCalendarDate.valueOf();
+	}
+
+	isAfter(oCalendarDate: CalendarDate) {
+		checkCalendarDate(oCalendarDate);
+		return this.valueOf() > oCalendarDate.valueOf();
+	}
+
+	isSameOrBefore(oCalendarDate: CalendarDate) {
+		checkCalendarDate(oCalendarDate);
+		return this.valueOf() <= oCalendarDate.valueOf();
+	}
+
+	isSameOrAfter(oCalendarDate: CalendarDate) {
+		checkCalendarDate(oCalendarDate);
+		return this.valueOf() >= oCalendarDate.valueOf();
+	}
+
+	isSame(oCalendarDate: CalendarDate) {
+		checkCalendarDate(oCalendarDate);
+		return this.valueOf() === oCalendarDate.valueOf();
+	}
+
+	toLocalJSDate() {
+		// Use this._oUDate.getTime()(returns the same point of time regardless calendar type)  instead of
+		// this._oUDate's getters to avoid non-gregorian Year, Month and Date to be used to construct a Gregorian date
+		const oLocalDate = new Date(this._oUDate.getTime());
+
+		// Make this date really local. Now getters are safe.
+		oLocalDate.setFullYear(oLocalDate.getUTCFullYear(), oLocalDate.getUTCMonth(), oLocalDate.getUTCDate());
+		oLocalDate.setHours(0, 0, 0, 0);
+
+		return oLocalDate;
+	}
+
+	toUTCJSDate() {
+		// Use this._oUDate.getTime()(returns the same point of time regardless calendar type)  instead of
+		// this._oUDate's getters to avoid non-gregorian Year, Month and Date to be used to construct a Gregorian date
+		const oUTCDate = new Date(this._oUDate.getTime());
+		oUTCDate.setUTCHours(0, 0, 0, 0);
+
+		return oUTCDate;
+	}
+
+	toString() {
+		return `${(this._oUDate as UniversalDate).sCalendarType}: ${this.getYear()}/${this.getMonth() + 1}/${this.getDate()}`;
+	}
+
+	valueOf() {
+		return this._oUDate.getTime();
+	}
+
+	static fromLocalJSDate(oJSDate: Date, sCalendarType: string) {
+		// 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: 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 as unknown as string}].`);
+		}
+		return new CalendarDate(oJSDate.getFullYear(), oJSDate.getMonth(), oJSDate.getDate(), sCalendarType);
+	}
+
+	static fromTimestamp(iTimestamp: number, sCalendarType: string) {
+		const oCalDate = new CalendarDate(0, 0, 1);
+		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: Date, sCalendarType: string) {
+	if (sCalendarType) {
+		return UniversalDate.getInstance(createUTCDate(oDate), sCalendarType);
+	}
+	return new UniversalDate(createUTCDate(oDate).getTime());
+}
+
+/**
+ * Creates a JavaScript UTC Date corresponding to the given JavaScript Date.
+ * @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: Date) {
+	const oUTCDate = new Date(Date.UTC(0, 0, 1));
+
+	oUTCDate.setUTCFullYear(oDate.getFullYear(), oDate.getMonth(), oDate.getDate());
+
+	return oUTCDate;
+}
+
+function checkCalendarDate(oCalendarDate: CalendarDate) {
+	if (!(oCalendarDate instanceof CalendarDate)) {
+		throw new Error(`Invalid calendar date: [${oCalendarDate as unknown as string}]. Expected: sap.ui.unified.calendar.CalendarDate`);
+	}
+}
+
+/**
+ * Verifies the given value is numeric like, i.e. 3, "3" and throws an error if it is not.
+ * @param {any} value The value of any type to check. If null or undefined, this method throws an error.
+ * @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: any, message: string) {
+	if (value === undefined || value === Infinity || isNaN(value)) { // eslint-disable-line
+		throw message;
+	}
+}
+
+export default CalendarDate;

package/src/getCachedLocaleDataInstance.ts

@@ -0,0 +1,14 @@
+import LocaleData from "./LocaleData.js";
+import Locale from "sap/ui/core/Locale";
+
+const cache = new Map<Locale, LocaleData>();
+
+const getCachedLocaleDataInstance = (locale: Locale) => {
+	if (!cache.has(locale)) {
+		cache.set(locale, LocaleData.getInstance(locale));
+	}
+
+	return cache.get(locale)!;
+};
+
+export default getCachedLocaleDataInstance;