@stridge/noctis-intl 1.0.0-beta.0

package/dist/date/CalendarDate.js

@@ -0,0 +1,340 @@
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { add, addTime, addZoned, constrain, constrainTime, cycleDate, cycleTime, cycleZoned, set, setTime, setZoned, subtract, subtractTime, subtractZoned } from "./manipulation.js";
+import { compareDate, compareTime } from "./queries.js";
+import { toCalendarDateTime, toDate, toZoned, zonedToDate } from "./conversion.js";
+import { dateTimeToString, dateToString, timeToString, zonedDateTimeToString } from "./string.js";
+//#region src/date/CalendarDate.ts
+function shiftArgs(args) {
+	let calendar = typeof args[0] === "object" ? args.shift() : new GregorianCalendar();
+	let era;
+	if (typeof args[0] === "string") era = args.shift();
+	else {
+		let eras = calendar.getEras();
+		era = eras[eras.length - 1];
+	}
+	let year = args.shift();
+	let month = args.shift();
+	let day = args.shift();
+	return [
+		calendar,
+		era,
+		year,
+		month,
+		day
+	];
+}
+/** A CalendarDate represents a date without any time components in a specific calendar system. */
+var CalendarDate = class CalendarDate {
+	#type;
+	/** The calendar system associated with this date, e.g. Gregorian. */
+	calendar;
+	/** The calendar era for this date, e.g. "BC" or "AD". */
+	era;
+	/** The year of this date within the era. */
+	year;
+	/**
+	* The month number within the year. Note that some calendar systems such as Hebrew
+	* may have a variable number of months per year. Therefore, month numbers may not
+	* always correspond to the same month names in different years.
+	*/
+	month;
+	/** The day number within the month. */
+	day;
+	constructor(...args) {
+		let [calendar, era, year, month, day] = shiftArgs(args);
+		this.calendar = calendar;
+		this.era = era;
+		this.year = year;
+		this.month = month;
+		this.day = day;
+		constrain(this);
+	}
+	/** Returns a copy of this date. */
+	copy() {
+		if (this.era) return new CalendarDate(this.calendar, this.era, this.year, this.month, this.day);
+		else return new CalendarDate(this.calendar, this.year, this.month, this.day);
+	}
+	/** Returns a new `CalendarDate` with the given duration added to it. */
+	add(duration) {
+		return add(this, duration);
+	}
+	/** Returns a new `CalendarDate` with the given duration subtracted from it. */
+	subtract(duration) {
+		return subtract(this, duration);
+	}
+	/**
+	* Returns a new `CalendarDate` with the given fields set to the provided values. Other fields
+	* will be constrained accordingly.
+	*/
+	set(fields) {
+		return set(this, fields);
+	}
+	/**
+	* Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+	* When the resulting value reaches the limits of the field, it wraps around.
+	*/
+	cycle(field, amount, options) {
+		return cycleDate(this, field, amount, options);
+	}
+	/**
+	* Converts the date to a native JavaScript Date object, with the time set to midnight in the
+	* given time zone.
+	*/
+	toDate(timeZone) {
+		return toDate(this, timeZone);
+	}
+	/** Converts the date to an ISO 8601 formatted string. */
+	toString() {
+		return dateToString(this);
+	}
+	/**
+	* Compares this date with another. A negative result indicates that this date is before the given
+	* one, and a positive date indicates that it is after.
+	*/
+	compare(b) {
+		return compareDate(this, b);
+	}
+};
+/** A Time represents a clock time without any date components. */
+var Time = class Time {
+	#type;
+	/** The hour, numbered from 0 to 23. */
+	hour;
+	/** The minute in the hour. */
+	minute;
+	/** The second in the minute. */
+	second;
+	/** The millisecond in the second. */
+	millisecond;
+	constructor(hour = 0, minute = 0, second = 0, millisecond = 0) {
+		this.hour = hour;
+		this.minute = minute;
+		this.second = second;
+		this.millisecond = millisecond;
+		constrainTime(this);
+	}
+	/** Returns a copy of this time. */
+	copy() {
+		return new Time(this.hour, this.minute, this.second, this.millisecond);
+	}
+	/** Returns a new `Time` with the given duration added to it. */
+	add(duration) {
+		return addTime(this, duration);
+	}
+	/** Returns a new `Time` with the given duration subtracted from it. */
+	subtract(duration) {
+		return subtractTime(this, duration);
+	}
+	/**
+	* Returns a new `Time` with the given fields set to the provided values. Other fields will be
+	* constrained accordingly.
+	*/
+	set(fields) {
+		return setTime(this, fields);
+	}
+	/**
+	* Returns a new `Time` with the given field adjusted by a specified amount.
+	* When the resulting value reaches the limits of the field, it wraps around.
+	*/
+	cycle(field, amount, options) {
+		return cycleTime(this, field, amount, options);
+	}
+	/** Converts the time to an ISO 8601 formatted string. */
+	toString() {
+		return timeToString(this);
+	}
+	/**
+	* Compares this time with another. A negative result indicates that this time is before the given
+	* one, and a positive time indicates that it is after.
+	*/
+	compare(b) {
+		return compareTime(this, b);
+	}
+};
+/** A CalendarDateTime represents a date and time without a time zone, in a specific calendar system. */
+var CalendarDateTime = class CalendarDateTime {
+	#type;
+	/** The calendar system associated with this date, e.g. Gregorian. */
+	calendar;
+	/** The calendar era for this date, e.g. "BC" or "AD". */
+	era;
+	/** The year of this date within the era. */
+	year;
+	/**
+	* The month number within the year. Note that some calendar systems such as Hebrew
+	* may have a variable number of months per year. Therefore, month numbers may not
+	* always correspond to the same month names in different years.
+	*/
+	month;
+	/** The day number within the month. */
+	day;
+	/** The hour in the day, numbered from 0 to 23. */
+	hour;
+	/** The minute in the hour. */
+	minute;
+	/** The second in the minute. */
+	second;
+	/** The millisecond in the second. */
+	millisecond;
+	constructor(...args) {
+		let [calendar, era, year, month, day] = shiftArgs(args);
+		this.calendar = calendar;
+		this.era = era;
+		this.year = year;
+		this.month = month;
+		this.day = day;
+		this.hour = args.shift() || 0;
+		this.minute = args.shift() || 0;
+		this.second = args.shift() || 0;
+		this.millisecond = args.shift() || 0;
+		constrain(this);
+	}
+	/** Returns a copy of this date. */
+	copy() {
+		if (this.era) return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+		else return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+	}
+	/** Returns a new `CalendarDateTime` with the given duration added to it. */
+	add(duration) {
+		return add(this, duration);
+	}
+	/** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+	subtract(duration) {
+		return subtract(this, duration);
+	}
+	/**
+	* Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields
+	* will be constrained accordingly.
+	*/
+	set(fields) {
+		return set(setTime(this, fields), fields);
+	}
+	/**
+	* Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+	* When the resulting value reaches the limits of the field, it wraps around.
+	*/
+	cycle(field, amount, options) {
+		switch (field) {
+			case "era":
+			case "year":
+			case "month":
+			case "day": return cycleDate(this, field, amount, options);
+			default: return cycleTime(this, field, amount, options);
+		}
+	}
+	/** Converts the date to a native JavaScript Date object in the given time zone. */
+	toDate(timeZone, disambiguation) {
+		return toDate(this, timeZone, disambiguation);
+	}
+	/** Converts the date to an ISO 8601 formatted string. */
+	toString() {
+		return dateTimeToString(this);
+	}
+	/**
+	* Compares this date with another. A negative result indicates that this date is before the given
+	* one, and a positive date indicates that it is after.
+	*/
+	compare(b) {
+		let res = compareDate(this, b);
+		if (res === 0) return compareTime(this, toCalendarDateTime(b));
+		return res;
+	}
+};
+/** A ZonedDateTime represents a date and time in a specific time zone and calendar system. */
+var ZonedDateTime = class ZonedDateTime {
+	#type;
+	/** The calendar system associated with this date, e.g. Gregorian. */
+	calendar;
+	/** The calendar era for this date, e.g. "BC" or "AD". */
+	era;
+	/** The year of this date within the era. */
+	year;
+	/**
+	* The month number within the year. Note that some calendar systems such as Hebrew
+	* may have a variable number of months per year. Therefore, month numbers may not
+	* always correspond to the same month names in different years.
+	*/
+	month;
+	/** The day number within the month. */
+	day;
+	/** The hour in the day, numbered from 0 to 23. */
+	hour;
+	/** The minute in the hour. */
+	minute;
+	/** The second in the minute. */
+	second;
+	/** The millisecond in the second. */
+	millisecond;
+	/** The IANA time zone identifier that this date and time is represented in. */
+	timeZone;
+	/** The UTC offset for this time, in milliseconds. */
+	offset;
+	constructor(...args) {
+		let [calendar, era, year, month, day] = shiftArgs(args);
+		let timeZone = args.shift();
+		let offset = args.shift();
+		this.calendar = calendar;
+		this.era = era;
+		this.year = year;
+		this.month = month;
+		this.day = day;
+		this.timeZone = timeZone;
+		this.offset = offset;
+		this.hour = args.shift() || 0;
+		this.minute = args.shift() || 0;
+		this.second = args.shift() || 0;
+		this.millisecond = args.shift() || 0;
+		constrain(this);
+	}
+	/** Returns a copy of this date. */
+	copy() {
+		if (this.era) return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+		else return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+	}
+	/** Returns a new `ZonedDateTime` with the given duration added to it. */
+	add(duration) {
+		return addZoned(this, duration);
+	}
+	/** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
+	subtract(duration) {
+		return subtractZoned(this, duration);
+	}
+	/**
+	* Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields
+	* will be constrained accordingly.
+	*/
+	set(fields, disambiguation) {
+		return setZoned(this, fields, disambiguation);
+	}
+	/**
+	* Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
+	* When the resulting value reaches the limits of the field, it wraps around.
+	*/
+	cycle(field, amount, options) {
+		return cycleZoned(this, field, amount, options);
+	}
+	/** Converts the date to a native JavaScript Date object. */
+	toDate() {
+		return zonedToDate(this);
+	}
+	/**
+	* Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone
+	* identifier.
+	*/
+	toString() {
+		return zonedDateTimeToString(this);
+	}
+	/** Converts the date to an ISO 8601 formatted string in UTC. */
+	toAbsoluteString() {
+		return this.toDate().toISOString();
+	}
+	/**
+	* Compares this date with another. A negative result indicates that this date is before the given
+	* one, and a positive date indicates that it is after.
+	*/
+	compare(b) {
+		return this.toDate().getTime() - toZoned(b, this.timeZone).toDate().getTime();
+	}
+};
+//#endregion
+export { CalendarDate, CalendarDateTime, Time, ZonedDateTime };

package/dist/date/DateFormatter.d.ts

@@ -0,0 +1,26 @@
+//#region src/date/DateFormatter.d.ts
+interface DateRangeFormatPart extends Intl.DateTimeFormatPart {
+  source: "startRange" | "endRange" | "shared";
+}
+/** A wrapper around Intl.DateTimeFormat that fixes various browser bugs, and polyfills new features. */
+declare class DateFormatter implements Intl.DateTimeFormat {
+  private formatter;
+  private options;
+  private resolvedHourCycle;
+  constructor(locale: string, options?: Intl.DateTimeFormatOptions);
+  /**
+   * Formats a date as a string according to the locale and format options passed to the
+   * constructor.
+   */
+  format(value: Date): string;
+  /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+  formatToParts(value: Date): Intl.DateTimeFormatPart[];
+  /** Formats a date range as a string. */
+  formatRange(start: Date, end: Date): string;
+  /** Formats a date range as an array of parts. */
+  formatRangeToParts(start: Date, end: Date): DateRangeFormatPart[];
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions(): Intl.ResolvedDateTimeFormatOptions;
+}
+//#endregion
+export { DateFormatter };

package/dist/date/DateFormatter.js

@@ -0,0 +1,114 @@
+//#region src/date/DateFormatter.ts
+let formatterCache = /* @__PURE__ */ new Map();
+/** A wrapper around Intl.DateTimeFormat that fixes various browser bugs, and polyfills new features. */
+var DateFormatter = class {
+	formatter;
+	options;
+	resolvedHourCycle;
+	constructor(locale, options = {}) {
+		this.formatter = getCachedDateFormatter(locale, options);
+		this.options = options;
+	}
+	/**
+	* Formats a date as a string according to the locale and format options passed to the
+	* constructor.
+	*/
+	format(value) {
+		return this.formatter.format(value);
+	}
+	/** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+	formatToParts(value) {
+		return this.formatter.formatToParts(value);
+	}
+	/** Formats a date range as a string. */
+	formatRange(start, end) {
+		if (typeof this.formatter.formatRange === "function") return this.formatter.formatRange(start, end);
+		if (end < start) throw new RangeError("End date must be >= start date");
+		return `${this.formatter.format(start)} – ${this.formatter.format(end)}`;
+	}
+	/** Formats a date range as an array of parts. */
+	formatRangeToParts(start, end) {
+		if (typeof this.formatter.formatRangeToParts === "function") return this.formatter.formatRangeToParts(start, end);
+		if (end < start) throw new RangeError("End date must be >= start date");
+		let startParts = this.formatter.formatToParts(start);
+		let endParts = this.formatter.formatToParts(end);
+		return [
+			...startParts.map((p) => ({
+				...p,
+				source: "startRange"
+			})),
+			{
+				type: "literal",
+				value: " – ",
+				source: "shared"
+			},
+			...endParts.map((p) => ({
+				...p,
+				source: "endRange"
+			}))
+		];
+	}
+	/** Returns the resolved formatting options based on the values passed to the constructor. */
+	resolvedOptions() {
+		let resolvedOptions = this.formatter.resolvedOptions();
+		if (hasBuggyResolvedHourCycle()) {
+			if (!this.resolvedHourCycle) this.resolvedHourCycle = getResolvedHourCycle(resolvedOptions.locale, this.options);
+			resolvedOptions.hourCycle = this.resolvedHourCycle;
+			resolvedOptions.hour12 = this.resolvedHourCycle === "h11" || this.resolvedHourCycle === "h12";
+		}
+		if (resolvedOptions.calendar === "ethiopic-amete-alem") resolvedOptions.calendar = "ethioaa";
+		return resolvedOptions;
+	}
+};
+const hour12Preferences = {
+	true: { ja: "h11" },
+	false: {}
+};
+function getCachedDateFormatter(locale, options = {}) {
+	if (typeof options.hour12 === "boolean" && hasBuggyHour12Behavior()) {
+		options = { ...options };
+		let pref = hour12Preferences[String(options.hour12)][locale.split("-")[0]];
+		let defaultHourCycle = options.hour12 ? "h12" : "h23";
+		options.hourCycle = pref ?? defaultHourCycle;
+		delete options.hour12;
+	}
+	let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+	if (formatterCache.has(cacheKey)) return formatterCache.get(cacheKey);
+	let numberFormatter = new Intl.DateTimeFormat(locale, options);
+	formatterCache.set(cacheKey, numberFormatter);
+	return numberFormatter;
+}
+let _hasBuggyHour12Behavior = null;
+function hasBuggyHour12Behavior() {
+	if (_hasBuggyHour12Behavior == null) _hasBuggyHour12Behavior = new Intl.DateTimeFormat("en-US", {
+		hour: "numeric",
+		hour12: false
+	}).format(new Date(2020, 2, 3, 0)) === "24";
+	return _hasBuggyHour12Behavior;
+}
+let _hasBuggyResolvedHourCycle = null;
+function hasBuggyResolvedHourCycle() {
+	if (_hasBuggyResolvedHourCycle == null) _hasBuggyResolvedHourCycle = new Intl.DateTimeFormat("fr", {
+		hour: "numeric",
+		hour12: false
+	}).resolvedOptions().hourCycle === "h12";
+	return _hasBuggyResolvedHourCycle;
+}
+function getResolvedHourCycle(locale, options) {
+	if (!options.timeStyle && !options.hour) return;
+	locale = locale.replace(/(-u-)?-nu-[a-zA-Z0-9]+/, "");
+	locale += (locale.includes("-u-") ? "" : "-u") + "-nu-latn";
+	let formatter = getCachedDateFormatter(locale, {
+		...options,
+		timeZone: void 0
+	});
+	let min = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find((p) => p.type === "hour").value, 10);
+	let max = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find((p) => p.type === "hour").value, 10);
+	if (min === 0 && max === 23) return "h23";
+	if (min === 24 && max === 23) return "h24";
+	if (min === 0 && max === 11) return "h11";
+	if (min === 12 && max === 11) return "h12";
+	throw new Error("Unexpected hour cycle result");
+}
+//#endregion
+export { DateFormatter };

package/dist/date/calendars/BuddhistCalendar.d.ts

@@ -0,0 +1,20 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, CalendarIdentifier } from "../types.js";
+import { GregorianCalendar } from "./GregorianCalendar.js";
+
+//#region src/date/calendars/BuddhistCalendar.d.ts
+/**
+ * The Buddhist calendar is the same as the Gregorian calendar, but counts years
+ * starting from the birth of Buddha in 543 BC (Gregorian). It supports only one
+ * era, identified as 'BE'.
+ */
+declare class BuddhistCalendar extends GregorianCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getEras(): string[];
+  getDaysInMonth(date: AnyCalendarDate): number;
+  balanceDate(): void;
+}
+//#endregion
+export { BuddhistCalendar };

package/dist/date/calendars/BuddhistCalendar.js

@@ -0,0 +1,33 @@
+import { GregorianCalendar, fromExtendedYear, getExtendedYear } from "./GregorianCalendar.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/BuddhistCalendar.ts
+const BUDDHIST_ERA_START = -543;
+/**
+* The Buddhist calendar is the same as the Gregorian calendar, but counts years
+* starting from the birth of Buddha in 543 BC (Gregorian). It supports only one
+* era, identified as 'BE'.
+*/
+var BuddhistCalendar = class extends GregorianCalendar {
+	identifier = "buddhist";
+	fromJulianDay(jd) {
+		let gregorianDate = super.fromJulianDay(jd);
+		let year = getExtendedYear(gregorianDate.era, gregorianDate.year);
+		return new CalendarDate(this, year - BUDDHIST_ERA_START, gregorianDate.month, gregorianDate.day);
+	}
+	toJulianDay(date) {
+		return super.toJulianDay(toGregorian(date));
+	}
+	getEras() {
+		return ["BE"];
+	}
+	getDaysInMonth(date) {
+		return super.getDaysInMonth(toGregorian(date));
+	}
+	balanceDate() {}
+};
+function toGregorian(date) {
+	let [era, year] = fromExtendedYear(date.year + BUDDHIST_ERA_START);
+	return new CalendarDate(era, year, date.month, date.day);
+}
+//#endregion
+export { BuddhistCalendar };

package/dist/date/calendars/EthiopicCalendar.d.ts

@@ -0,0 +1,49 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, Calendar, CalendarIdentifier } from "../types.js";
+import { Mutable } from "../utils.js";
+
+//#region src/date/calendars/EthiopicCalendar.d.ts
+/**
+ * The Ethiopic calendar system is the official calendar used in Ethiopia.
+ * It includes 12 months of 30 days each, plus 5 or 6 intercalary days depending
+ * on whether it is a leap year. Two eras are supported: 'AA' and 'AM'.
+ */
+declare class EthiopicCalendar implements Calendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getMonthsInYear(): number;
+  getDaysInYear(date: AnyCalendarDate): number;
+  getMaximumMonthsInYear(): number;
+  getMaximumDaysInMonth(): number;
+  getYearsInEra(date: AnyCalendarDate): number;
+  getEras(): string[];
+}
+/**
+ * The Ethiopic (Amete Alem) calendar is the same as the modern Ethiopic calendar,
+ * except years were measured from a different epoch. Only one era is supported: 'AA'.
+ */
+declare class EthiopicAmeteAlemCalendar extends EthiopicCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  getEras(): string[];
+  getYearsInEra(): number;
+}
+/**
+ * The Coptic calendar is similar to the Ethiopic calendar.
+ * It includes 12 months of 30 days each, plus 5 or 6 intercalary days depending
+ * on whether it is a leap year. Two eras are supported: 'BCE' and 'CE'.
+ */
+declare class CopticCalendar extends EthiopicCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  isInverseEra(date: AnyCalendarDate): boolean;
+  balanceDate(date: Mutable<AnyCalendarDate>): void;
+  getEras(): string[];
+  getYearsInEra(date: AnyCalendarDate): number;
+}
+//#endregion
+export { CopticCalendar, EthiopicAmeteAlemCalendar, EthiopicCalendar };