@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

package/core/datetime/date-adapter.js

@@ -0,0 +1,136 @@
+const l = 7, f = 4, u = 4, D = 12, g = 24, h = /(0?[1-9]|[12][0-9]|3[01])[.,\\/\-\s](0?[1-9]|1[0-2])[.,\\/\-\s]([0-9]{1,4}$)?/, o = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-3][0-9])$/;
+class d {
+  /**
+   * @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(t = 15) {
+    this._cutoffYearOffset = t;
+  }
+  /**
+   * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+   * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+   * string). The default implementation does not allow any deserialization, it simply checks that
+   * the given value is already a valid date object or null.
+   * @param value Either a date object, ISO string or an empty value.
+   * @returns The date if the input is valid, `null` otherwise.
+   */
+  deserialize(t) {
+    return t == null || this.isDateInstance(t) && this.isValid(t) ? t : this.invalid();
+  }
+  /**
+   * Get the given string as Date.
+   * @param value The date in the format DD.MM.YYYY.
+   */
+  parse(t) {
+    if (!t)
+      return null;
+    let e = null;
+    const s = t.match(o);
+    try {
+      e = s ? this.createDate(+s[1], +s[2], +s[3]) : null;
+    } catch {
+    }
+    if (this.isValid(e))
+      return e;
+    const r = t.replace(/\D/g, " ").trim()?.match(h);
+    if (!r || r.index !== 0 || r.length <= 2 || r.some((n) => n === void 0) || !this.isValid(this.createDate(+r[3], +r[2], +r[1])))
+      return null;
+    let i = +r[3];
+    if (typeof i == "number" && i < 100 && i >= 0) {
+      const n = this.getYear(this.today()) - 2e3 + this._cutoffYearOffset;
+      i = i <= n ? 2e3 + i : 1900 + i;
+    }
+    return this.createDate(i, +r[2], +r[1]);
+  }
+  /**
+   * Format the given date as string.
+   * @param date The date to format.
+   * @param options options object with weekdayStyle as property
+   */
+  format(t, e) {
+    if (!this.isValid(t))
+      return "";
+    const s = /* @__PURE__ */ new Date(this.toIso8601(t) + "T00:00:00"), a = new Intl.DateTimeFormat("de-CH", {
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric"
+    });
+    if (e?.weekdayStyle === "none")
+      return a.format(s);
+    const r = e?.weekdayStyle ?? "short";
+    let i = this.getDayOfWeekNames(r)[this.getDayOfWeek(t)];
+    return i = i.charAt(0).toUpperCase() + i.substring(1), r === "short" && (i = i.substring(0, 2)), `${i}, ${a.format(s)}`;
+  }
+  /**
+   * Get the given date as ISO String.
+   * @param date The date to convert to ISO String.
+   */
+  toIso8601(t) {
+    const e = (s, a = 2) => `${s}`.padStart(a, "0");
+    return `${e(this.getYear(t), 4)}-${e(this.getMonth(t))}-${e(this.getDate(t))}`;
+  }
+  /**
+   * Given a potential date object, returns that same date object if it is
+   * a valid date, or `null` if it's not a valid date.
+   * @param value The object to check.
+   * @returns A date or `null`.
+   */
+  getValidDateOrNull(t) {
+    return this.isDateInstance(t) && this.isValid(t) ? t : null;
+  }
+  /**
+   * Calculates the day of the week of the first day of the month, and then its offset from the first day of the week.
+   */
+  getFirstWeekOffset(t) {
+    const e = this.createDate(this.getYear(t), this.getMonth(t), 1);
+    return (7 + this.getDayOfWeek(e) - this.getFirstDayOfWeek()) % 7;
+  }
+  /**
+   * Compares two dates.
+   * @param first The first date to compare.
+   * @param second The second date to compare.
+   * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
+   *     a number greater than 0 if the first date is later.
+   */
+  compareDate(t, e) {
+    return this.getYear(t) - this.getYear(e) || this.getMonth(t) - this.getMonth(e) || this.getDate(t) - this.getDate(e);
+  }
+  /**
+   * Checks if two dates are equal.
+   * @param first The first date to check.
+   * @param second The second date to check.
+   * @returns Whether the two dates are equal.
+   *     Null dates are considered equal to other null dates.
+   */
+  sameDate(t, e) {
+    if (t && e) {
+      const s = this.isValid(t), a = this.isValid(e);
+      return s && a ? !this.compareDate(t, e) : s == a;
+    }
+    return t == e;
+  }
+  /**
+   * Clamp the given date between min and max dates.
+   * @param date The date to clamp.
+   * @param min The minimum value to allow. If null or omitted no min is enforced.
+   * @param max The maximum value to allow. If null or omitted no max is enforced.
+   * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
+   *     otherwise `date`.
+   */
+  clampDate(t, e, s) {
+    return e && this.compareDate(t, e) < 0 ? e : s && this.compareDate(t, s) > 0 ? s : t;
+  }
+}
+export {
+  l as DAYS_PER_ROW,
+  d as DateAdapter,
+  h as FORMAT_DATE,
+  o as ISO8601_FORMAT_DATE,
+  D as MONTHS_PER_PAGE,
+  f as MONTHS_PER_ROW,
+  g as YEARS_PER_PAGE,
+  u as YEARS_PER_ROW
+};

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

@@ -0,0 +1,140 @@
+import { SbbLanguageController as a } from "../controllers.js";
+import { DateAdapter as s } from "./date-adapter.js";
+const i = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+class u extends s {
+  /** Gets the year of the input date. */
+  getYear(e) {
+    return e.getFullYear();
+  }
+  /** Gets the month of the input date. */
+  getMonth(e) {
+    return e.getMonth() + 1;
+  }
+  /** Gets the day of the input date. */
+  getDate(e) {
+    return e.getDate();
+  }
+  /** Gets the day of the week of the input date. */
+  getDayOfWeek(e) {
+    return e.getDay();
+  }
+  /** Gets the date in the local format. */
+  getAccessibilityFormatDate(e) {
+    const t = {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    };
+    return new Intl.DateTimeFormat(a.current, t).format(new Date(e));
+  }
+  /**
+   * 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(e) {
+    const t = new Intl.DateTimeFormat(a.current, { month: e });
+    return this._range(12, (r) => t.format(new Date(2017, r, 1)));
+  }
+  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */
+  getDateNames() {
+    const e = new Intl.DateTimeFormat(a.current, { day: "numeric" });
+    return this._range(31, (t) => e.format(new Date(2017, 0, t + 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(e) {
+    const t = new Intl.DateTimeFormat(a.current, { weekday: e });
+    return this._range(7, (r) => t.format(new Date(2017, 0, r + 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(e) {
+    return this.getDate(this._createDateWithOverflow(this.getYear(e), this.getMonth(e), 0));
+  }
+  /** Creates today's date. */
+  today() {
+    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(e, t, r) {
+    if (t < 1 || t > 12)
+      throw Error(`Invalid month "${t}". Month has to be between 1 and 12.`);
+    if (r < 1)
+      throw Error(`Invalid day "${r}". Day has to be greater than 0.`);
+    const n = this._createDateWithOverflow(e, t - 1, r);
+    if (n.getMonth() + 1 !== t)
+      throw Error(`Invalid day "${r}" for month "${t}".`);
+    return n;
+  }
+  /** Checks whether the given `obj` is a Date. */
+  isDateInstance(e) {
+    return e instanceof Date;
+  }
+  /** Checks whether the given `date` is a valid Date. */
+  isValid(e) {
+    return !!e && !isNaN(e.valueOf());
+  }
+  /** Creates a new date by cloning the given one. */
+  clone(e) {
+    return new Date(e.valueOf());
+  }
+  /**
+   * 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(e, t) {
+    return this.addCalendarMonths(e, t * 12);
+  }
+  /**
+   * 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).
+   */
+  addCalendarMonths(e, t) {
+    const r = e.getMonth() + t, n = new Date(e.getFullYear(), r, 1, 0, 0, 0, 0), o = this.getNumDaysInMonth(n);
+    return new Date(this.clone(e).setMonth(r, Math.min(o, e.getDate())));
+  }
+  /** Creates a new date by adding the number of provided `days` to the provided `date`. */
+  addCalendarDays(e, t) {
+    const r = e.getDate() + t;
+    return new Date(e.getFullYear(), e.getMonth(), r, 0, 0, 0, 0);
+  }
+  /** Creates a Date from a valid input (Date or ISO string). */
+  deserialize(e) {
+    if (typeof e == "string")
+      if (e) {
+        if (i.test(e))
+          return this.getValidDateOrNull(new Date(e.includes("T") ? e : e + "T00:00:00"));
+      } else return null;
+    return super.deserialize(e);
+  }
+  invalid() {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+  /**
+   * 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(e, t) {
+    return Array.from({ length: e }).map((r, n) => t(n));
+  }
+  /** Creates a date but allows the month and date to overflow. */
+  _createDateWithOverflow(e, t, r) {
+    const n = new Date(e, t, r);
+    return e >= 0 && e < 100 && n.setFullYear(this.getYear(n) - 1900), n;
+  }
+}
+const g = new u();
+export {
+  u as NativeDateAdapter,
+  g as defaultDateAdapter
+};

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

@@ -0,0 +1,145 @@
+import { SbbLanguageController as a } from "../controllers.js";
+import { DateAdapter as o } from "./date-adapter.js";
+const i = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+class d extends o {
+  /**
+   * @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(e) {
+    if (super(e), 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(e) {
+    return e.year;
+  }
+  /** Gets the month of the input date. */
+  getMonth(e) {
+    return e.month;
+  }
+  /** Gets the day of the input date. */
+  getDate(e) {
+    return e.day;
+  }
+  /** Gets the day of the week of the input date. */
+  getDayOfWeek(e) {
+    return e.dayOfWeek % 7;
+  }
+  /** Gets the date in the local format. */
+  getAccessibilityFormatDate(e) {
+    const r = {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    };
+    return this.deserialize(e).toLocaleString(a.current, r);
+  }
+  /**
+   * 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(e) {
+    const r = new Intl.DateTimeFormat(a.current, { month: e });
+    return this._range(12, (t) => r.format(Temporal.PlainDate.from({ year: 2017, month: t + 1, day: 1 })));
+  }
+  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */
+  getDateNames() {
+    const e = new Intl.DateTimeFormat(a.current, { day: "numeric" });
+    return this._range(31, (r) => e.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: r + 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(e) {
+    const r = new Intl.DateTimeFormat(a.current, { weekday: e });
+    return this._range(7, (t) => r.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: t + 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(e) {
+    return e.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(e, r, t) {
+    if (r < 1 || r > 12)
+      throw Error(`Invalid month "${r}". Month has to be between 1 and 12.`);
+    if (t < 1)
+      throw Error(`Invalid day "${t}". Day has to be greater than 0.`);
+    try {
+      return Temporal.PlainDate.from({ year: e, month: r, day: t }, { overflow: "reject" });
+    } catch {
+      throw Error(`Invalid date "${t}" for month with index "${r}".`);
+    }
+  }
+  /** Checks whether the given `obj` is a Temporal.PlainDate. */
+  isDateInstance(e) {
+    return e instanceof Temporal.PlainDate;
+  }
+  /** Checks whether the given `date` is a valid Temporal.PlainDate. */
+  isValid(e) {
+    return this.isDateInstance(e);
+  }
+  /** Creates a new date by cloning the given one. */
+  clone(e) {
+    return Temporal.PlainDate.from(e);
+  }
+  /**
+   * 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(e, r) {
+    return e.add({ years: r });
+  }
+  /**
+   * 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(e, r) {
+    return e.add({ months: r });
+  }
+  /** Creates a new date by adding the number of provided `days` to the provided `date`. */
+  addCalendarDays(e, r) {
+    return e.add({ days: r });
+  }
+  /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */
+  deserialize(e) {
+    if (typeof e == "string")
+      if (e) {
+        if (i.test(e))
+          return this.getValidDateOrNull(Temporal.PlainDate.from(e.split("T")[0]));
+      } else return null;
+    return super.deserialize(e);
+  }
+  invalid() {
+    return null;
+  }
+  toIso8601(e) {
+    return e.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(e, r) {
+    return Array.from({ length: e }).map((t, n) => r(n));
+  }
+}
+export {
+  d as TemporalDateAdapter
+};

package/core/datetime.js

@@ -0,0 +1,16 @@
+import { DAYS_PER_ROW as A, DateAdapter as _, FORMAT_DATE as R, ISO8601_FORMAT_DATE as a, MONTHS_PER_PAGE as r, MONTHS_PER_ROW as E, YEARS_PER_PAGE as p, YEARS_PER_ROW as O } from "./datetime/date-adapter.js";
+import { NativeDateAdapter as D, defaultDateAdapter as P } from "./datetime/native-date-adapter.js";
+import { TemporalDateAdapter as S } from "./datetime/temporal-date-adapter.js";
+export {
+  A as DAYS_PER_ROW,
+  _ as DateAdapter,
+  R as FORMAT_DATE,
+  a as ISO8601_FORMAT_DATE,
+  r as MONTHS_PER_PAGE,
+  E as MONTHS_PER_ROW,
+  D as NativeDateAdapter,
+  S as TemporalDateAdapter,
+  p as YEARS_PER_PAGE,
+  O as YEARS_PER_ROW,
+  P as defaultDateAdapter
+};

package/core/decorators/base.js

@@ -0,0 +1 @@
+

package/core/decorators/force-type.js

@@ -0,0 +1,17 @@
+const o = (e) => (i, l) => {
+  const { kind: r, metadata: s, name: a } = l, n = globalThis.litPropertyMetadata.get(s)?.get(a)?.type ?? String;
+  if (e ??= n, e === String ? e = (t) => t == null ? "" : String(t) : e === Number && (e = (t) => t == null ? NaN : Number(t)), r === "accessor")
+    return {
+      set(t) {
+        i.set.call(this, e(t));
+      }
+    };
+  if (r === "setter")
+    return function(t) {
+      i.call(this, e(t));
+    };
+  throw new Error(`Unsupported decorator location: ${r}`);
+};
+export {
+  o as forceType
+};

package/core/decorators/get-override.js

@@ -0,0 +1,14 @@
+const c = (t) => (e, n) => {
+  const { kind: r } = n;
+  if (r === "accessor")
+    return {
+      get() {
+        const o = e.get.call(this);
+        return t(this, o);
+      }
+    };
+  throw new Error(`Unsupported decorator location: ${r}`);
+};
+export {
+  c as getOverride
+};

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

@@ -0,0 +1,16 @@
+const a = (c) => (n, s) => {
+  const { kind: t } = s;
+  if (t === "accessor")
+    return {
+      set(o) {
+        const e = s.access.get(this);
+        n.set.call(this, o);
+        const r = s.access.get(this);
+        r !== e && c(this, r, e);
+      }
+    };
+  throw new Error(`Unsupported decorator location: ${t}`);
+};
+export {
+  a as handleDistinctChange
+};

package/core/decorators/host-attributes.js

@@ -0,0 +1,18 @@
+import { isServer as i } from "lit";
+function l(o, t) {
+  for (const [e, r] of Object.entries(t))
+    r ? o.setAttribute(e, r) : o.toggleAttribute(e, r !== null);
+}
+const f = (o) => (t) => t.addInitializer((e) => {
+  i ? l(e, o) : e.addController({
+    hostConnected() {
+      l(e, o), e.removeController(this);
+    },
+    hostUpdate() {
+      l(e, o), e.removeController(this);
+    }
+  });
+});
+export {
+  f as hostAttributes
+};

package/core/decorators/id-reference.js

@@ -0,0 +1,76 @@
+import { isServer as b } from "lit";
+const c = /* @__PURE__ */ new WeakMap(), h = /* @__PURE__ */ new WeakMap(), y = () => (g, n) => {
+  const { kind: l, metadata: N, name: a } = n;
+  if (l === "accessor") {
+    if (b)
+      return {};
+    const f = globalThis.litPropertyMetadata.get(N)?.get(a)?.attribute, s = typeof f == "string" ? f : a;
+    return n.addInitializer(function() {
+      this.addController({
+        host: this,
+        rootNode: null,
+        checkIdReference(t) {
+          const e = this.host.getAttribute(s) ?? h.get(this.host);
+          if (e && typeof e == "string" && (!t || t.has(e))) {
+            const i = this.rootNode?.getElementById?.(e) ?? null;
+            n.access.get(this.host) !== i && n.access.set(this.host, i);
+          }
+        },
+        hostConnected() {
+          this.rootNode = this.host.getRootNode(), this.checkIdReference();
+          const t = c.get(this.rootNode);
+          if (t)
+            t.controllers.add(this);
+          else {
+            const e = /* @__PURE__ */ new Set([this]), i = new MutationObserver((m) => {
+              const r = /* @__PURE__ */ new Set();
+              for (const o of m)
+                if (o.type === "attributes")
+                  o.oldValue && r.add(o.oldValue), o.target.id && r.add(o.target.id);
+                else if (o.type === "childList")
+                  for (const d of [...o.addedNodes, ...o.removedNodes])
+                    d instanceof HTMLElement && (d.id && r.add(d.id), d.querySelectorAll("[id]").forEach((u) => {
+                      u.id && r.add(u.id);
+                    }));
+              e.forEach((o) => o.checkIdReference(r));
+            });
+            i.observe(this.rootNode, {
+              attributeFilter: ["id"],
+              attributeOldValue: !0,
+              childList: !0,
+              subtree: !0
+            }), c.set(this.rootNode, { observer: i, controllers: e });
+          }
+        },
+        hostDisconnected() {
+          if (b || !this.rootNode)
+            return;
+          const t = c.get(this.rootNode);
+          if (!t) {
+            this.rootNode = null;
+            return;
+          }
+          t.controllers.delete(this), t.controllers.size === 0 && (t.observer.disconnect(), c.delete(this.rootNode)), this.rootNode = null;
+        }
+      });
+    }), {
+      set(t) {
+        if (typeof t != "string")
+          h.delete(this), t instanceof HTMLElement && this.hasAttribute(s) && t.id !== this.getAttribute(s) && this.removeAttribute(s);
+        else {
+          if (this.hasAttribute(s) && this.getAttribute(s) !== t)
+            return;
+          {
+            const e = t ? this.getRootNode?.()?.getElementById?.(t) : null;
+            e ? t = e : t && (h.set(this, t), t = null);
+          }
+        }
+        g.set.call(this, t);
+      }
+    };
+  }
+  throw new Error(`Unsupported decorator location: ${l}`);
+};
+export {
+  y as idReference
+};

package/core/decorators/omit-empty-converter.js

@@ -0,0 +1,9 @@
+import { defaultConverter as o } from "lit";
+const n = {
+  toAttribute(r, t) {
+    return (t === String || t === void 0) && r === "" || t === Number && isNaN(r) ? null : o.toAttribute(r, t);
+  }
+};
+export {
+  n as omitEmptyConverter
+};

package/core/decorators/plain-date.js

@@ -0,0 +1,26 @@
+import { readConfig as d } from "../config.js";
+import { defaultDateAdapter as n } from "../datetime.js";
+const p = {
+  toAttribute(r, o) {
+    const a = d().datetime?.dateAdapter ?? n;
+    return a.isValid(r) ? a.toIso8601(r) : null;
+  }
+}, l = (r) => (o, a) => {
+  const { kind: i } = a;
+  if (i === "accessor")
+    return {
+      set(t) {
+        const e = d().datetime?.dateAdapter ?? n;
+        t = e.getValidDateOrNull(e.deserialize(t)), t = t ? e.createDate(e.getYear(t), e.getMonth(t), e.getDate(t)) : null, o.set.call(this, t);
+      },
+      get() {
+        const t = d().datetime?.dateAdapter ?? n, e = o.get.call(this);
+        return t.isValid(e) ? t.clone(e) : r?.fallback?.(t);
+      }
+    };
+  throw new Error(`Unsupported decorator location: ${i}`);
+};
+export {
+  l as plainDate,
+  p as plainDateConverter
+};

package/core/decorators.js

@@ -0,0 +1,17 @@
+import { forceType as t } from "./decorators/force-type.js";
+import { getOverride as p } from "./decorators/get-override.js";
+import { handleDistinctChange as m } from "./decorators/handle-distinct-change.js";
+import { hostAttributes as n } from "./decorators/host-attributes.js";
+import { idReference as a } from "./decorators/id-reference.js";
+import { omitEmptyConverter as d } from "./decorators/omit-empty-converter.js";
+import { plainDate as l, plainDateConverter as s } from "./decorators/plain-date.js";
+export {
+  t as forceType,
+  p as getOverride,
+  m as handleDistinctChange,
+  n as hostAttributes,
+  a as idReference,
+  d as omitEmptyConverter,
+  l as plainDate,
+  s as plainDateConverter
+};

package/core/dom/animation.js

@@ -0,0 +1,10 @@
+import { isServer as i } from "lit";
+function n(t, r) {
+  if (i || globalThis.disableAnimation)
+    return !0;
+  const e = getComputedStyle(t).getPropertyValue(r);
+  return parseFloat(e) === 0;
+}
+export {
+  n as isZeroAnimationDuration
+};

package/core/dom/contains-pierce-shadow-dom.js

@@ -0,0 +1,12 @@
+function n(t, o) {
+  let e = o;
+  for (; e; ) {
+    if (e === t)
+      return !0;
+    e = e instanceof ShadowRoot ? e.host : e.parentNode;
+  }
+  return !1;
+}
+export {
+  n as containsPierceShadowDom
+};

package/core/dom/lean-context.js

@@ -0,0 +1,7 @@
+import { isServer as e } from "lit";
+function t() {
+  return !e && document.documentElement.classList.contains("sbb-lean");
+}
+export {
+  t as isLean
+};