@golemui/gui-lit 1.0.3 → 1.1.0

package/range-date-time-calendar.element-C00aDefZ.js

@@ -0,0 +1,95 @@
+import { InputWidgetAdapter as d, formContext as m, inputContext as u } from "@golemui/lit";
+import "./range-date-time-calendar-yksWrR7b.js";
+import { consume as p, provide as h } from "@lit/context";
+import { LitElement as c, html as b } from "lit";
+import { property as $, customElement as g } from "lit/decorators.js";
+import "rxjs";
+var v = Object.defineProperty, f = Object.getOwnPropertyDescriptor, l = (e, t, s, r) => {
+  for (var a = r > 1 ? void 0 : r ? f(t, s) : t, n = e.length - 1, o; n >= 0; n--)
+    (o = e[n]) && (a = (r ? o(t, s, a) : o(a)) || a);
+  return r && a && v(t, s, a), a;
+};
+let i = class extends c {
+  constructor() {
+    super(...arguments), this.adapter = new d(), this.subscriptions = [];
+  }
+  createRenderRoot() {
+    return this;
+  }
+  updated(e) {
+    super.updated(e);
+    const t = this.adapter.templateData.size;
+    t ? this.style.flex = String(t) : this.style.removeProperty("flex");
+  }
+  connectedCallback() {
+    super.connectedCallback(), this.classList.add("gui-range-date-time-calendar", "gui-field"), this.adapter.context = this.formContext, this.adapter.init(this.widget), this.subscriptions.push(
+      this.adapter.templateDataChanged$.subscribe(() => this.requestUpdate())
+    );
+  }
+  render() {
+    super.render();
+    const e = this.adapter.templateData;
+    return b`
+      <gui-range-date-time-calendar
+        .uid=${this.widget.uid}
+        .label=${e.label}
+        .hint=${e.hint}
+        .errors=${e.errors}
+        ?touched=${e.touched}
+        ?required=${e.validator?.required}
+        ?disabled=${e.disabled}
+        ?readonly=${e.readonly}
+        .value=${e.value}
+        .prevMonthIcon=${e.prevMonthIcon}
+        .nextMonthIcon=${e.nextMonthIcon}
+        .prevMonthAriaLabel=${e.prevMonthAriaLabel}
+        .nextMonthAriaLabel=${e.nextMonthAriaLabel}
+        .dayFormat=${e.dayFormat}
+        .weekdayFormat=${e.weekdayFormat}
+        .monthFormat=${e.monthFormat}
+        .numberOfMonths=${e.numberOfMonths}
+        .removePillAriaLabel=${e.removePillAriaLabel}
+        .localeId=${e.lang}
+        .hourFormat=${e.hourFormat}
+        .minuteStep=${e.minuteStep}
+        ?allow-custom-time=${e.allowCustomTime}
+        .startTimeLabel=${e.startTimeLabel}
+        .endTimeLabel=${e.endTimeLabel}
+        .minDateTime=${e.minDateTime}
+        .maxDateTime=${e.maxDateTime}
+        .disabledRanges=${e.disabledRanges}
+        .minDateTimeMessage=${e.minDateTimeMessage}
+        .maxDateTimeMessage=${e.maxDateTimeMessage}
+        .disabledRangeMessage=${e.disabledRangeMessage}
+        .noAvailableTimesMessage=${e.noAvailableTimesMessage}
+        .dayCountAriaLabel=${e.dayCountAriaLabel}
+        .disabledDayCountAriaLabel=${e.disabledDayCountAriaLabel}
+        @change=${this.valueChanged}
+        @inputError=${this.onInputError}
+        @blur=${() => this.adapter.onBlur()}
+      ></gui-range-date-time-calendar>
+    `;
+  }
+  valueChanged(e) {
+    this.adapter.injectValidationIssues(null), this.adapter.valueChanged(e.detail.value);
+  }
+  onInputError(e) {
+    this.adapter.injectValidationIssues([e.detail.message]), this.adapter.onBlur();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.adapter.destroy(), this.subscriptions.forEach((e) => e.unsubscribe());
+  }
+};
+l([
+  p({ context: m }),
+  $({ attribute: !1 })
+], i.prototype, "formContext", 2);
+l([
+  h({ context: u })
+], i.prototype, "adapter", 2);
+i = l([
+  g("gui-range-date-time-calendar-input")
+], i);
+export {
+  i as RangeDateTimeCalendarElement
+};

package/range-date-time-input-B37TUoM3.js

@@ -0,0 +1,322 @@
+import { LitElement as g, nothing as p, html as u } from "lit";
+import { property as a, customElement as c } from "lit/decorators.js";
+import { classMap as v } from "lit/directives/class-map.js";
+import { styleMap as y } from "lit-html/directives/style-map.js";
+import { G as b, b as f, c as D } from "./templates-Dk1jxLwS.js";
+import { G as T, g as E, a as _, r as h, f as P, p as m, b as S, d as R, m as C, c as k, o as $ } from "./part-templates-Db871PS3.js";
+import { c as A } from "./range-commit-8-MmYUyo.js";
+import { r as L, f as I, b as M, a as w, s as B } from "./pill-ranges-DCqDmpkk.js";
+import "./pills-Be1UrLgq.js";
+import { D as F } from "./date-Bj9mI3GU.js";
+var O = Object.defineProperty, x = Object.getOwnPropertyDescriptor, i = (t, s, l, r) => {
+  for (var o = r > 1 ? void 0 : r ? x(s, l) : s, n = t.length - 1, d; n >= 0; n--)
+    (d = t[n]) && (o = (r ? d(s, l, o) : d(o)) || o);
+  return r && o && O(s, l, o), o;
+};
+let e = class extends g {
+  constructor() {
+    super(...arguments), this.uid = void 0, this.label = void 0, this.localeId = void 0, this.errors = [], this.showErrors = !0, this.touched = !1, this.required = !1, this.disabled = !1, this.readOnly = !1, this.icon = "", this.hint = void 0, this.hourFormat = void 0, this.minuteStep = 1, this.invalidDateMessage = void 0, this.value = [], this.removePillAriaLabel = void 0, this.startDateTimeAriaLabel = void 0, this.endDateTimeAriaLabel = void 0, this.separator = void 0, this.minDateTime = void 0, this.maxDateTime = void 0, this.minDateTimeMessage = void 0, this.maxDateTimeMessage = void 0, this.disabledRanges = void 0, this.disabledRangeMessage = void 0, this.inputBlockClass = "gui-range-date-time-input", this.groups = ["start", "end"], this._validationTriggered = !1, this._parts = new T(this, {
+      blockClass: this.inputBlockClass,
+      groups: this.groups,
+      getDescriptor: (t) => this.getPartDescriptor(t),
+      commitGroup: () => {
+        this._validationTriggered ? this.revalidate() : this.syncParts();
+      },
+      isReadonly: () => !!this.readOnly,
+      isDisabled: () => !!this.disabled,
+      onEmptyPartBlur: () => {
+      },
+      onEnter: () => {
+        this.tryCreatePill(), this.value && this.value.length > 0 && this.onPillClick(this.value[this.value.length - 1]);
+      },
+      getHourFormat: () => this.localeData.effectiveHourFormat,
+      getDayPeriodLabels: () => this.localeData.dayPeriodLabels,
+      onInputErrorSurfaced: (t) => this.dispatchEvent(new CustomEvent("inputError", { detail: { message: t }, bubbles: !0 })),
+      onSurfacedErrorCleared: (t) => this.dispatchEvent(
+        new CustomEvent("change", { detail: { value: t }, bubbles: !0, composed: !0 })
+      )
+    }), this.ariaController = new b(this, {
+      getTargets: () => this.querySelectorAll(`.${this.inputBlockClass}`),
+      getState: () => ({
+        uid: this.uid,
+        templateData: {
+          hint: this.hint,
+          errors: this.errors,
+          readonly: this.readOnly,
+          disabled: this.disabled,
+          touched: this.touched
+        }
+      })
+    }), this.onPillRemoveEvent = (t) => {
+      if (this.disabled || this.readOnly) return;
+      const s = L(this.value, t.detail.key);
+      s && (this.value = s.next, this.dispatchEvent(
+        new CustomEvent("change", { detail: { value: this.value }, bubbles: !0, composed: !0 })
+      ), s.next.length === 0 && requestAnimationFrame(() => {
+        this.querySelector(".gui-range-date-time-input__field input")?.focus();
+      }));
+    }, this.onPillClickEvent = (t) => {
+      const s = I(this.getSortedPills(), t.detail.key);
+      s && this.onPillClick(s);
+    };
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback(), this.classList.add("gui-field");
+  }
+  get localeData() {
+    return E(this.localeId, this.hourFormat, this.minuteStep, !0);
+  }
+  getPartDescriptor(t) {
+    return this.localeData.descriptors[t];
+  }
+  willUpdate(t) {
+    (!this.hasUpdated || t.has("hourFormat") || t.has("localeId")) && this._parts.seedDayPeriods();
+  }
+  render() {
+    const t = {
+      uid: this.uid,
+      label: this.label,
+      errors: this.errors,
+      touched: this.touched,
+      required: this.required,
+      disabled: this.disabled,
+      readonly: this.readOnly,
+      value: this.value,
+      hint: this.hint
+    }, s = {
+      blockClass: this.inputBlockClass,
+      groups: this.groups,
+      formatParts: _(this.localeId, this.localeData.effectiveHourFormat),
+      getDescriptor: (o) => this.getPartDescriptor(o),
+      getDisplayValue: this._parts.getPartDisplay,
+      required: this.required,
+      disabled: this.disabled,
+      partsReadonly: !!this.readOnly
+    }, l = M(
+      this.getSortedPills(),
+      (o) => w(o, (n) => this.formatDateTimeForDisplay(n)),
+      this.removePillAriaLabel ?? "Remove date-time"
+    ), r = {
+      "gui-widget-icon": !0,
+      [this.icon]: !!this.icon
+    };
+    return u`
+      ${this.label ? f(this.uid, t, !1, void 0, !1) : p}
+
+      <div class="gui-widget">
+        <div
+          class="gui-widget-input gui-parts-ring gui-range-date-time-input ${this.icon ? "gui-range-date-time-input--icon" : ""}"
+          role="group"
+          aria-label=${this.label ?? "Date-time range input"}
+        >
+          ${this.icon ? u`<span class=${v(r)} data-icon=${this.icon}></span>` : p}
+
+          <gui-pills
+            class="gui-range-date-time-input__pills"
+            style=${y(l.length ? {} : { "min-width": 0 })}
+            .items=${l}
+            .removable=${!0}
+            .clickable=${!0}
+            .bubble=${!0}
+            ?disabled=${this.disabled}
+            ?readonly=${this.readOnly}
+            .removeAriaLabel=${this.removePillAriaLabel ?? "Remove date-time"}
+            .compactAriaLabel=${`${l.length} date-time ranges`}
+            @pillremove=${this.onPillRemoveEvent}
+            @pillclick=${this.onPillClickEvent}
+          ></gui-pills>
+
+          <div class="gui-range-date-time-input__inputs">
+            <div
+              class="gui-parts gui-range-date-time-input__field"
+              role="group"
+              aria-label=${this.startDateTimeAriaLabel ?? "Start date-time"}
+            >
+              ${h("start", s, this._parts)}
+            </div>
+
+            <span class="gui-range-date-time-input__separator">${this.separator ?? "-"}</span>
+
+            <div
+              class="gui-parts gui-range-date-time-input__field"
+              role="group"
+              aria-label=${this.endDateTimeAriaLabel ?? "End date-time"}
+            >
+              ${h("end", s, this._parts)}
+            </div>
+          </div>
+        </div>
+
+        ${this.showErrors && this.errors?.length ? D(this.uid, t) : p}
+      </div>
+    `;
+  }
+  onPillClick(t) {
+    this.dispatchEvent(
+      new CustomEvent("pillClick", { detail: { range: t }, bubbles: !0, composed: !0 })
+    );
+  }
+  formatDateTimeForDisplay(t) {
+    return P(t, this.localeId, this.localeData.effectiveHourFormat);
+  }
+  getSortedPills() {
+    return B(
+      this.value,
+      (t, s) => m(t).getTime() - m(s).getTime()
+    );
+  }
+  /**
+   * Parses a group into an ISO date-time via the shared clamp/bounds pipeline,
+   * distinguishing an incomplete group (nothing to report) from a
+   * complete-but-rejected one (an impossible date or an out-of-bounds
+   * date-time). It does not emit: the caller decides whether to surface or
+   * clear an error, so fixing one group clears its error even while the other
+   * is still empty.
+   *
+   * Each endpoint is an instant, so it is bounded by instants. A date-only
+   * bound could not express this: `maxDate: 2026-02-10` is ambiguous about
+   * whether the 10th is allowed until 00:00 or 23:59, and independent date/time
+   * axes would wrongly reject Feb 11 08:00 for a `minTime` of 09:00.
+   */
+  validateDateTimeParts(t) {
+    const { effectiveHourFormat: s, descriptors: l } = this.localeData, { result: r, writeBacks: o } = S(this._parts.values[t] ?? {}, {
+      hourFormat: s,
+      descriptors: l,
+      invalidDateMessage: this.invalidDateMessage
+    });
+    if (this._parts.applyWriteBacks(t, o), r.kind === "incomplete") return { kind: "incomplete" };
+    if (r.kind === "invalid") return { kind: "invalid", message: r.message };
+    const n = R(r.iso, this.minDateTime, this.maxDateTime, {
+      minDateTimeMessage: this.minDateTimeMessage,
+      maxDateTimeMessage: this.maxDateTimeMessage
+    });
+    return n ? { kind: "invalid", message: n } : { kind: "valid", value: r.iso };
+  }
+  /**
+   * Re-parses both endpoints so per-endpoint problems (impossible date-time,
+   * out of instant bounds) surface while the user types. Runs on every part
+   * change.
+   */
+  syncParts() {
+    return {
+      start: this.validateDateTimeParts("start"),
+      end: this.validateDateTimeParts("end")
+    };
+  }
+  /**
+   * Parses the range and updates the error state, without ever committing.
+   * Shared by the Enter commit and by {@link revalidate}.
+   */
+  evaluateRange() {
+    const { start: t, end: s } = this.syncParts(), l = A(t, s, this.value, {
+      // Date-time ranges are two instants: a backward selection reorders (swap)
+      // rather than erroring — mirroring the range calendar's date swap.
+      order: (r, o) => {
+        const n = $(r, o);
+        return { start: n.start, end: n.end };
+      },
+      validate: (r) => k({ start: r.start, end: r.end }, this.disabledRanges) ? this.disabledRangeMessage ?? F : null,
+      toRange: (r) => ({ start: r.start, end: r.end }),
+      merge: C
+    });
+    return l.kind === "invalid" && this._parts.surfaceInputError(l.message), l.kind === "incomplete" && this._parts.clearSurfacedInputError(this.value ?? []), l;
+  }
+  /**
+   * Once the user has attempted a commit, every later edit re-runs validation
+   * so a corrected range clears its error immediately, otherwise the message
+   * would linger until the next Enter and the user could not tell the problem
+   * was solved.
+   */
+  revalidate() {
+    this.evaluateRange().kind === "commit" && this._parts.clearSurfacedInputError(this.value ?? []);
+  }
+  tryCreatePill() {
+    this._validationTriggered = !0;
+    const t = this.evaluateRange();
+    t.kind === "commit" && (this.value = t.value, this._validationTriggered = !1, this._parts.clearGroup("start"), this._parts.clearGroup("end"), this._parts.seedDayPeriods(), this._parts.resetSurfacedInputError(), this.dispatchEvent(
+      new CustomEvent("change", { detail: { value: this.value }, bubbles: !0, composed: !0 })
+    ), this._parts.focusFirst("start"), this.requestUpdate());
+  }
+};
+i([
+  a({ type: String })
+], e.prototype, "uid", 2);
+i([
+  a({ type: String })
+], e.prototype, "label", 2);
+i([
+  a({ type: String, attribute: "locale-id" })
+], e.prototype, "localeId", 2);
+i([
+  a({ type: Array })
+], e.prototype, "errors", 2);
+i([
+  a({ type: Boolean })
+], e.prototype, "showErrors", 2);
+i([
+  a({ type: Boolean })
+], e.prototype, "touched", 2);
+i([
+  a({ type: Boolean })
+], e.prototype, "required", 2);
+i([
+  a({ type: Boolean })
+], e.prototype, "disabled", 2);
+i([
+  a({ type: Boolean, attribute: "readonly" })
+], e.prototype, "readOnly", 2);
+i([
+  a({ type: String })
+], e.prototype, "icon", 2);
+i([
+  a({ type: String })
+], e.prototype, "hint", 2);
+i([
+  a({ type: String, attribute: "hour-format" })
+], e.prototype, "hourFormat", 2);
+i([
+  a({ type: Number, attribute: "minute-step" })
+], e.prototype, "minuteStep", 2);
+i([
+  a({ type: String, attribute: "invalid-date-message" })
+], e.prototype, "invalidDateMessage", 2);
+i([
+  a({ type: Array })
+], e.prototype, "value", 2);
+i([
+  a({ type: String })
+], e.prototype, "removePillAriaLabel", 2);
+i([
+  a({ type: String })
+], e.prototype, "startDateTimeAriaLabel", 2);
+i([
+  a({ type: String })
+], e.prototype, "endDateTimeAriaLabel", 2);
+i([
+  a({ type: String })
+], e.prototype, "separator", 2);
+i([
+  a({ type: String, attribute: "min-date-time" })
+], e.prototype, "minDateTime", 2);
+i([
+  a({ type: String, attribute: "max-date-time" })
+], e.prototype, "maxDateTime", 2);
+i([
+  a({ type: String, attribute: "min-date-time-message" })
+], e.prototype, "minDateTimeMessage", 2);
+i([
+  a({ type: String, attribute: "max-date-time-message" })
+], e.prototype, "maxDateTimeMessage", 2);
+i([
+  a({ type: Array, attribute: "disabled-ranges" })
+], e.prototype, "disabledRanges", 2);
+i([
+  a({ type: String, attribute: "disabled-range-message" })
+], e.prototype, "disabledRangeMessage", 2);
+e = i([
+  c("gui-range-date-time")
+], e);
+typeof customElements < "u" && !customElements.get("gui-range-date-time") && customElements.define("gui-range-date-time", e);

package/range-date-time-input.element-DUnbv4ed.js

@@ -0,0 +1,81 @@
+import { InputWidgetAdapter as n, formContext as m, inputContext as o } from "@golemui/lit";
+import "./range-date-time-input-B37TUoM3.js";
+import { consume as h, provide as u } from "@lit/context";
+import { LitElement as D, html as c } from "lit";
+import { property as g, customElement as $ } from "lit/decorators.js";
+import "rxjs";
+var b = Object.defineProperty, v = Object.getOwnPropertyDescriptor, d = (t, e, s, i) => {
+  for (var a = i > 1 ? void 0 : i ? v(e, s) : e, p = t.length - 1, l; p >= 0; p--)
+    (l = t[p]) && (a = (i ? l(e, s, a) : l(a)) || a);
+  return i && a && b(e, s, a), a;
+};
+let r = class extends D {
+  constructor() {
+    super(...arguments), this.adapter = new n(), this.subscriptions = [];
+  }
+  createRenderRoot() {
+    return this;
+  }
+  updated(t) {
+    super.updated(t);
+    const e = this.adapter.templateData.size;
+    e ? this.style.flex = String(e) : this.style.removeProperty("flex");
+  }
+  connectedCallback() {
+    super.connectedCallback(), this.classList.add("gui-range-date-time", "gui-field"), this.adapter.context = this.formContext, this.adapter.init(this.widget), this.subscriptions.push(
+      this.adapter.templateDataChanged$.subscribe(() => this.requestUpdate())
+    );
+  }
+  render() {
+    return super.render(), c`
+      <gui-range-date-time
+        .uid=${this.widget.uid}
+        .label=${this.adapter.templateData.label}
+        .hint=${this.adapter.templateData.hint}
+        .icon=${this.adapter.templateData.icon}
+        .errors=${this.adapter.templateData.errors}
+        ?touched=${this.adapter.templateData.touched}
+        ?required=${this.adapter.templateData.validator?.required}
+        ?disabled=${this.adapter.templateData.disabled}
+        ?readonly=${this.adapter.templateData.readonly}
+        .value=${this.adapter.templateData.value}
+        .localeId=${this.adapter.templateData.lang}
+        .separator=${this.adapter.templateData.separator}
+        .removePillAriaLabel=${this.adapter.templateData.removePillAriaLabel}
+        .startDateTimeAriaLabel=${this.adapter.templateData.startDateTimeAriaLabel}
+        .endDateTimeAriaLabel=${this.adapter.templateData.endDateTimeAriaLabel}
+        .hourFormat=${this.adapter.templateData.hourFormat}
+        .minuteStep=${this.adapter.templateData.minuteStep}
+        .minDateTime=${this.adapter.templateData.minDateTime}
+        .maxDateTime=${this.adapter.templateData.maxDateTime}
+        .invalidDateMessage=${this.adapter.templateData.invalidDateMessage}
+        .minDateTimeMessage=${this.adapter.templateData.minDateTimeMessage}
+        .maxDateTimeMessage=${this.adapter.templateData.maxDateTimeMessage}
+        @change=${this.valueChanged}
+        @inputError=${this.onInputError}
+      ></gui-range-date-time>
+    `;
+  }
+  valueChanged(t) {
+    this.adapter.injectValidationIssues(null), this.adapter.valueChanged(t.detail.value);
+  }
+  onInputError(t) {
+    this.adapter.injectValidationIssues([t.detail.message]);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.adapter.destroy(), this.subscriptions.forEach((t) => t.unsubscribe());
+  }
+};
+d([
+  h({ context: m }),
+  g({ attribute: !1 })
+], r.prototype, "formContext", 2);
+d([
+  u({ context: o })
+], r.prototype, "adapter", 2);
+r = d([
+  $("gui-range-date-time-input")
+], r);
+export {
+  r as RangeDateTimeInputElement
+};