@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773396165

package/development/core/datetime/temporal-date-adapter.js

@@ -1,164 +1,151 @@
-import { DateAdapter } from "./date-adapter.js";
 import { SbbLanguageController } from "../controllers.js";
-//#region src/elements/core/datetime/temporal-date-adapter.ts
-/**
-* Matches strings that have the form of a valid RFC 3339 string
-* (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date
-* because the regex will match strings and without of bounds month, date, etc.
-*/
-var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
-var TemporalDateAdapter = class extends DateAdapter {
-	/**
-	* @param cutoffYearOffset The threshold on whether a two-digit year
-	* should be treated as belonging to 2000 or 1900. e.g. with 15 (default)
-	* the current year plus 15 will be treated as belonging to 2000, and the rest to 1900.
-	* So e.g. with the current year 2025, 40 will be treated as 2040, while 41 will be treated as 1941.
-	*/
-	constructor(cutoffYearOffset) {
-		super(cutoffYearOffset);
-		if (typeof Temporal !== "object") throw new Error("Temporal is not available in the current environment. Please make sure to include the temporal polyfill.");
-	}
-	/** Gets the year of the input date. */
-	getYear(date) {
-		return date.year;
-	}
-	/** Gets the month of the input date. */
-	getMonth(date) {
-		return date.month;
-	}
-	/** Gets the day of the input date. */
-	getDate(date) {
-		return date.day;
-	}
-	/** Gets the day of the week of the input date. */
-	getDayOfWeek(date) {
-		return date.dayOfWeek % 7;
-	}
-	/** Gets the date in the local format. */
-	getAccessibilityFormatDate(date) {
-		return this.deserialize(date).toLocaleString(SbbLanguageController.current, {
-			year: "numeric",
-			month: "long",
-			day: "numeric"
-		});
-	}
-	/**
-	* Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.
-	* @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,
-	* E.g., with January in en-gb: `long` returns "January", `short` returns "Jan", `narrow` returns "J".
-	*/
-	getMonthNames(style) {
-		const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { month: style });
-		return this._range(12, (i) => formatter.format(Temporal.PlainDate.from({
-			year: 2017,
-			month: i + 1,
-			day: 1
-		})));
-	}
-	/** Creates a string array with length = 31, filled with the days in a month, starting from 1. */
-	getDateNames() {
-		const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { day: "numeric" });
-		return this._range(31, (i) => formatter.format(Temporal.PlainDate.from({
-			year: 2017,
-			month: 1,
-			day: i + 1
-		})));
-	}
-	/**
-	* Creates a string array with length = 7, filled with the name of the days in a week starting from Sunday, in the document language.
-	* @param style See `weekday` in `DateTimeFormatOptions` - 'long' for full name, 'short' for short name, 'narrow' for single letter;
-	* E.g., with Monday in en-gb: `long` returns "Monday", `short` returns "Mon", `narrow` returns "M".
-	*/
-	getDayOfWeekNames(style) {
-		const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { weekday: style });
-		return this._range(7, (i) => formatter.format(Temporal.PlainDate.from({
-			year: 2017,
-			month: 1,
-			day: i + 1
-		})));
-	}
-	/** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */
-	getFirstDayOfWeek() {
-		return 1;
-	}
-	/** Calculates the number of days in a month given the year and the month. */
-	getNumDaysInMonth(date) {
-		return date.daysInMonth;
-	}
-	/** Creates today's date. */
-	today() {
-		return Temporal.Now.plainDateISO();
-	}
-	/** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */
-	createDate(year, month, day) {
-		if (month < 1 || month > 12) throw Error(`Invalid month "${month}". Month has to be between 1 and 12.`);
-		else if (day < 1) throw Error(`Invalid day "${day}". Day has to be greater than 0.`);
-		try {
-			return Temporal.PlainDate.from({
-				year,
-				month,
-				day
-			}, { overflow: "reject" });
-		} catch {
-			throw Error(`Invalid date "${day}" for month with index "${month}".`);
-		}
-	}
-	/** Checks whether the given `obj` is a Temporal.PlainDate. */
-	isDateInstance(obj) {
-		return obj instanceof Temporal.PlainDate;
-	}
-	/** Checks whether the given `date` is a valid Temporal.PlainDate. */
-	isValid(date) {
-		return this.isDateInstance(date);
-	}
-	/** Creates a new date by cloning the given one. */
-	clone(date) {
-		return Temporal.PlainDate.from(date);
-	}
-	/**
-	* Creates a new date adding the number of provided `years` to the provided `date`.
-	* @param date The starting date.
-	* @param years The number of years to add.
-	*/
-	addCalendarYears(date, years) {
-		return date.add({ years });
-	}
-	/**
-	* Creates a new date adding the number of provided `months` to the provided `date`.
-	* If the calculated month has fewer days than the original one, the date is set to the last day of the month.
-	* E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).
-	*/
-	addCalendarMonths(date, months) {
-		return date.add({ months });
-	}
-	/** Creates a new date by adding the number of provided `days` to the provided `date`. */
-	addCalendarDays(date, days) {
-		return date.add({ days });
-	}
-	/** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */
-	deserialize(date) {
-		if (typeof date === "string") {
-			if (!date) return null;
-			else if (ISO_8601_REGEX.test(date)) return this.getValidDateOrNull(Temporal.PlainDate.from(date.split("T")[0]));
-		}
-		return super.deserialize(date);
-	}
-	invalid() {
-		return null;
-	}
-	toIso8601(date) {
-		return date.toJSON();
-	}
-	/**
-	* Creates an array with the given length and fills it by mapping with the provided function.
-	* @param length The length of the array to be created.
-	* @param valueFunction The function of array's index used to fill the array.
-	*/
-	_range(length, valueFunction) {
-		return Array.from({ length }).map((_, i) => valueFunction(i));
-	}
+import { DateAdapter } from "./date-adapter.js";
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+class TemporalDateAdapter extends DateAdapter {
+  /**
+   * @param cutoffYearOffset The threshold on whether a two-digit year
+   * should be treated as belonging to 2000 or 1900. e.g. with 15 (default)
+   * the current year plus 15 will be treated as belonging to 2000, and the rest to 1900.
+   * So e.g. with the current year 2025, 40 will be treated as 2040, while 41 will be treated as 1941.
+   */
+  constructor(cutoffYearOffset) {
+    super(cutoffYearOffset);
+    if (typeof Temporal !== "object") {
+      throw new Error("Temporal is not available in the current environment. Please make sure to include the temporal polyfill.");
+    }
+  }
+  /** Gets the year of the input date. */
+  getYear(date) {
+    return date.year;
+  }
+  /** Gets the month of the input date. */
+  getMonth(date) {
+    return date.month;
+  }
+  /** Gets the day of the input date. */
+  getDate(date) {
+    return date.day;
+  }
+  /** Gets the day of the week of the input date. */
+  getDayOfWeek(date) {
+    return date.dayOfWeek % 7;
+  }
+  /** Gets the date in the local format. */
+  getAccessibilityFormatDate(date) {
+    const options = {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    };
+    return this.deserialize(date).toLocaleString(SbbLanguageController.current, options);
+  }
+  /**
+   * Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.
+   * @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,
+   * E.g., with January in en-gb: `long` returns "January", `short` returns "Jan", `narrow` returns "J".
+   */
+  getMonthNames(style) {
+    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { month: style });
+    return this._range(12, (i) => formatter.format(Temporal.PlainDate.from({ year: 2017, month: i + 1, day: 1 })));
+  }
+  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */
+  getDateNames() {
+    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { day: "numeric" });
+    return this._range(31, (i) => formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })));
+  }
+  /**
+   * Creates a string array with length = 7, filled with the name of the days in a week starting from Sunday, in the document language.
+   * @param style See `weekday` in `DateTimeFormatOptions` - 'long' for full name, 'short' for short name, 'narrow' for single letter;
+   * E.g., with Monday in en-gb: `long` returns "Monday", `short` returns "Mon", `narrow` returns "M".
+   */
+  getDayOfWeekNames(style) {
+    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { weekday: style });
+    return this._range(7, (i) => formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })));
+  }
+  /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */
+  getFirstDayOfWeek() {
+    return 1;
+  }
+  /** Calculates the number of days in a month given the year and the month. */
+  getNumDaysInMonth(date) {
+    return date.daysInMonth;
+  }
+  /** Creates today's date. */
+  today() {
+    return Temporal.Now.plainDateISO();
+  }
+  /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */
+  createDate(year, month, day) {
+    if (month < 1 || month > 12) {
+      throw Error(`Invalid month "${month}". Month has to be between 1 and 12.`);
+    } else if (day < 1) {
+      throw Error(`Invalid day "${day}". Day has to be greater than 0.`);
+    }
+    try {
+      return Temporal.PlainDate.from({ year, month, day }, { overflow: "reject" });
+    } catch {
+      throw Error(`Invalid date "${day}" for month with index "${month}".`);
+    }
+  }
+  /** Checks whether the given `obj` is a Temporal.PlainDate. */
+  isDateInstance(obj) {
+    return obj instanceof Temporal.PlainDate;
+  }
+  /** Checks whether the given `date` is a valid Temporal.PlainDate. */
+  isValid(date) {
+    return this.isDateInstance(date);
+  }
+  /** Creates a new date by cloning the given one. */
+  clone(date) {
+    return Temporal.PlainDate.from(date);
+  }
+  /**
+   * Creates a new date adding the number of provided `years` to the provided `date`.
+   * @param date The starting date.
+   * @param years The number of years to add.
+   */
+  addCalendarYears(date, years) {
+    return date.add({ years });
+  }
+  /**
+   * Creates a new date adding the number of provided `months` to the provided `date`.
+   * If the calculated month has fewer days than the original one, the date is set to the last day of the month.
+   * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).
+   */
+  addCalendarMonths(date, months) {
+    return date.add({ months });
+  }
+  /** Creates a new date by adding the number of provided `days` to the provided `date`. */
+  addCalendarDays(date, days) {
+    return date.add({ days });
+  }
+  /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */
+  deserialize(date) {
+    if (typeof date === "string") {
+      if (!date) {
+        return null;
+      } else if (ISO_8601_REGEX.test(date)) {
+        return this.getValidDateOrNull(Temporal.PlainDate.from(date.split("T")[0]));
+      }
+    }
+    return super.deserialize(date);
+  }
+  invalid() {
+    return null;
+  }
+  toIso8601(date) {
+    return date.toJSON();
+  }
+  /**
+   * Creates an array with the given length and fills it by mapping with the provided function.
+   * @param length The length of the array to be created.
+   * @param valueFunction The function of array's index used to fill the array.
+   */
+  _range(length, valueFunction) {
+    return Array.from({ length }).map((_, i) => valueFunction(i));
+  }
+}
+export {
+  TemporalDateAdapter
 };
-//#endregion
-export { TemporalDateAdapter };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"temporal-date-adapter.js","names":[],"sources":["../../../../../src/elements/core/datetime/temporal-date-adapter.ts"],"sourcesContent":["/// <reference types=\"temporal-polyfill/global\" />\n\nimport { SbbLanguageController } from '../controllers.ts';\n\nimport { DateAdapter } from './date-adapter.ts';\n\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings and without of bounds month, date, etc.\n */\nconst ISO_8601_REGEX =\n  /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n\nexport class TemporalDateAdapter extends DateAdapter<Temporal.PlainDate> {\n  /**\n   * @param cutoffYearOffset The threshold on whether a two-digit year\n   * should be treated as belonging to 2000 or 1900. e.g. with 15 (default)\n   * the current year plus 15 will be treated as belonging to 2000, and the rest to 1900.\n   * So e.g. with the current year 2025, 40 will be treated as 2040, while 41 will be treated as 1941.\n   */\n  public constructor(cutoffYearOffset?: number) {\n    super(cutoffYearOffset);\n    if (typeof Temporal !== 'object') {\n      throw new Error(\n        'Temporal is not available in the current environment. Please make sure to include the temporal polyfill.',\n      );\n    }\n  }\n\n  /** Gets the year of the input date. */\n  public getYear(date: Temporal.PlainDate): number {\n    return date.year;\n  }\n\n  /** Gets the month of the input date. */\n  public getMonth(date: Temporal.PlainDate): number {\n    return date.month;\n  }\n\n  /** Gets the day of the input date. */\n  public getDate(date: Temporal.PlainDate): number {\n    return date.day;\n  }\n\n  /** Gets the day of the week of the input date. */\n  public getDayOfWeek(date: Temporal.PlainDate): number {\n    // Our expectation is 0 = Sunday but Temporal.PlainDate.dayOfWeek returns 7 = Sunday\n    // TODO: Remove this with a future release.\n    return date.dayOfWeek % 7;\n  }\n\n  /** Gets the date in the local format. */\n  public getAccessibilityFormatDate(date: Temporal.PlainDate | string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: 'long',\n      day: 'numeric',\n    };\n    return this.deserialize(date)!.toLocaleString(SbbLanguageController.current, options);\n  }\n\n  /**\n   * Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.\n   * @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,\n   * E.g., with January in en-gb: `long` returns \"January\", `short` returns \"Jan\", `narrow` returns \"J\".\n   */\n  public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { month: style });\n    return this._range(12, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: i + 1, day: 1 })),\n    );\n  }\n\n  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */\n  public getDateNames(): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { day: 'numeric' });\n    return this._range(31, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })),\n    );\n  }\n\n  /**\n   * Creates a string array with length = 7, filled with the name of the days in a week starting from Sunday, in the document language.\n   * @param style See `weekday` in `DateTimeFormatOptions` - 'long' for full name, 'short' for short name, 'narrow' for single letter;\n   * E.g., with Monday in en-gb: `long` returns \"Monday\", `short` returns \"Mon\", `narrow` returns \"M\".\n   */\n  public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { weekday: style });\n    return this._range(7, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })),\n    );\n  }\n\n  /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */\n  public getFirstDayOfWeek(): number {\n    return 1;\n  }\n\n  /** Calculates the number of days in a month given the year and the month. */\n  public getNumDaysInMonth(date: Temporal.PlainDate): number {\n    return date.daysInMonth;\n  }\n\n  /** Creates today's date. */\n  public today(): Temporal.PlainDate {\n    return Temporal.Now.plainDateISO();\n  }\n\n  /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */\n  public createDate(year: number, month: number, day: number): Temporal.PlainDate {\n    // Check for invalid month and date (except upper bound on date which we have to check after creating the Temporal.PlainDate).\n    if (month < 1 || month > 12) {\n      throw Error(`Invalid month \"${month}\". Month has to be between 1 and 12.`);\n    } else if (day < 1) {\n      throw Error(`Invalid day \"${day}\". Day has to be greater than 0.`);\n    }\n\n    try {\n      return Temporal.PlainDate.from({ year, month, day: day }, { overflow: 'reject' });\n    } catch {\n      throw Error(`Invalid date \"${day}\" for month with index \"${month}\".`);\n    }\n  }\n\n  /** Checks whether the given `obj` is a Temporal.PlainDate. */\n  public isDateInstance(obj: any): boolean {\n    return obj instanceof Temporal.PlainDate;\n  }\n\n  /** Checks whether the given `date` is a valid Temporal.PlainDate. */\n  public isValid(date: Temporal.PlainDate | null | undefined): date is Temporal.PlainDate {\n    return this.isDateInstance(date);\n  }\n\n  /** Creates a new date by cloning the given one. */\n  public clone(date: Temporal.PlainDate): Temporal.PlainDate {\n    return Temporal.PlainDate.from(date);\n  }\n\n  /**\n   * Creates a new date adding the number of provided `years` to the provided `date`.\n   * @param date The starting date.\n   * @param years The number of years to add.\n   */\n  public addCalendarYears(date: Temporal.PlainDate, years: number): Temporal.PlainDate {\n    return date.add({ years });\n  }\n\n  /**\n   * Creates a new date adding the number of provided `months` to the provided `date`.\n   * If the calculated month has fewer days than the original one, the date is set to the last day of the month.\n   * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).\n   */\n  public addCalendarMonths(date: Temporal.PlainDate, months: number): Temporal.PlainDate {\n    return date.add({ months });\n  }\n\n  /** Creates a new date by adding the number of provided `days` to the provided `date`. */\n  public addCalendarDays(date: Temporal.PlainDate, days: number): Temporal.PlainDate {\n    return date.add({ days });\n  }\n\n  /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */\n  public override deserialize(\n    date: Temporal.PlainDate | string | null | undefined,\n  ): Temporal.PlainDate | null {\n    if (typeof date === 'string') {\n      if (!date) {\n        return null;\n      } else if (ISO_8601_REGEX.test(date)) {\n        // `Temporal.PlainDate.from` only accepts ISO 8601 date strings without time components.\n        return this.getValidDateOrNull(Temporal.PlainDate.from(date.split('T')[0]));\n      }\n    }\n    return super.deserialize(date);\n  }\n\n  public override invalid(): Temporal.PlainDate {\n    // It is not possible to create an invalid Temporal.PlainDate, so we return null.\n    return null!;\n  }\n\n  public override toIso8601(date: Temporal.PlainDate): string {\n    return date.toJSON();\n  }\n\n  /**\n   * Creates an array with the given length and fills it by mapping with the provided function.\n   * @param length The length of the array to be created.\n   * @param valueFunction The function of array's index used to fill the array.\n   */\n  private _range<T>(length: number, valueFunction: (index: number) => T): T[] {\n    return Array.from({ length }).map((_, i) => valueFunction(i));\n  }\n}\n"],"mappings":";;;;;;;;AAWA,IAAM,iBACJ;AAEF,IAAa,sBAAb,cAAyC,YAA+B;;;;;;;CAOtE,YAAmB,kBAAyB;AAC1C,QAAM,iBAAiB;AACvB,MAAI,OAAO,aAAa,SACtB,OAAM,IAAI,MACR,2GACD;;;CAKE,QAAQ,MAAwB;AACrC,SAAO,KAAK;;;CAIP,SAAS,MAAwB;AACtC,SAAO,KAAK;;;CAIP,QAAQ,MAAwB;AACrC,SAAO,KAAK;;;CAIP,aAAa,MAAwB;AAG1C,SAAO,KAAK,YAAY;;;CAInB,2BAA2B,MAAiC;AAMjE,SAAO,KAAK,YAAY,KAAM,CAAC,eAAe,sBAAsB,SALxB;GAC1C,MAAM;GACN,OAAO;GACP,KAAK;GACN,CACoF;;;;;;;CAQhF,cAAc,OAAkC;EACrD,MAAM,YAAY,IAAI,KAAK,eAAe,sBAAsB,SAAS,EAAE,OAAO,OAAO,CAAC;AAC1F,SAAO,KAAK,OAAO,KAAK,MACtB,UAAU,OAAO,SAAS,UAAU,KAAK;GAAE,MAAM;GAAM,OAAO,IAAI;GAAG,KAAK;GAAG,CAAC,CAAC,CAChF;;;CAII,eAAY;EACjB,MAAM,YAAY,IAAI,KAAK,eAAe,sBAAsB,SAAS,EAAE,KAAK,WAAW,CAAC;AAC5F,SAAO,KAAK,OAAO,KAAK,MACtB,UAAU,OAAO,SAAS,UAAU,KAAK;GAAE,MAAM;GAAM,OAAO;GAAG,KAAK,IAAI;GAAG,CAAC,CAAC,CAChF;;;;;;;CAQI,kBAAkB,OAAkC;EACzD,MAAM,YAAY,IAAI,KAAK,eAAe,sBAAsB,SAAS,EAAE,SAAS,OAAO,CAAC;AAC5F,SAAO,KAAK,OAAO,IAAI,MACrB,UAAU,OAAO,SAAS,UAAU,KAAK;GAAE,MAAM;GAAM,OAAO;GAAG,KAAK,IAAI;GAAG,CAAC,CAAC,CAChF;;;CAII,oBAAiB;AACtB,SAAO;;;CAIF,kBAAkB,MAAwB;AAC/C,SAAO,KAAK;;;CAIP,QAAK;AACV,SAAO,SAAS,IAAI,cAAc;;;CAI7B,WAAW,MAAc,OAAe,KAAW;AAExD,MAAI,QAAQ,KAAK,QAAQ,GACvB,OAAM,MAAM,kBAAkB,MAAK,sCAAuC;WACjE,MAAM,EACf,OAAM,MAAM,gBAAgB,IAAG,kCAAmC;AAGpE,MAAI;AACF,UAAO,SAAS,UAAU,KAAK;IAAE;IAAM;IAAY;IAAK,EAAE,EAAE,UAAU,UAAU,CAAC;UAC3E;AACN,SAAM,MAAM,iBAAiB,IAAG,0BAA2B,MAAK,IAAK;;;;CAKlE,eAAe,KAAQ;AAC5B,SAAO,eAAe,SAAS;;;CAI1B,QAAQ,MAA2C;AACxD,SAAO,KAAK,eAAe,KAAK;;;CAI3B,MAAM,MAAwB;AACnC,SAAO,SAAS,UAAU,KAAK,KAAK;;;;;;;CAQ/B,iBAAiB,MAA0B,OAAa;AAC7D,SAAO,KAAK,IAAI,EAAE,OAAO,CAAC;;;;;;;CAQrB,kBAAkB,MAA0B,QAAc;AAC/D,SAAO,KAAK,IAAI,EAAE,QAAQ,CAAC;;;CAItB,gBAAgB,MAA0B,MAAY;AAC3D,SAAO,KAAK,IAAI,EAAE,MAAM,CAAC;;;CAIX,YACd,MAAoD;AAEpD,MAAI,OAAO,SAAS;OACd,CAAC,KACH,QAAO;YACE,eAAe,KAAK,KAAK,CAElC,QAAO,KAAK,mBAAmB,SAAS,UAAU,KAAK,KAAK,MAAM,IAAI,CAAC,GAAG,CAAC;;AAG/E,SAAO,MAAM,YAAY,KAAK;;CAGhB,UAAO;AAErB,SAAO;;CAGO,UAAU,MAAwB;AAChD,SAAO,KAAK,QAAQ;;;;;;;CAQd,OAAU,QAAgB,eAAmC;AACnE,SAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,CAAC,KAAK,GAAG,MAAM,cAAc,EAAE,CAAC"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"temporal-date-adapter.js","sources":["../../../../../src/elements/core/datetime/temporal-date-adapter.ts"],"sourcesContent":["/// <reference types=\"temporal-polyfill/global\" />\n\nimport { SbbLanguageController } from '../controllers.ts';\n\nimport { DateAdapter } from './date-adapter.ts';\n\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings and without of bounds month, date, etc.\n */\nconst ISO_8601_REGEX =\n  /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n\nexport class TemporalDateAdapter extends DateAdapter<Temporal.PlainDate> {\n  /**\n   * @param cutoffYearOffset The threshold on whether a two-digit year\n   * should be treated as belonging to 2000 or 1900. e.g. with 15 (default)\n   * the current year plus 15 will be treated as belonging to 2000, and the rest to 1900.\n   * So e.g. with the current year 2025, 40 will be treated as 2040, while 41 will be treated as 1941.\n   */\n  public constructor(cutoffYearOffset?: number) {\n    super(cutoffYearOffset);\n    if (typeof Temporal !== 'object') {\n      throw new Error(\n        'Temporal is not available in the current environment. Please make sure to include the temporal polyfill.',\n      );\n    }\n  }\n\n  /** Gets the year of the input date. */\n  public getYear(date: Temporal.PlainDate): number {\n    return date.year;\n  }\n\n  /** Gets the month of the input date. */\n  public getMonth(date: Temporal.PlainDate): number {\n    return date.month;\n  }\n\n  /** Gets the day of the input date. */\n  public getDate(date: Temporal.PlainDate): number {\n    return date.day;\n  }\n\n  /** Gets the day of the week of the input date. */\n  public getDayOfWeek(date: Temporal.PlainDate): number {\n    // Our expectation is 0 = Sunday but Temporal.PlainDate.dayOfWeek returns 7 = Sunday\n    // TODO: Remove this with a future release.\n    return date.dayOfWeek % 7;\n  }\n\n  /** Gets the date in the local format. */\n  public getAccessibilityFormatDate(date: Temporal.PlainDate | string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: 'long',\n      day: 'numeric',\n    };\n    return this.deserialize(date)!.toLocaleString(SbbLanguageController.current, options);\n  }\n\n  /**\n   * Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.\n   * @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,\n   * E.g., with January in en-gb: `long` returns \"January\", `short` returns \"Jan\", `narrow` returns \"J\".\n   */\n  public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { month: style });\n    return this._range(12, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: i + 1, day: 1 })),\n    );\n  }\n\n  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */\n  public getDateNames(): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { day: 'numeric' });\n    return this._range(31, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })),\n    );\n  }\n\n  /**\n   * Creates a string array with length = 7, filled with the name of the days in a week starting from Sunday, in the document language.\n   * @param style See `weekday` in `DateTimeFormatOptions` - 'long' for full name, 'short' for short name, 'narrow' for single letter;\n   * E.g., with Monday in en-gb: `long` returns \"Monday\", `short` returns \"Mon\", `narrow` returns \"M\".\n   */\n  public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { weekday: style });\n    return this._range(7, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })),\n    );\n  }\n\n  /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */\n  public getFirstDayOfWeek(): number {\n    return 1;\n  }\n\n  /** Calculates the number of days in a month given the year and the month. */\n  public getNumDaysInMonth(date: Temporal.PlainDate): number {\n    return date.daysInMonth;\n  }\n\n  /** Creates today's date. */\n  public today(): Temporal.PlainDate {\n    return Temporal.Now.plainDateISO();\n  }\n\n  /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */\n  public createDate(year: number, month: number, day: number): Temporal.PlainDate {\n    // Check for invalid month and date (except upper bound on date which we have to check after creating the Temporal.PlainDate).\n    if (month < 1 || month > 12) {\n      throw Error(`Invalid month \"${month}\". Month has to be between 1 and 12.`);\n    } else if (day < 1) {\n      throw Error(`Invalid day \"${day}\". Day has to be greater than 0.`);\n    }\n\n    try {\n      return Temporal.PlainDate.from({ year, month, day: day }, { overflow: 'reject' });\n    } catch {\n      throw Error(`Invalid date \"${day}\" for month with index \"${month}\".`);\n    }\n  }\n\n  /** Checks whether the given `obj` is a Temporal.PlainDate. */\n  public isDateInstance(obj: any): boolean {\n    return obj instanceof Temporal.PlainDate;\n  }\n\n  /** Checks whether the given `date` is a valid Temporal.PlainDate. */\n  public isValid(date: Temporal.PlainDate | null | undefined): date is Temporal.PlainDate {\n    return this.isDateInstance(date);\n  }\n\n  /** Creates a new date by cloning the given one. */\n  public clone(date: Temporal.PlainDate): Temporal.PlainDate {\n    return Temporal.PlainDate.from(date);\n  }\n\n  /**\n   * Creates a new date adding the number of provided `years` to the provided `date`.\n   * @param date The starting date.\n   * @param years The number of years to add.\n   */\n  public addCalendarYears(date: Temporal.PlainDate, years: number): Temporal.PlainDate {\n    return date.add({ years });\n  }\n\n  /**\n   * Creates a new date adding the number of provided `months` to the provided `date`.\n   * If the calculated month has fewer days than the original one, the date is set to the last day of the month.\n   * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).\n   */\n  public addCalendarMonths(date: Temporal.PlainDate, months: number): Temporal.PlainDate {\n    return date.add({ months });\n  }\n\n  /** Creates a new date by adding the number of provided `days` to the provided `date`. */\n  public addCalendarDays(date: Temporal.PlainDate, days: number): Temporal.PlainDate {\n    return date.add({ days });\n  }\n\n  /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */\n  public override deserialize(\n    date: Temporal.PlainDate | string | null | undefined,\n  ): Temporal.PlainDate | null {\n    if (typeof date === 'string') {\n      if (!date) {\n        return null;\n      } else if (ISO_8601_REGEX.test(date)) {\n        // `Temporal.PlainDate.from` only accepts ISO 8601 date strings without time components.\n        return this.getValidDateOrNull(Temporal.PlainDate.from(date.split('T')[0]));\n      }\n    }\n    return super.deserialize(date);\n  }\n\n  public override invalid(): Temporal.PlainDate {\n    // It is not possible to create an invalid Temporal.PlainDate, so we return null.\n    return null!;\n  }\n\n  public override toIso8601(date: Temporal.PlainDate): string {\n    return date.toJSON();\n  }\n\n  /**\n   * Creates an array with the given length and fills it by mapping with the provided function.\n   * @param length The length of the array to be created.\n   * @param valueFunction The function of array's index used to fill the array.\n   */\n  private _range<T>(length: number, valueFunction: (index: number) => T): T[] {\n    return Array.from({ length }).map((_, i) => valueFunction(i));\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/core/datetime.js

@@ -1,4 +1,17 @@
 import { DAYS_PER_ROW, DateAdapter, FORMAT_DATE, ISO8601_FORMAT_DATE, MONTHS_PER_PAGE, MONTHS_PER_ROW, YEARS_PER_PAGE, YEARS_PER_ROW } from "./datetime/date-adapter.js";
 import { NativeDateAdapter, defaultDateAdapter } from "./datetime/native-date-adapter.js";
 import { TemporalDateAdapter } from "./datetime/temporal-date-adapter.js";
-export { DAYS_PER_ROW, DateAdapter, FORMAT_DATE, ISO8601_FORMAT_DATE, MONTHS_PER_PAGE, MONTHS_PER_ROW, NativeDateAdapter, TemporalDateAdapter, YEARS_PER_PAGE, YEARS_PER_ROW, defaultDateAdapter };
+export {
+  DAYS_PER_ROW,
+  DateAdapter,
+  FORMAT_DATE,
+  ISO8601_FORMAT_DATE,
+  MONTHS_PER_PAGE,
+  MONTHS_PER_ROW,
+  NativeDateAdapter,
+  TemporalDateAdapter,
+  YEARS_PER_PAGE,
+  YEARS_PER_ROW,
+  defaultDateAdapter
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWUuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7In0=

package/development/core/decorators/base.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/development/core/decorators/force-type.js

@@ -1,25 +1,28 @@
-//#region src/elements/core/decorators/force-type.ts
-/**
-* Decorator that forces the value of a property or getter/setter
-* to the defined type.
-*/
-var forceType = (convert) => {
-	return (target, context) => {
-		const { kind, metadata, name } = context;
-		const type = globalThis.litPropertyMetadata.get(metadata)?.get(name)?.type ?? String;
-		convert ??= type;
-		if (convert === String) convert = (v) => v == null ? "" : String(v);
-		else if (convert === Number) convert = (v) => v == null ? NaN : Number(v);
-		if (kind === "accessor") return { set(value) {
-			target.set.call(this, convert(value));
-		} };
-		else if (kind === "setter") return function(value) {
-			target.call(this, convert(value));
-		};
-		throw new Error(`Unsupported decorator location: ${kind}`);
-	};
+const forceType = (convert) => {
+  return (target, context) => {
+    const { kind, metadata, name } = context;
+    const type = globalThis.litPropertyMetadata.get(metadata)?.get(name)?.type ?? String;
+    convert ??= type;
+    if (convert === String) {
+      convert = (v) => v == null ? "" : String(v);
+    } else if (convert === Number) {
+      convert = (v) => v == null ? NaN : Number(v);
+    }
+    if (kind === "accessor") {
+      return {
+        set(value) {
+          target.set.call(this, convert(value));
+        }
+      };
+    } else if (kind === "setter") {
+      return function(value) {
+        target.call(this, convert(value));
+      };
+    }
+    throw new Error(`Unsupported decorator location: ${kind}`);
+  };
 };
-//#endregion
-export { forceType };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export {
+  forceType
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/decorators/get-override.js

@@ -1,18 +1,18 @@
-//#region src/elements/core/decorators/get-override.ts
-/**
-* Decorator that overrides the underlying getter of the accessor.
-*/
-var getOverride = (callback) => {
-	return (target, context) => {
-		const { kind } = context;
-		if (kind === "accessor") return { get() {
-			const innerValue = target.get.call(this);
-			return callback(this, innerValue);
-		} };
-		throw new Error(`Unsupported decorator location: ${kind}`);
-	};
+const getOverride = (callback) => {
+  return (target, context) => {
+    const { kind } = context;
+    if (kind === "accessor") {
+      return {
+        get() {
+          const innerValue = target.get.call(this);
+          return callback(this, innerValue);
+        }
+      };
+    }
+    throw new Error(`Unsupported decorator location: ${kind}`);
+  };
 };
-//#endregion
-export { getOverride };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW92ZXJyaWRlLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jb3JlL2RlY29yYXRvcnMvZ2V0LW92ZXJyaWRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUmVhY3RpdmVFbGVtZW50IH0gZnJvbSAnbGl0JztcblxuaW1wb3J0IHR5cGUgeyBJbnRlcmZhY2UgfSBmcm9tICcuL2Jhc2UudHMnO1xuXG4vKipcbiAqIERlY29yYXRvciB0aGF0IG92ZXJyaWRlcyB0aGUgdW5kZXJseWluZyBnZXR0ZXIgb2YgdGhlIGFjY2Vzc29yLlxuICovXG5leHBvcnQgY29uc3QgZ2V0T3ZlcnJpZGUgPSA8QyBleHRlbmRzIEludGVyZmFjZTxSZWFjdGl2ZUVsZW1lbnQ+LCBWPihcbiAgY2FsbGJhY2s6IChpbnN0YW5jZTogQywgaW5uZXJWYWx1ZTogVikgPT4gVixcbikgPT4ge1xuICByZXR1cm4gKFxuICAgIHRhcmdldDogQ2xhc3NBY2Nlc3NvckRlY29yYXRvclRhcmdldDxDLCBWPixcbiAgICBjb250ZXh0OiBDbGFzc0FjY2Vzc29yRGVjb3JhdG9yQ29udGV4dDxDLCBWPixcbiAgKTogYW55ID0+IHtcbiAgICBjb25zdCB7IGtpbmQgfSA9IGNvbnRleHQ7XG4gICAgaWYgKGtpbmQgPT09ICdhY2Nlc3NvcicpIHtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIGdldCh0aGlzOiBDKSB7XG4gICAgICAgICAgY29uc3QgaW5uZXJWYWx1ZSA9ICh0YXJnZXQgYXMgQ2xhc3NBY2Nlc3NvckRlY29yYXRvclRhcmdldDxDLCBWPikuZ2V0LmNhbGwoXG4gICAgICAgICAgICB0aGlzIGFzIHVua25vd24gYXMgQyxcbiAgICAgICAgICApO1xuICAgICAgICAgIHJldHVybiBjYWxsYmFjayh0aGlzLCBpbm5lclZhbHVlKTtcbiAgICAgICAgfSxcbiAgICAgIH0gc2F0aXNmaWVzIENsYXNzQWNjZXNzb3JEZWNvcmF0b3JSZXN1bHQ8QywgVj47XG4gICAgfVxuXG4gICAgdGhyb3cgbmV3IEVycm9yKGBVbnN1cHBvcnRlZCBkZWNvcmF0b3IgbG9jYXRpb246ICR7a2luZH1gKTtcbiAgfTtcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFPQSxJQUFhLGVBQ1gsYUFDRTtBQUNGLFNBQ0UsUUFDQSxZQUNPO0VBQ1AsTUFBTSxFQUFFLFNBQVM7QUFDakIsTUFBSSxTQUFTLFdBQ1gsUUFBTyxFQUNMLE1BQUc7R0FDRCxNQUFNLGFBQWMsT0FBOEMsSUFBSSxLQUNwRSxLQUNEO0FBQ0QsVUFBTyxTQUFTLE1BQU0sV0FBVztLQUVTO0FBR2hELFFBQU0sSUFBSSxNQUFNLG1DQUFtQyxPQUFPIn0=
+export {
+  getOverride
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW92ZXJyaWRlLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS9kZWNvcmF0b3JzL2dldC1vdmVycmlkZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJlYWN0aXZlRWxlbWVudCB9IGZyb20gJ2xpdCc7XG5cbmltcG9ydCB0eXBlIHsgSW50ZXJmYWNlIH0gZnJvbSAnLi9iYXNlLnRzJztcblxuLyoqXG4gKiBEZWNvcmF0b3IgdGhhdCBvdmVycmlkZXMgdGhlIHVuZGVybHlpbmcgZ2V0dGVyIG9mIHRoZSBhY2Nlc3Nvci5cbiAqL1xuZXhwb3J0IGNvbnN0IGdldE92ZXJyaWRlID0gPEMgZXh0ZW5kcyBJbnRlcmZhY2U8UmVhY3RpdmVFbGVtZW50PiwgVj4oXG4gIGNhbGxiYWNrOiAoaW5zdGFuY2U6IEMsIGlubmVyVmFsdWU6IFYpID0+IFYsXG4pID0+IHtcbiAgcmV0dXJuIChcbiAgICB0YXJnZXQ6IENsYXNzQWNjZXNzb3JEZWNvcmF0b3JUYXJnZXQ8QywgVj4sXG4gICAgY29udGV4dDogQ2xhc3NBY2Nlc3NvckRlY29yYXRvckNvbnRleHQ8QywgVj4sXG4gICk6IGFueSA9PiB7XG4gICAgY29uc3QgeyBraW5kIH0gPSBjb250ZXh0O1xuICAgIGlmIChraW5kID09PSAnYWNjZXNzb3InKSB7XG4gICAgICByZXR1cm4ge1xuICAgICAgICBnZXQodGhpczogQykge1xuICAgICAgICAgIGNvbnN0IGlubmVyVmFsdWUgPSAodGFyZ2V0IGFzIENsYXNzQWNjZXNzb3JEZWNvcmF0b3JUYXJnZXQ8QywgVj4pLmdldC5jYWxsKFxuICAgICAgICAgICAgdGhpcyBhcyB1bmtub3duIGFzIEMsXG4gICAgICAgICAgKTtcbiAgICAgICAgICByZXR1cm4gY2FsbGJhY2sodGhpcywgaW5uZXJWYWx1ZSk7XG4gICAgICAgIH0sXG4gICAgICB9IHNhdGlzZmllcyBDbGFzc0FjY2Vzc29yRGVjb3JhdG9yUmVzdWx0PEMsIFY+O1xuICAgIH1cblxuICAgIHRocm93IG5ldyBFcnJvcihgVW5zdXBwb3J0ZWQgZGVjb3JhdG9yIGxvY2F0aW9uOiAke2tpbmR9YCk7XG4gIH07XG59O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9PLE1BQU0sY0FBYyxDQUN6QixhQUNFO0FBQ0YsU0FBTyxDQUNMLFFBQ0EsWUFDTztBQUNQLFVBQU0sRUFBRSxTQUFTO0FBQ2pCLFFBQUksU0FBUyxZQUFZO0FBQ3ZCLGFBQU87QUFBQSxRQUNMLE1BQUc7QUFDRCxnQkFBTSxhQUFjLE9BQThDLElBQUksS0FDcEUsSUFBb0I7QUFFdEIsaUJBQU8sU0FBUyxNQUFNLFVBQVU7QUFBQSxRQUNsQztBQUFBLE1BQUE7QUFBQSxJQUVKO0FBRUEsVUFBTSxJQUFJLE1BQU0sbUNBQW1DLElBQUksRUFBRTtBQUFBLEVBQzNEO0FBQ0Y7In0=

package/development/core/decorators/handle-distinct-change.js

@@ -1,21 +1,22 @@
-//#region src/elements/core/decorators/handle-distinct-change.ts
-/**
-* Decorator that calls the given callback when the value
-* of the associated property is changed.
-*/
-var handleDistinctChange = (callback) => {
-	return (target, context) => {
-		const { kind } = context;
-		if (kind === "accessor") return { set(value) {
-			const oldValue = context.access.get(this);
-			target.set.call(this, value);
-			const newValue = context.access.get(this);
-			if (newValue !== oldValue) callback(this, newValue, oldValue);
-		} };
-		throw new Error(`Unsupported decorator location: ${kind}`);
-	};
+const handleDistinctChange = (callback) => {
+  return (target, context) => {
+    const { kind } = context;
+    if (kind === "accessor") {
+      return {
+        set(value) {
+          const oldValue = context.access.get(this);
+          target.set.call(this, value);
+          const newValue = context.access.get(this);
+          if (newValue !== oldValue) {
+            callback(this, newValue, oldValue);
+          }
+        }
+      };
+    }
+    throw new Error(`Unsupported decorator location: ${kind}`);
+  };
 };
-//#endregion
-export { handleDistinctChange };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export {
+  handleDistinctChange
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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