@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/datepicker/datepicker-toggle.js

@@ -0,0 +1,234 @@
+import { css, LitElement, isServer, html, nothing } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { ref } from "lit/directives/ref.js";
+import { sbbInputModalityDetector } from "../core/a11y.js";
+import { SbbLanguageController } from "../core/controllers.js";
+import { hostAttributes } from "../core/decorators.js";
+import { i18nShowCalendar } from "../core/i18n.js";
+import { SbbNegativeMixin, SbbHydrationMixin } from "../core/mixins.js";
+import { getDatePicker, datepickerControlRegisteredEventFactory } from "./datepicker.js";
+import "../calendar.js";
+import "../popover.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-datepicker-control-radius: var(--sbb-border-radius-4x);
+  --sbb-datepicker-control-color: var(--sbb-color-black);
+  display: inline-flex;
+}
+
+sbb-popover-trigger {
+  --sbb-button-display: flex;
+  color: var(--sbb-datepicker-control-color);
+  height: unset;
+}
+
+sbb-icon {
+  color: var(--sbb-color-graphite);
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+let SbbDatepickerToggleElement = class extends SbbNegativeMixin(SbbHydrationMixin(LitElement)) {
+  constructor() {
+    super();
+    this._disabled = false;
+    this._min = null;
+    this._max = null;
+    this._renderCalendar = false;
+    this._language = new SbbLanguageController(this);
+    if (!isServer) {
+      this.hydrationComplete.then(() => this._renderCalendar = true);
+    }
+  }
+  /**
+   * Opens the calendar.
+   */
+  open() {
+    if (!this._triggerElement) {
+      this._triggerElement = this.shadowRoot.querySelector("sbb-popover-trigger");
+    }
+    this._triggerElement.click();
+  }
+  connectedCallback() {
+    var _a, _b;
+    super.connectedCallback();
+    if (!this.datePicker) {
+      this._init();
+    }
+    const formField = ((_a = this.closest) == null ? void 0 : _a.call(this, "sbb-form-field")) ?? ((_b = this.closest) == null ? void 0 : _b.call(this, "[data-form-field]"));
+    if (formField) {
+      this.negative = formField.hasAttribute("negative");
+    }
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("datePicker")) {
+      this._init(this.datePicker);
+    }
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this._datePickerController) == null ? void 0 : _a.abort();
+  }
+  _init(datePicker) {
+    var _a, _b, _c, _d, _e;
+    (_a = this._datePickerController) == null ? void 0 : _a.abort();
+    this._datePickerController = new AbortController();
+    this._datePickerElement = getDatePicker(this, datePicker);
+    if (!this._datePickerElement) {
+      (_b = this.parentElement) == null ? void 0 : _b.addEventListener(
+        "inputUpdated",
+        (e) => this._init(e.target),
+        { once: true, signal: this._datePickerController.signal }
+      );
+      return;
+    }
+    (_c = this._datePickerElement) == null ? void 0 : _c.addEventListener(
+      "inputUpdated",
+      (event) => {
+        this._datePickerElement = event.target;
+        this._disabled = !!(event.detail.disabled || event.detail.readonly);
+        this._min = event.detail.min;
+        this._max = event.detail.max;
+      },
+      { signal: this._datePickerController.signal }
+    );
+    (_d = this._datePickerElement) == null ? void 0 : _d.addEventListener(
+      "change",
+      (event) => this._datePickerChanged(event),
+      {
+        signal: this._datePickerController.signal
+      }
+    );
+    (_e = this._datePickerElement) == null ? void 0 : _e.addEventListener(
+      "datePickerUpdated",
+      (event) => this._configureCalendar(this._calendarElement, event.target),
+      { signal: this._datePickerController.signal }
+    );
+    this._datePickerElement.dispatchEvent(datepickerControlRegisteredEventFactory());
+  }
+  _configureCalendar(calendar, datepicker) {
+    if (!calendar || !datepicker) {
+      return;
+    }
+    calendar.wide = datepicker.wide;
+    calendar.now = this._nowOrUndefined();
+    calendar.dateFilter = datepicker.dateFilter;
+  }
+  _datePickerChanged(event) {
+    this._datePickerElement = event.target;
+    this._calendarElement.selected = this._datePickerElement.getValueAsDate();
+  }
+  _assignCalendar(calendar) {
+    var _a;
+    if (this._calendarElement && this._calendarElement === calendar) {
+      return;
+    }
+    this._calendarElement = calendar;
+    if (!this._datePickerElement || !this._datePickerElement.getValueAsDate || !((_a = this._calendarElement) == null ? void 0 : _a.resetPosition)) {
+      return;
+    }
+    this._calendarElement.selected = this._datePickerElement.getValueAsDate();
+    this._configureCalendar(this._calendarElement, this._datePickerElement);
+    this._calendarElement.resetPosition();
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    this._popoverElement.trigger = this._triggerElement;
+  }
+  _nowOrUndefined() {
+    var _a;
+    return ((_a = this._datePickerElement) == null ? void 0 : _a.hasCustomNow()) ? this._datePickerElement.now : void 0;
+  }
+  render() {
+    var _a, _b;
+    return html`
+      <sbb-popover-trigger
+        icon-name="calendar-small"
+        aria-label=${i18nShowCalendar[this._language.current]}
+        ?disabled=${!isServer && (!this._datePickerElement || this._disabled)}
+        ?negative=${this.negative}
+        data-icon-small
+        ${ref((el) => this._triggerElement = el)}
+      ></sbb-popover-trigger>
+      <sbb-popover
+        @willOpen=${() => this._calendarElement.resetPosition()}
+        @didOpen=${() => {
+      sbbInputModalityDetector.mostRecentModality === "keyboard" && this._calendarElement.focus();
+    }}
+        .trigger=${this._triggerElement}
+        hide-close-button
+        ${ref((el) => this._popoverElement = el)}
+      >
+        ${this._renderCalendar ? html`<sbb-calendar
+              .min=${this._min}
+              .max=${this._max}
+              .now=${this._nowOrUndefined()}
+              ?wide=${(_a = this._datePickerElement) == null ? void 0 : _a.wide}
+              .dateFilter=${(_b = this._datePickerElement) == null ? void 0 : _b.dateFilter}
+              @dateSelected=${(d) => {
+      var _a2;
+      const newDate = new Date(d.detail);
+      this._calendarElement.selected = newDate;
+      (_a2 = this._datePickerElement) == null ? void 0 : _a2.setValueAsDate(newDate);
+    }}
+              ${ref((calendar) => this._assignCalendar(calendar))}
+            ></sbb-calendar>` : nothing}
+      </sbb-popover>
+    `;
+  }
+};
+SbbDatepickerToggleElement.styles = style;
+__decorateClass([
+  property({ attribute: "date-picker" })
+], SbbDatepickerToggleElement.prototype, "datePicker", 2);
+__decorateClass([
+  state()
+], SbbDatepickerToggleElement.prototype, "_disabled", 2);
+__decorateClass([
+  state()
+], SbbDatepickerToggleElement.prototype, "_min", 2);
+__decorateClass([
+  state()
+], SbbDatepickerToggleElement.prototype, "_max", 2);
+__decorateClass([
+  state()
+], SbbDatepickerToggleElement.prototype, "_renderCalendar", 2);
+SbbDatepickerToggleElement = __decorateClass([
+  customElement("sbb-datepicker-toggle"),
+  hostAttributes({
+    slot: "prefix"
+  })
+], SbbDatepickerToggleElement);
+export {
+  SbbDatepickerToggleElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"datepicker-toggle.js","sources":["../../../../src/elements/datepicker/datepicker-toggle/datepicker-toggle.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, isServer, LitElement, nothing } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport type { SbbCalendarElement } from '../../calendar.js';\nimport { sbbInputModalityDetector } from '../../core/a11y.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { i18nShowCalendar } from '../../core/i18n.js';\nimport { SbbHydrationMixin, SbbNegativeMixin } from '../../core/mixins.js';\nimport type { SbbPopoverElement, SbbPopoverTriggerElement } from '../../popover.js';\nimport type { SbbDatepickerElement, SbbInputUpdateEvent } from '../datepicker.js';\nimport { datepickerControlRegisteredEventFactory, getDatePicker } from '../datepicker.js';\n\nimport style from './datepicker-toggle.scss?lit&inline';\n\nimport '../../calendar.js';\nimport '../../popover.js';\n\n/**\n * Combined with a `sbb-datepicker`, it can be used to select a date from a `sbb-calendar`.\n */\n@customElement('sbb-datepicker-toggle')\n@hostAttributes({\n  slot: 'prefix',\n})\nexport class SbbDatepickerToggleElement extends SbbNegativeMixin(SbbHydrationMixin(LitElement)) {\n  public static override styles: CSSResultGroup = style;\n\n  /** Datepicker reference. */\n  @property({ attribute: 'date-picker' }) public datePicker?: string | SbbDatepickerElement;\n\n  @state() private _disabled = false;\n\n  @state() private _min: string | number | null | undefined = null;\n\n  @state() private _max: string | number | null | undefined = null;\n\n  @state() private _renderCalendar = false;\n\n  private _datePickerElement: SbbDatepickerElement | null | undefined;\n\n  private _calendarElement!: SbbCalendarElement;\n\n  private _triggerElement!: SbbPopoverTriggerElement;\n\n  private _popoverElement!: SbbPopoverElement;\n\n  private _datePickerController!: AbortController;\n\n  private _language = new SbbLanguageController(this);\n\n  public constructor() {\n    super();\n    if (!isServer) {\n      this.hydrationComplete.then(() => (this._renderCalendar = true));\n    }\n  }\n\n  /**\n   * Opens the calendar.\n   */\n  public open(): void {\n    if (!this._triggerElement) {\n      this._triggerElement = this.shadowRoot!.querySelector('sbb-popover-trigger')!;\n    }\n    this._triggerElement.click();\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    if (!this.datePicker) {\n      this._init();\n    }\n\n    const formField = this.closest?.('sbb-form-field') ?? this.closest?.('[data-form-field]');\n    if (formField) {\n      this.negative = formField.hasAttribute('negative');\n    }\n  }\n\n  public override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('datePicker')) {\n      this._init(this.datePicker);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._datePickerController?.abort();\n  }\n\n  private _init(datePicker?: string | SbbDatepickerElement): void {\n    this._datePickerController?.abort();\n    this._datePickerController = new AbortController();\n    this._datePickerElement = getDatePicker(this, datePicker);\n    if (!this._datePickerElement) {\n      // If the component is attached to the DOM before the datepicker, it has to listen for the datepicker init,\n      // assuming that the two components share the same parent element.\n      this.parentElement?.addEventListener(\n        'inputUpdated',\n        (e: Event) => this._init(e.target as SbbDatepickerElement),\n        { once: true, signal: this._datePickerController.signal },\n      );\n      return;\n    }\n\n    this._datePickerElement?.addEventListener(\n      'inputUpdated',\n      (event: CustomEvent<SbbInputUpdateEvent>) => {\n        this._datePickerElement = event.target as SbbDatepickerElement;\n        this._disabled = !!(event.detail.disabled || event.detail.readonly);\n        this._min = event.detail.min;\n        this._max = event.detail.max;\n      },\n      { signal: this._datePickerController.signal },\n    );\n    this._datePickerElement?.addEventListener(\n      'change',\n      (event: Event) => this._datePickerChanged(event),\n      {\n        signal: this._datePickerController.signal,\n      },\n    );\n    this._datePickerElement?.addEventListener(\n      'datePickerUpdated',\n      (event: Event) =>\n        this._configureCalendar(this._calendarElement, event.target as SbbDatepickerElement),\n      { signal: this._datePickerController.signal },\n    );\n    this._datePickerElement.dispatchEvent(datepickerControlRegisteredEventFactory());\n  }\n\n  private _configureCalendar(calendar: SbbCalendarElement, datepicker: SbbDatepickerElement): void {\n    if (!calendar || !datepicker) {\n      return;\n    }\n    calendar.wide = datepicker.wide;\n    calendar.now = this._nowOrUndefined();\n    calendar.dateFilter = datepicker.dateFilter;\n  }\n\n  private _datePickerChanged(event: Event): void {\n    this._datePickerElement = event.target as SbbDatepickerElement;\n    this._calendarElement.selected = this._datePickerElement.getValueAsDate();\n  }\n\n  private _assignCalendar(calendar: SbbCalendarElement): void {\n    if (this._calendarElement && this._calendarElement === calendar) {\n      return;\n    }\n    this._calendarElement = calendar;\n    if (\n      !this._datePickerElement ||\n      !this._datePickerElement.getValueAsDate ||\n      !this._calendarElement?.resetPosition\n    ) {\n      return;\n    }\n    this._calendarElement.selected = this._datePickerElement.getValueAsDate();\n    this._configureCalendar(this._calendarElement, this._datePickerElement);\n    this._calendarElement.resetPosition();\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n\n    this._popoverElement.trigger = this._triggerElement;\n  }\n\n  private _nowOrUndefined(): Date | undefined {\n    return this._datePickerElement?.hasCustomNow() ? this._datePickerElement.now : undefined;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <sbb-popover-trigger\n        icon-name=\"calendar-small\"\n        aria-label=${i18nShowCalendar[this._language.current]}\n        ?disabled=${!isServer && (!this._datePickerElement || this._disabled)}\n        ?negative=${this.negative}\n        data-icon-small\n        ${ref((el?: Element) => (this._triggerElement = el as SbbPopoverTriggerElement))}\n      ></sbb-popover-trigger>\n      <sbb-popover\n        @willOpen=${() => this._calendarElement.resetPosition()}\n        @didOpen=${() => {\n          sbbInputModalityDetector.mostRecentModality === 'keyboard' &&\n            this._calendarElement.focus();\n        }}\n        .trigger=${this._triggerElement}\n        hide-close-button\n        ${ref((el?: Element) => (this._popoverElement = el as SbbPopoverElement))}\n      >\n        ${this._renderCalendar\n          ? html`<sbb-calendar\n              .min=${this._min}\n              .max=${this._max}\n              .now=${this._nowOrUndefined()}\n              ?wide=${this._datePickerElement?.wide}\n              .dateFilter=${this._datePickerElement?.dateFilter}\n              @dateSelected=${(d: CustomEvent<Date>) => {\n                const newDate = new Date(d.detail);\n                this._calendarElement.selected = newDate;\n                this._datePickerElement?.setValueAsDate(newDate);\n              }}\n              ${ref((calendar?: Element) => this._assignCalendar(calendar as SbbCalendarElement))}\n            ></sbb-calendar>`\n          : nothing}\n      </sbb-popover>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-datepicker-toggle': SbbDatepickerToggleElement;\n  }\n}\n"],"names":["_a"],"mappings":"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"}

package/development/datepicker/datepicker.d.ts

@@ -0,0 +1,2 @@
+export * from './datepicker/datepicker.js';
+//# sourceMappingURL=datepicker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"datepicker.d.ts","sourceRoot":"","sources":["../../../../src/elements/datepicker/datepicker.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}