@sbb-esta/lyne-elements 4.3.1 → 4.5.0

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

@@ -1,11 +1,7 @@
 import { SbbLanguageController } from "../controllers.js";
-import { DateAdapter, ISO8601_FORMAT_DATE, FORMAT_DATE } from "./date-adapter.js";
+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 NativeDateAdapter extends DateAdapter {
-  constructor(cutoffYearOffset = 15) {
-    super();
-    this._cutoffYearOffset = cutoffYearOffset;
-  }
   /** Gets the year of the input date. */
   getYear(date) {
     return date.getFullYear();
@@ -67,16 +63,15 @@ class NativeDateAdapter extends DateAdapter {
     return new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0));
   }
   /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */
-  createDate(year, month, date) {
+  createDate(year, month, day) {
     if (month < 1 || month > 12) {
-      throw Error(`Invalid month index "${month}". Month index has to be between 1 and 12.`);
-    }
-    if (date < 1) {
-      throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+      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.`);
     }
-    const result = this._createDateWithOverflow(year, month - 1, date);
+    const result = this._createDateWithOverflow(year, month - 1, day);
     if (result.getMonth() + 1 !== month) {
-      throw Error(`Invalid date "${date}" for month with index "${month}".`);
+      throw Error(`Invalid day "${day}" for month "${month}".`);
     }
     return result;
   }
@@ -127,32 +122,6 @@ class NativeDateAdapter extends DateAdapter {
     }
     return super.deserialize(date);
   }
-  /** Returns the right format for the `valueAsDate` property. */
-  parse(value) {
-    if (!value) {
-      return null;
-    }
-    let date = null;
-    const isoMatch = value.match(ISO8601_FORMAT_DATE);
-    try {
-      date = isoMatch ? this.createDate(+isoMatch[1], +isoMatch[2], +isoMatch[3]) : null;
-    } catch {
-    }
-    if (this.isValid(date)) {
-      return date;
-    }
-    const strippedValue = value.replace(/\D/g, " ").trim();
-    const match = strippedValue?.match(FORMAT_DATE);
-    if (!match || match.index !== 0 || match.length <= 2 || match.some((e) => e === void 0) || !this.isValid(this.createDate(+match[3], +match[2], +match[1]))) {
-      return null;
-    }
-    let year = +match[3];
-    if (typeof year === "number" && year < 100 && year >= 0) {
-      const shift = this.today().getFullYear() - 2e3 + this._cutoffYearOffset;
-      year = year <= shift ? 2e3 + year : 1900 + year;
-    }
-    return new Date(year, +match[2] - 1, +match[1]);
-  }
   invalid() {
     return /* @__PURE__ */ new Date(NaN);
   }
@@ -178,4 +147,4 @@ export {
   NativeDateAdapter,
   defaultDateAdapter
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"native-date-adapter.js","sources":["../../../../../src/elements/core/datetime/native-date-adapter.ts"],"sourcesContent":["import { SbbLanguageController } from '../controllers.ts';\n\nimport { DateAdapter, FORMAT_DATE, ISO8601_FORMAT_DATE } 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 an 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 NativeDateAdapter extends DateAdapter<Date> {\n  private readonly _cutoffYearOffset: number;\n\n  public constructor(cutoffYearOffset: number = 15) {\n    super();\n    this._cutoffYearOffset = cutoffYearOffset;\n  }\n\n  /** Gets the year of the input date. */\n  public getYear(date: Date): number {\n    return date.getFullYear();\n  }\n\n  /** Gets the month of the input date. */\n  public getMonth(date: Date): number {\n    return date.getMonth() + 1;\n  }\n\n  /** Gets the day of the input date. */\n  public getDate(date: Date): number {\n    return date.getDate();\n  }\n\n  /** Gets the day of the week of the input date. */\n  public getDayOfWeek(date: Date): number {\n    return date.getDay();\n  }\n\n  /** Gets the date in the local format. */\n  public getAccessibilityFormatDate(date: Date | string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: 'long',\n      day: 'numeric',\n    };\n    return new Intl.DateTimeFormat(SbbLanguageController.current, options).format(new Date(date));\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) => formatter.format(new Date(2017, i, 1)));\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) => formatter.format(new Date(2017, 0, i + 1)));\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) => formatter.format(new Date(2017, 0, i + 1)));\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: Date): number {\n    return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date), 0));\n  }\n\n  /** Creates today's date. */\n  public today(): Date {\n    return new Date(new Date().setHours(0, 0, 0, 0));\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, date: number): Date {\n    // Check for invalid month and date (except upper bound on date which we have to check after creating the Date).\n    if (month < 1 || month > 12) {\n      throw Error(`Invalid month index \"${month}\". Month index has to be between 1 and 12.`);\n    }\n\n    if (date < 1) {\n      throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\n    }\n\n    const result = this._createDateWithOverflow(year, month - 1, date);\n    // Check that the date wasn't above the upper bound for the month, causing the month to overflow\n    if (result.getMonth() + 1 !== month) {\n      throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\n    }\n\n    return result;\n  }\n\n  /** Checks whether the given `obj` is a Date. */\n  public isDateInstance(obj: any): boolean {\n    return obj instanceof Date;\n  }\n\n  /** Checks whether the given `date` is a valid Date. */\n  public isValid(date: Date | null | undefined): date is Date {\n    return !!date && !isNaN(date.valueOf());\n  }\n\n  /** Creates a new date by cloning the given one. */\n  public clone(date: Date): Date {\n    return new Date(date.valueOf());\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: Date, years: number): Date {\n    return this.addCalendarMonths(date, years * 12);\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 Date(2022, 0, 31) and `months` = 1, it returns new Date(2022, 1, 28).\n   */\n  public addCalendarMonths(date: Date, months: number): Date {\n    const targetMonth = date.getMonth() + months;\n    const dateWithCorrectMonth = new Date(date.getFullYear(), targetMonth, 1, 0, 0, 0, 0);\n    const daysInMonth = this.getNumDaysInMonth(dateWithCorrectMonth);\n    // Adapt the last day of month for shorter months\n    return new Date(this.clone(date).setMonth(targetMonth, Math.min(daysInMonth, date.getDate())));\n  }\n\n  /** Creates a new date by adding the number of provided `days` to the provided `date`. */\n  public addCalendarDays(date: Date, days: number): Date {\n    const targetDay = date.getDate() + days;\n    return new Date(date.getFullYear(), date.getMonth(), targetDay, 0, 0, 0, 0);\n  }\n\n  /** Creates a Date from a valid input (Date or ISO string). */\n  public override deserialize(date: Date | string | null | undefined): Date | null {\n    if (typeof date === 'string') {\n      if (!date) {\n        return null;\n      } else if (ISO_8601_REGEX.test(date)) {\n        // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\n        // string is the right format first.\n        return this.getValidDateOrNull(new Date(date.includes('T') ? date : date + 'T00:00:00'));\n      }\n    }\n    return super.deserialize(date);\n  }\n\n  /** Returns the right format for the `valueAsDate` property. */\n  public parse(value: string | null | undefined): Date | null {\n    if (!value) {\n      return null;\n    }\n\n    let date: Date | null = null;\n    const isoMatch = value.match(ISO8601_FORMAT_DATE);\n    try {\n      date = isoMatch ? this.createDate(+isoMatch[1], +isoMatch[2], +isoMatch[3]) : null;\n    } catch {\n      /* empty */\n    }\n    if (this.isValid(date)) {\n      return date;\n    }\n\n    const strippedValue = value.replace(/\\D/g, ' ').trim();\n\n    const match: RegExpMatchArray | null | undefined = strippedValue?.match(FORMAT_DATE);\n    if (\n      !match ||\n      match.index !== 0 ||\n      match.length <= 2 ||\n      match.some((e) => e === undefined) ||\n      !this.isValid(this.createDate(+match[3], +match[2], +match[1]))\n    ) {\n      return null;\n    }\n\n    let year = +match[3];\n\n    if (typeof year === 'number' && year < 100 && year >= 0) {\n      const shift = this.today().getFullYear() - 2000 + this._cutoffYearOffset;\n      year = year <= shift ? 2000 + year : 1900 + year;\n    }\n\n    return new Date(year, +match[2] - 1, +match[1]);\n  }\n\n  public override invalid(): Date {\n    return new Date(NaN);\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  /** Creates a date but allows the month and date to overflow. */\n  private _createDateWithOverflow(year: number, month: number, date: number): Date {\n    const result = new Date(year, month, date);\n    // We need to correct for the fact that JS native Date treats years in range [0, 99] as\n    // abbreviations for 19xx.\n    if (year >= 0 && year < 100) {\n      result.setFullYear(this.getYear(result) - 1900);\n    }\n    return result;\n  }\n}\n\nexport const defaultDateAdapter = new NativeDateAdapter();\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"native-date-adapter.js","sources":["../../../../../src/elements/core/datetime/native-date-adapter.ts"],"sourcesContent":["import { 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 an 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 NativeDateAdapter extends DateAdapter<Date> {\n  /** Gets the year of the input date. */\n  public getYear(date: Date): number {\n    return date.getFullYear();\n  }\n\n  /** Gets the month of the input date. */\n  public getMonth(date: Date): number {\n    return date.getMonth() + 1;\n  }\n\n  /** Gets the day of the input date. */\n  public getDate(date: Date): number {\n    return date.getDate();\n  }\n\n  /** Gets the day of the week of the input date. */\n  public getDayOfWeek(date: Date): number {\n    return date.getDay();\n  }\n\n  /** Gets the date in the local format. */\n  public getAccessibilityFormatDate(date: Date | string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: 'long',\n      day: 'numeric',\n    };\n    return new Intl.DateTimeFormat(SbbLanguageController.current, options).format(new Date(date));\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) => formatter.format(new Date(2017, i, 1)));\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) => formatter.format(new Date(2017, 0, i + 1)));\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) => formatter.format(new Date(2017, 0, i + 1)));\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: Date): number {\n    return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date), 0));\n  }\n\n  /** Creates today's date. */\n  public today(): Date {\n    return new Date(new Date().setHours(0, 0, 0, 0));\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): Date {\n    // Check for invalid month and date (except upper bound on date which we have to check after creating the Date).\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    const result = this._createDateWithOverflow(year, month - 1, day);\n    // Check that the date wasn't above the upper bound for the month, causing the month to overflow\n    if (result.getMonth() + 1 !== month) {\n      throw Error(`Invalid day \"${day}\" for month \"${month}\".`);\n    }\n\n    return result;\n  }\n\n  /** Checks whether the given `obj` is a Date. */\n  public isDateInstance(obj: any): boolean {\n    return obj instanceof Date;\n  }\n\n  /** Checks whether the given `date` is a valid Date. */\n  public isValid(date: Date | null | undefined): date is Date {\n    return !!date && !isNaN(date.valueOf());\n  }\n\n  /** Creates a new date by cloning the given one. */\n  public clone(date: Date): Date {\n    return new Date(date.valueOf());\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: Date, years: number): Date {\n    return this.addCalendarMonths(date, years * 12);\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 Date(2022, 0, 31) and `months` = 1, it returns new Date(2022, 1, 28).\n   */\n  public addCalendarMonths(date: Date, months: number): Date {\n    const targetMonth = date.getMonth() + months;\n    const dateWithCorrectMonth = new Date(date.getFullYear(), targetMonth, 1, 0, 0, 0, 0);\n    const daysInMonth = this.getNumDaysInMonth(dateWithCorrectMonth);\n    // Adapt the last day of month for shorter months\n    return new Date(this.clone(date).setMonth(targetMonth, Math.min(daysInMonth, date.getDate())));\n  }\n\n  /** Creates a new date by adding the number of provided `days` to the provided `date`. */\n  public addCalendarDays(date: Date, days: number): Date {\n    const targetDay = date.getDate() + days;\n    return new Date(date.getFullYear(), date.getMonth(), targetDay, 0, 0, 0, 0);\n  }\n\n  /** Creates a Date from a valid input (Date or ISO string). */\n  public override deserialize(date: Date | string | null | undefined): Date | null {\n    if (typeof date === 'string') {\n      if (!date) {\n        return null;\n      } else if (ISO_8601_REGEX.test(date)) {\n        // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\n        // string is the right format first.\n        return this.getValidDateOrNull(new Date(date.includes('T') ? date : date + 'T00:00:00'));\n      }\n    }\n    return super.deserialize(date);\n  }\n\n  public override invalid(): Date {\n    return new Date(NaN);\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  /** Creates a date but allows the month and date to overflow. */\n  private _createDateWithOverflow(year: number, month: number, date: number): Date {\n    const result = new Date(year, month, date);\n    // We need to correct for the fact that JS native Date treats years in range [0, 99] as\n    // abbreviations for 19xx.\n    if (year >= 0 && year < 100) {\n      result.setFullYear(this.getYear(result) - 1900);\n    }\n    return result;\n  }\n}\n\nexport const defaultDateAdapter = new NativeDateAdapter();\n"],"names":[],"mappings":"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"}

package/{core/datetime/native-date-adapter.d.ts → development/core/datetime/temporal-date-adapter.d.ts}

@@ -1,17 +1,15 @@
 import { DateAdapter } from './date-adapter.ts';
-export declare class NativeDateAdapter extends DateAdapter<Date> {
-    private readonly _cutoffYearOffset;
-    constructor(cutoffYearOffset?: number);
+export declare class TemporalDateAdapter extends DateAdapter<Temporal.PlainDate> {
     /** Gets the year of the input date. */
-    getYear(date: Date): number;
+    getYear(date: Temporal.PlainDate): number;
     /** Gets the month of the input date. */
-    getMonth(date: Date): number;
+    getMonth(date: Temporal.PlainDate): number;
     /** Gets the day of the input date. */
-    getDate(date: Date): number;
+    getDate(date: Temporal.PlainDate): number;
     /** Gets the day of the week of the input date. */
-    getDayOfWeek(date: Date): number;
+    getDayOfWeek(date: Temporal.PlainDate): number;
     /** Gets the date in the local format. */
-    getAccessibilityFormatDate(date: Date | string): string;
+    getAccessibilityFormatDate(date: Temporal.PlainDate | string): string;
     /**
      * 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,
@@ -29,44 +27,41 @@ export declare class NativeDateAdapter extends DateAdapter<Date> {
     /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */
     getFirstDayOfWeek(): number;
     /** Calculates the number of days in a month given the year and the month. */
-    getNumDaysInMonth(date: Date): number;
+    getNumDaysInMonth(date: Temporal.PlainDate): number;
     /** Creates today's date. */
-    today(): Date;
+    today(): Temporal.PlainDate;
     /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */
-    createDate(year: number, month: number, date: number): Date;
-    /** Checks whether the given `obj` is a Date. */
+    createDate(year: number, month: number, day: number): Temporal.PlainDate;
+    /** Checks whether the given `obj` is a Temporal.PlainDate. */
     isDateInstance(obj: any): boolean;
-    /** Checks whether the given `date` is a valid Date. */
-    isValid(date: Date | null | undefined): date is Date;
+    /** Checks whether the given `date` is a valid Temporal.PlainDate. */
+    isValid(date: Temporal.PlainDate | null | undefined): date is Temporal.PlainDate;
     /** Creates a new date by cloning the given one. */
-    clone(date: Date): Date;
+    clone(date: Temporal.PlainDate): Temporal.PlainDate;
     /**
      * 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: Date, years: number): Date;
+    addCalendarYears(date: Temporal.PlainDate, years: number): Temporal.PlainDate;
     /**
      * 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 Date(2022, 0, 31) and `months` = 1, it returns new Date(2022, 1, 28).
+     * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).
      */
-    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarMonths(date: Temporal.PlainDate, months: number): Temporal.PlainDate;
     /** Creates a new date by adding the number of provided `days` to the provided `date`. */
-    addCalendarDays(date: Date, days: number): Date;
-    /** Creates a Date from a valid input (Date or ISO string). */
-    deserialize(date: Date | string | null | undefined): Date | null;
-    /** Returns the right format for the `valueAsDate` property. */
-    parse(value: string | null | undefined): Date | null;
-    invalid(): Date;
+    addCalendarDays(date: Temporal.PlainDate, days: number): Temporal.PlainDate;
+    /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */
+    deserialize(date: Temporal.PlainDate | string | null | undefined): Temporal.PlainDate | null;
+    invalid(): Temporal.PlainDate;
+    toIso8601(date: Temporal.PlainDate): string;
     /**
      * 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.
      */
     private _range;
-    /** Creates a date but allows the month and date to overflow. */
-    private _createDateWithOverflow;
 }
-export declare const defaultDateAdapter: NativeDateAdapter;
-//# sourceMappingURL=native-date-adapter.d.ts.map
+export declare const temporalDateAdapter: TemporalDateAdapter;
+//# sourceMappingURL=temporal-date-adapter.d.ts.map

package/development/core/datetime/temporal-date-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-date-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/datetime/temporal-date-adapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAgBhD,qBAAa,mBAAoB,SAAQ,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC;IACtE,uCAAuC;IAChC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAIhD,wCAAwC;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAIjD,sCAAsC;IAC/B,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAIhD,kDAAkD;IAC3C,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAMrD,yCAAyC;IAClC,0BAA0B,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM,GAAG,MAAM;IAS5E;;;;OAIG;IACI,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAAE;IAOlE,iGAAiG;IAC1F,YAAY,IAAI,MAAM,EAAE;IAO/B;;;;OAIG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAAE;IAOtE,+EAA+E;IACxE,iBAAiB,IAAI,MAAM;IAIlC,6EAA6E;IACtE,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAI1D,4BAA4B;IACrB,KAAK,IAAI,QAAQ,CAAC,SAAS;IAIlC,+FAA+F;IACxF,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAe/E,8DAA8D;IACvD,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAIxC,qEAAqE;IAC9D,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,QAAQ,CAAC,SAAS;IAIvF,mDAAmD;IAC5C,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS;IAI1D;;;;OAIG;IACI,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAIpF;;;;OAIG;IACI,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAItF,yFAAyF;IAClF,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAIlF,0FAA0F;IAC1E,WAAW,CACzB,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GACnD,QAAQ,CAAC,SAAS,GAAG,IAAI;IAYZ,OAAO,IAAI,QAAQ,CAAC,SAAS;IAK7B,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAI3D;;;;OAIG;IACH,OAAO,CAAC,MAAM;CAGf;AAED,eAAO,MAAM,mBAAmB,qBAA4B,CAAC"}

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

@@ -0,0 +1,144 @@
+import { SbbLanguageController } from "../controllers.js";
+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}))?)?$/;
+if (typeof Temporal !== "object") {
+  throw new Error("Temporal is not available in the current environment. Please make sure to include the temporal polyfill.");
+}
+class TemporalDateAdapter extends DateAdapter {
+  /** 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));
+  }
+}
+const temporalDateAdapter = new TemporalDateAdapter();
+export {
+  TemporalDateAdapter,
+  temporalDateAdapter
+};
+//# 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 an 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\nif (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\nexport class TemporalDateAdapter extends DateAdapter<Temporal.PlainDate> {\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\nexport const temporalDateAdapter = new TemporalDateAdapter();\n"],"names":[],"mappings":"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"}

package/development/core/datetime.d.ts

@@ -3,4 +3,5 @@
  */
 export * from './datetime/date-adapter.ts';
 export * from './datetime/native-date-adapter.ts';
+export * from './datetime/temporal-date-adapter.ts';
 //# sourceMappingURL=datetime.d.ts.map

package/development/core/datetime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/datetime.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/datetime.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC"}

package/development/core/datetime.js

@@ -1,5 +1,6 @@
 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, temporalDateAdapter } from "./datetime/temporal-date-adapter.js";
 export {
   DAYS_PER_ROW,
   DateAdapter,
@@ -8,8 +9,10 @@ export {
   MONTHS_PER_PAGE,
   MONTHS_PER_ROW,
   NativeDateAdapter,
+  TemporalDateAdapter,
   YEARS_PER_PAGE,
   YEARS_PER_ROW,
-  defaultDateAdapter
+  defaultDateAdapter,
+  temporalDateAdapter
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWUuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWUuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7In0=

package/development/core/decorators/id-reference.js

@@ -90,10 +90,6 @@ const idReference = () => {
           if (typeof value !== "string") {
             idReferences.delete(this);
             if (value instanceof HTMLElement && this.hasAttribute(attributeName) && value.id !== this.getAttribute(attributeName)) {
-              {
-                const elementIdentity = value.id ? `#${value.id}` : value.classList.value.split(" ").map((c) => `.${c}`).join("");
-                console.warn(`An element (${value.localName + elementIdentity}) was passed to the ${this.localName}.${name} property, which does not match the existing id reference attribute ${attributeName} with value ${this.getAttribute(attributeName)}. This will remove the current attribute value.`);
-              }
               this.removeAttribute(attributeName);
             }
           } else if (this.hasAttribute(attributeName) && this.getAttribute(attributeName) !== value) {
@@ -117,4 +113,4 @@ const idReference = () => {
 export {
   idReference
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"id-reference.js","sources":["../../../../../src/elements/core/decorators/id-reference.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveElement } from 'lit';\n\nimport type { Interface } from './base.ts';\n\ninterface IdReferenceController extends ReactiveController {\n  host: Interface<ReactiveElement>;\n  rootNode: Document | ShadowRoot | null;\n  checkIdReference: (changedIds?: Set<string>) => void;\n}\n\n/**\n * We keep track of the observers for each root node, which is either a document\n * or a shadow root.\n * Each observer is associated with a set of controllers that each represent\n * an id reference.\n * Whenever the MutationObserver detects a change that affects a potential id\n * reference, it notifies all controllers associated with that observer.\n */\nconst observers = new WeakMap<\n  Node,\n  {\n    observer: MutationObserver;\n    controllers: Set<IdReferenceController>;\n  }\n>();\n/**\n * Whenever an id string is passed to the setter and no reference is found,\n * we store it in this WeakMap.\n * The key is the host element and the value is the id string.\n * Please note that if an id reference property has both an entry\n * in this WeakMap and an associated attribute, the attribute will take precedence.\n */\nconst idReferences = new WeakMap<object, string | null>();\n\n/**\n * Accessor decorator that resolves id references dynamically.\n * If a string is passed (e.g. from an attribute), it will be resolved to the element with that id.\n * This decorator observes the connected document fragment for changes to the id attribute\n * and child elements and if any id reference is established or removed, it will\n * update the associated property.\n */\nexport const idReference = <C extends Interface<ReactiveElement>, V>() => {\n  return (\n    target: ClassAccessorDecoratorTarget<C, V>,\n    context: ClassAccessorDecoratorContext<C, V>,\n  ): any => {\n    const { kind, metadata, name } = context;\n    if (kind === 'accessor') {\n      if (isServer) {\n        return {};\n      }\n\n      const attribute = globalThis.litPropertyMetadata.get(metadata)?.get(name)?.attribute;\n      const attributeName = typeof attribute === 'string' ? attribute : (name as string);\n      context.addInitializer(function () {\n        this.addController({\n          host: this,\n          rootNode: null,\n          checkIdReference(changedIds?: Set<string>): void {\n            const id = this.host.getAttribute(attributeName) ?? idReferences.get(this.host);\n            if (id && typeof id === 'string' && (!changedIds || changedIds.has(id))) {\n              const value = (this.rootNode?.getElementById?.(id) ?? null) as unknown as V;\n              if (context.access.get(this.host as C) !== value) {\n                context.access.set(this.host as C, value);\n              }\n            }\n          },\n          hostConnected() {\n            this.rootNode = this.host.getRootNode() as Document | ShadowRoot;\n            this.checkIdReference();\n            const observerContext = observers.get(this.rootNode);\n\n            if (observerContext) {\n              observerContext.controllers.add(this);\n            } else {\n              const controllers = new Set([this]);\n              const observer = new MutationObserver((mutations) => {\n                const mutatedIds = new Set<string>();\n\n                for (const mutation of mutations) {\n                  if (mutation.type === 'attributes') {\n                    if (mutation.oldValue) {\n                      mutatedIds.add(mutation.oldValue!);\n                    }\n                    if ((mutation.target as HTMLElement).id) {\n                      mutatedIds.add((mutation.target as HTMLElement).id);\n                    }\n                  } else if (mutation.type === 'childList') {\n                    for (const node of [...mutation.addedNodes, ...mutation.removedNodes]) {\n                      if (node instanceof HTMLElement) {\n                        if (node.id) {\n                          mutatedIds.add(node.id);\n                        }\n                        node.querySelectorAll('[id]').forEach((e) => {\n                          if (e.id) {\n                            mutatedIds.add(e.id);\n                          }\n                        });\n                      }\n                    }\n                  }\n                }\n\n                controllers.forEach((c) => c.checkIdReference(mutatedIds));\n              });\n\n              observer.observe(this.rootNode, {\n                attributeFilter: ['id'],\n                attributeOldValue: true,\n                childList: true,\n                subtree: true,\n              });\n\n              observers.set(this.rootNode, { observer, controllers });\n            }\n          },\n          hostDisconnected() {\n            if (isServer || !this.rootNode) {\n              return;\n            }\n\n            const observerContext = observers.get(this.rootNode);\n            if (!observerContext) {\n              this.rootNode = null;\n              return;\n            }\n\n            observerContext.controllers.delete(this);\n            if (observerContext.controllers.size === 0) {\n              observerContext.observer.disconnect();\n              observers.delete(this.rootNode);\n            }\n\n            this.rootNode = null;\n          },\n        } as IdReferenceController);\n      });\n      return {\n        set(this: C, value) {\n          if (typeof value !== 'string') {\n            idReferences.delete(this);\n            if (\n              value instanceof HTMLElement &&\n              this.hasAttribute(attributeName) &&\n              value.id !== this.getAttribute(attributeName)\n            ) {\n              if (import.meta.env.DEV) {\n                const elementIdentity = value.id\n                  ? `#${value.id}`\n                  : value.classList.value\n                      .split(' ')\n                      .map((c) => `.${c}`)\n                      .join('');\n                console.warn(\n                  `An element (${value.localName + elementIdentity}) was ` +\n                    `passed to the ${this.localName}.${name as string} property, ` +\n                    `which does not match the existing id reference attribute ` +\n                    `${attributeName} with value ${this.getAttribute(attributeName)}. ` +\n                    `This will remove the current attribute value.`,\n                );\n              }\n              this.removeAttribute(attributeName);\n            }\n          } else if (\n            this.hasAttribute(attributeName) &&\n            this.getAttribute(attributeName) !== value\n          ) {\n            // When a string is passed to the setter but the attribute is set to a\n            // different value, we ignore the passed value.\n            return;\n          } else {\n            const element = value\n              ? (this.getRootNode?.() as Document | ShadowRoot)?.getElementById?.(value)\n              : null;\n            if (element) {\n              value = element as unknown as V;\n            } else if (value) {\n              // If we are unable to resolve the id reference, we temporarily store it\n              // to try to resolve it later.\n              idReferences.set(this, value as string);\n              value = null!;\n            }\n          }\n\n          (target as ClassAccessorDecoratorTarget<C, V>).set.call(this as unknown as C, value);\n        },\n      } satisfies ClassAccessorDecoratorResult<C, V>;\n    }\n\n    throw new Error(`Unsupported decorator location: ${kind}`);\n  };\n};\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"id-reference.js","sources":["../../../../../src/elements/core/decorators/id-reference.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveElement } from 'lit';\n\nimport type { Interface } from './base.ts';\n\ninterface IdReferenceController extends ReactiveController {\n  host: Interface<ReactiveElement>;\n  rootNode: Document | ShadowRoot | null;\n  checkIdReference: (changedIds?: Set<string>) => void;\n}\n\n/**\n * We keep track of the observers for each root node, which is either a document\n * or a shadow root.\n * Each observer is associated with a set of controllers that each represent\n * an id reference.\n * Whenever the MutationObserver detects a change that affects a potential id\n * reference, it notifies all controllers associated with that observer.\n */\nconst observers = new WeakMap<\n  Node,\n  {\n    observer: MutationObserver;\n    controllers: Set<IdReferenceController>;\n  }\n>();\n/**\n * Whenever an id string is passed to the setter and no reference is found,\n * we store it in this WeakMap.\n * The key is the host element and the value is the id string.\n * Please note that if an id reference property has both an entry\n * in this WeakMap and an associated attribute, the attribute will take precedence.\n */\nconst idReferences = new WeakMap<object, string | null>();\n\n/**\n * Accessor decorator that resolves id references dynamically.\n * If a string is passed (e.g. from an attribute), it will be resolved to the element with that id.\n * This decorator observes the connected document fragment for changes to the id attribute\n * and child elements and if any id reference is established or removed, it will\n * update the associated property.\n */\nexport const idReference = <C extends Interface<ReactiveElement>, V>() => {\n  return (\n    target: ClassAccessorDecoratorTarget<C, V>,\n    context: ClassAccessorDecoratorContext<C, V>,\n  ): any => {\n    const { kind, metadata, name } = context;\n    if (kind === 'accessor') {\n      if (isServer) {\n        return {};\n      }\n\n      const attribute = globalThis.litPropertyMetadata.get(metadata)?.get(name)?.attribute;\n      const attributeName = typeof attribute === 'string' ? attribute : (name as string);\n      context.addInitializer(function () {\n        this.addController({\n          host: this,\n          rootNode: null,\n          checkIdReference(changedIds?: Set<string>): void {\n            const id = this.host.getAttribute(attributeName) ?? idReferences.get(this.host);\n            if (id && typeof id === 'string' && (!changedIds || changedIds.has(id))) {\n              const value = (this.rootNode?.getElementById?.(id) ?? null) as unknown as V;\n              if (context.access.get(this.host as C) !== value) {\n                context.access.set(this.host as C, value);\n              }\n            }\n          },\n          hostConnected() {\n            this.rootNode = this.host.getRootNode() as Document | ShadowRoot;\n            this.checkIdReference();\n            const observerContext = observers.get(this.rootNode);\n\n            if (observerContext) {\n              observerContext.controllers.add(this);\n            } else {\n              const controllers = new Set([this]);\n              const observer = new MutationObserver((mutations) => {\n                const mutatedIds = new Set<string>();\n\n                for (const mutation of mutations) {\n                  if (mutation.type === 'attributes') {\n                    if (mutation.oldValue) {\n                      mutatedIds.add(mutation.oldValue!);\n                    }\n                    if ((mutation.target as HTMLElement).id) {\n                      mutatedIds.add((mutation.target as HTMLElement).id);\n                    }\n                  } else if (mutation.type === 'childList') {\n                    for (const node of [...mutation.addedNodes, ...mutation.removedNodes]) {\n                      if (node instanceof HTMLElement) {\n                        if (node.id) {\n                          mutatedIds.add(node.id);\n                        }\n                        node.querySelectorAll('[id]').forEach((e) => {\n                          if (e.id) {\n                            mutatedIds.add(e.id);\n                          }\n                        });\n                      }\n                    }\n                  }\n                }\n\n                controllers.forEach((c) => c.checkIdReference(mutatedIds));\n              });\n\n              observer.observe(this.rootNode, {\n                attributeFilter: ['id'],\n                attributeOldValue: true,\n                childList: true,\n                subtree: true,\n              });\n\n              observers.set(this.rootNode, { observer, controllers });\n            }\n          },\n          hostDisconnected() {\n            if (isServer || !this.rootNode) {\n              return;\n            }\n\n            const observerContext = observers.get(this.rootNode);\n            if (!observerContext) {\n              this.rootNode = null;\n              return;\n            }\n\n            observerContext.controllers.delete(this);\n            if (observerContext.controllers.size === 0) {\n              observerContext.observer.disconnect();\n              observers.delete(this.rootNode);\n            }\n\n            this.rootNode = null;\n          },\n        } as IdReferenceController);\n      });\n      return {\n        set(this: C, value) {\n          if (typeof value !== 'string') {\n            idReferences.delete(this);\n            if (\n              value instanceof HTMLElement &&\n              this.hasAttribute(attributeName) &&\n              value.id !== this.getAttribute(attributeName)\n            ) {\n              if (import.meta.env.DEV) {\n                const elementIdentity = value.id\n                  ? `#${value.id}`\n                  : value.classList.value\n                      .split(' ')\n                      .map((c) => `.${c}`)\n                      .join('');\n                console.warn(\n                  `An element (${value.localName + elementIdentity}) was ` +\n                    `passed to the ${this.localName}.${name as string} property, ` +\n                    `which does not match the existing id reference attribute ` +\n                    `${attributeName} with value ${this.getAttribute(attributeName)}. ` +\n                    `This will remove the current attribute value.`,\n                );\n              }\n              this.removeAttribute(attributeName);\n            }\n          } else if (\n            this.hasAttribute(attributeName) &&\n            this.getAttribute(attributeName) !== value\n          ) {\n            // When a string is passed to the setter but the attribute is set to a\n            // different value, we ignore the passed value.\n            return;\n          } else {\n            const element = value\n              ? (this.getRootNode?.() as Document | ShadowRoot)?.getElementById?.(value)\n              : null;\n            if (element) {\n              value = element as unknown as V;\n            } else if (value) {\n              // If we are unable to resolve the id reference, we temporarily store it\n              // to try to resolve it later.\n              idReferences.set(this, value as string);\n              value = null!;\n            }\n          }\n\n          (target as ClassAccessorDecoratorTarget<C, V>).set.call(this as unknown as C, value);\n        },\n      } satisfies ClassAccessorDecoratorResult<C, V>;\n    }\n\n    throw new Error(`Unsupported decorator location: ${kind}`);\n  };\n};\n"],"names":[],"mappings":"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"}

package/development/datepicker/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/elements/datepicker/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/elements/datepicker/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,+BAA+B,CAAC;AAE9C,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,4CAA4C,CAAC"}

package/development/datepicker/common.js

@@ -1,6 +1,8 @@
 import { SbbDatepickerButton, SbbDatepickerButtonBase } from "./common/datepicker-button.js";
+import { d } from "../datepicker-button-BDlxIp9r.js";
 export {
   SbbDatepickerButton,
-  SbbDatepickerButtonBase
+  SbbDatepickerButtonBase,
+  d as datepickerButtonStyle
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=

package/development/datepicker/datepicker-next-day/datepicker-next-day.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datepicker-next-day.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker-next-day/datepicker-next-day.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAM1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAInD;;GAEG;AACH,qBAEM,2BAA2B,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IACxE,OAAuB,MAAM,EAAE,cAAc,CAA6C;IAE1F,SAAS,CAAC,QAAQ,EAAE,MAAM,CAA+B;IACzD,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAe;IACnE,SAAS,CAAC,wBAAwB,kDAAqB;IAEvD,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI;IAmB9C,OAAO,CAAC,eAAe;CAGxB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,yBAAyB,EAAE,2BAA2B,CAAC;KACxD;CACF"}
+{"version":3,"file":"datepicker-next-day.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker-next-day/datepicker-next-day.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAM1C,OAAO,EAAyB,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAE1E;;GAEG;AACH,qBAEM,2BAA2B,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IACxE,OAAuB,MAAM,EAAE,cAAc,CAI3C;IAEF,SAAS,CAAC,QAAQ,EAAE,MAAM,CAA+B;IACzD,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAe;IACnE,SAAS,CAAC,wBAAwB,kDAAqB;IAEvD,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI;IAmB9C,OAAO,CAAC,eAAe;CAGxB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,yBAAyB,EAAE,2BAA2B,CAAC;KACxD;CACF"}

package/development/datepicker/datepicker-next-day/datepicker-next-day.component.js

@@ -3,12 +3,7 @@ import { customElement } from "lit/decorators.js";
 import { miniButtonStyle } from "../../button/common.js";
 import { i18nNextDay, i18nSelectNextDay } from "../../core/i18n.js";
 import { boxSizingStyles } from "../../core/styles.js";
-import { SbbDatepickerButton } from "../common.js";
-import { css } from "lit";
-const style = css`.sbb-datepicker-next-day {
-  margin: auto;
-  -webkit-tap-highlight-color: transparent;
-}`;
+import { SbbDatepickerButton, datepickerButtonStyle } from "../common.js";
 let SbbDatepickerNextDayElement = (() => {
   var _a;
   let _classDecorators = [customElement("sbb-datepicker-next-day")];
@@ -47,10 +42,14 @@ let SbbDatepickerNextDayElement = (() => {
     __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
     _classThis = _classDescriptor.value;
     if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-  })(), _a.styles = [boxSizingStyles, miniButtonStyle, style], __runInitializers(_classThis, _classExtraInitializers), _a;
+  })(), _a.styles = [
+    boxSizingStyles,
+    miniButtonStyle,
+    datepickerButtonStyle
+  ], __runInitializers(_classThis, _classExtraInitializers), _a;
   return _classThis;
 })();
 export {
   SbbDatepickerNextDayElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/datepicker/datepicker-previous-day/datepicker-previous-day.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datepicker-previous-day.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker-previous-day/datepicker-previous-day.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAM1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAInD;;GAEG;AACH,qBAEM,+BAA+B,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IAC5E,OAAuB,MAAM,EAAE,cAAc,CAA6C;IAE1F,SAAS,CAAC,QAAQ,EAAE,MAAM,CAA8B;IACxD,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAmB;IACvE,SAAS,CAAC,wBAAwB,kDAAyB;IAE3D,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI;IAmB9C,OAAO,CAAC,gBAAgB;CAGzB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,6BAA6B,EAAE,+BAA+B,CAAC;KAChE;CACF"}
+{"version":3,"file":"datepicker-previous-day.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker-previous-day/datepicker-previous-day.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAM1C,OAAO,EAAyB,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAE1E;;GAEG;AACH,qBAEM,+BAA+B,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IAC5E,OAAuB,MAAM,EAAE,cAAc,CAI3C;IAEF,SAAS,CAAC,QAAQ,EAAE,MAAM,CAA8B;IACxD,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAmB;IACvE,SAAS,CAAC,wBAAwB,kDAAyB;IAE3D,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI;IAmB9C,OAAO,CAAC,gBAAgB;CAGzB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,6BAA6B,EAAE,+BAA+B,CAAC;KAChE;CACF"}