@ds-autonomie/web-components 2.5.1 → 2.7.0

package/cdn/chunks/chunk.2PHBYTZR.js

@@ -0,0 +1,124 @@
+import {
+  avatar_styles_default
+} from "./chunk.RN7CKDB7.js";
+import {
+  ifDefinedAndNotEmpty
+} from "./chunk.B6GVVW66.js";
+import {
+  DSAIcon
+} from "./chunk.ORAENX4U.js";
+import {
+  o
+} from "./chunk.YQLIIKLI.js";
+import {
+  e2 as e
+} from "./chunk.A2REDF56.js";
+import {
+  watch
+} from "./chunk.4FQJ3QJK.js";
+import {
+  ShoelaceElement,
+  n,
+  r,
+  t
+} from "./chunk.JIQUSHGZ.js";
+import {
+  x
+} from "./chunk.7HUC6BF3.js";
+import {
+  __decorateClass
+} from "./chunk.4ZGVANML.js";
+
+// src/components/avatar/avatar.ts
+var DSAAvatar = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.hasError = false;
+    this.image = "";
+    this.label = "";
+    this.initials = "";
+    this.loading = "eager";
+    this.size = "medium";
+  }
+  handleImageChange() {
+    this.hasError = false;
+  }
+  render() {
+    const avatarWithImage = x`
+      <img
+        part="image"
+        class="avatar__image"
+        src="${this.image}"
+        loading="${this.loading}"
+        alt=""
+        @error="${() => this.hasError = true}"
+      />
+    `;
+    let avatarWithoutImage = x``;
+    if (this.initials) {
+      avatarWithoutImage = x`<div
+        part="initials"
+        aria-hidden="true"
+        class="avatar__initials"
+      >
+        ${this.initials}
+      </div>`;
+    } else {
+      avatarWithoutImage = x`
+        <div part="icon" class="avatar__icon" aria-hidden="true">
+          <slot name="icon">
+            <dsa-icon name="person_filled" library="system"></dsa-icon>
+          </slot>
+        </div>
+      `;
+    }
+    return x`
+      <div
+        part="base"
+        class=${e({
+      avatar: true,
+      "avatar--small": this.size === "small",
+      "avatar--medium": this.size === "medium",
+      "avatar--large": this.size === "large",
+      "avatar--x-large": this.size === "x-large"
+    })}
+        role=${o(this.label ? "img" : void 0)}
+        aria-label=${ifDefinedAndNotEmpty(this.label)}
+      >
+        ${this.image && !this.hasError ? avatarWithImage : avatarWithoutImage}
+      </div>
+    `;
+  }
+};
+DSAAvatar.styles = avatar_styles_default;
+DSAAvatar.dependencies = {
+  "dsa-icon": DSAIcon
+};
+__decorateClass([
+  r()
+], DSAAvatar.prototype, "hasError", 2);
+__decorateClass([
+  n()
+], DSAAvatar.prototype, "image", 2);
+__decorateClass([
+  n()
+], DSAAvatar.prototype, "label", 2);
+__decorateClass([
+  n()
+], DSAAvatar.prototype, "initials", 2);
+__decorateClass([
+  n()
+], DSAAvatar.prototype, "loading", 2);
+__decorateClass([
+  n({ reflect: true })
+], DSAAvatar.prototype, "size", 2);
+__decorateClass([
+  watch("image")
+], DSAAvatar.prototype, "handleImageChange", 1);
+DSAAvatar = __decorateClass([
+  t("dsa-avatar")
+], DSAAvatar);
+
+export {
+  DSAAvatar
+};

package/cdn/chunks/chunk.2Q5VJMXL.js

@@ -0,0 +1,85 @@
+import {
+  card_nav_item_styles_default
+} from "./chunk.DVU5XTCV.js";
+import {
+  HasSlotController
+} from "./chunk.YIY5RM53.js";
+import {
+  a11yWarning
+} from "./chunk.PWL7QCVG.js";
+import {
+  i,
+  u
+} from "./chunk.VIVOXZF6.js";
+import {
+  o
+} from "./chunk.YQLIIKLI.js";
+import {
+  ShoelaceElement,
+  n,
+  t
+} from "./chunk.JIQUSHGZ.js";
+import {
+  __decorateClass
+} from "./chunk.4ZGVANML.js";
+
+// src/components/card-nav-item/card-nav-item.ts
+var DSACardNavItem = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(this, "[default]");
+    this.href = "";
+    this.rel = "noreferrer noopener";
+    this.role = "listitem";
+  }
+  isLink() {
+    return this.href ? true : false;
+  }
+  render() {
+    const isLink = this.isLink();
+    const tag = isLink ? i`a` : i`button`;
+    if (!this.hasSlotController.test("[default]")) {
+      a11yWarning(
+        "<dsa-card-nav-item> requires slotted content for accessibility"
+      );
+    }
+    return u`
+      <${tag}
+        part="base"
+        class="card-nav-item"
+        href=${o(isLink ? this.href : void 0)}
+        target=${o(isLink ? this.target : void 0)}
+        download=${o(isLink ? this.download : void 0)}
+        rel=${o(isLink ? this.rel : void 0)}
+      >
+        <div class="card-nav-item__body">
+          <slot></slot>
+          <dsa-icon library="system" name="arrow_forward" class="card-nav-item__icon"></dsa-icon>
+      </div>
+      </${tag}>
+    `;
+  }
+};
+DSACardNavItem.styles = card_nav_item_styles_default;
+__decorateClass([
+  n()
+], DSACardNavItem.prototype, "href", 2);
+__decorateClass([
+  n()
+], DSACardNavItem.prototype, "target", 2);
+__decorateClass([
+  n()
+], DSACardNavItem.prototype, "rel", 2);
+__decorateClass([
+  n()
+], DSACardNavItem.prototype, "download", 2);
+__decorateClass([
+  n({ reflect: true })
+], DSACardNavItem.prototype, "role", 2);
+DSACardNavItem = __decorateClass([
+  t("dsa-card-nav-item")
+], DSACardNavItem);
+
+export {
+  DSACardNavItem
+};

package/cdn/chunks/chunk.2RXI7QGS.js

@@ -0,0 +1,47 @@
+import {
+  f,
+  m
+} from "./chunk.ORAENX4U.js";
+import {
+  e,
+  i,
+  t
+} from "./chunk.A2REDF56.js";
+import {
+  E,
+  T
+} from "./chunk.7HUC6BF3.js";
+
+// ../../node_modules/.pnpm/lit-html@3.2.1/node_modules/lit-html/directives/live.js
+var l = e(class extends i {
+  constructor(r) {
+    if (super(r), r.type !== t.PROPERTY && r.type !== t.ATTRIBUTE && r.type !== t.BOOLEAN_ATTRIBUTE) throw Error("The `live` directive is not allowed on child or event bindings");
+    if (!f(r)) throw Error("`live` bindings can only contain a single expression");
+  }
+  render(r) {
+    return r;
+  }
+  update(i2, [t2]) {
+    if (t2 === T || t2 === E) return t2;
+    const o = i2.element, l2 = i2.name;
+    if (i2.type === t.PROPERTY) {
+      if (t2 === o[l2]) return T;
+    } else if (i2.type === t.BOOLEAN_ATTRIBUTE) {
+      if (!!t2 === o.hasAttribute(l2)) return T;
+    } else if (i2.type === t.ATTRIBUTE && o.getAttribute(l2) === t2 + "") return T;
+    return m(i2), t2;
+  }
+});
+
+export {
+  l
+};
+/*! Bundled license information:
+
+lit-html/directives/live.js:
+  (**
+   * @license
+   * Copyright 2020 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/

package/cdn/chunks/chunk.2TMGDRXQ.js

@@ -0,0 +1,60 @@
+import {
+  component_styles_default
+} from "./chunk.B5IB4265.js";
+import {
+  i
+} from "./chunk.R7BJEFEU.js";
+
+// src/components/table-header-row/table-header-row.styles.ts
+var table_header_row_styles_default = i`
+  ${component_styles_default}
+
+  :host {
+    display: table-row;
+    outline: none;
+    font: var(--dsa-wc-table-header-row-font);
+    background: var(--dsa-wc-table-header-row-background);
+    color: var(--dsa-wc-table-header-row-color);
+  }
+
+  /* Sizes */
+  :host([size='small']) {
+    block-size: var(--dsa-wc-table-row-small-height);
+  }
+
+  :host([size='medium']) {
+    block-size: var(--dsa-wc-table-row-medium-height);
+  }
+
+  :host([size='large']) {
+    block-size: var(--dsa-wc-table-row-large-height);
+  }
+
+  [part~='column-checkbox'] {
+    display: table-cell;
+    vertical-align: middle;
+    text-align: center;
+    min-width: var(--dsa-wc-table-row-selectable-cell-width);
+  }
+
+  .column-checkbox--content {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+
+  :host(:not([loading])) [part~='column-checkbox']:hover {
+    background: var(--dsa-wc-table-header-cell-background-hover);
+  }
+
+  .column-expand-button {
+    display: table-cell;
+    vertical-align: middle;
+    text-align: center;
+    min-width: var(--dsa-wc-table-row-expandable-cell-width);
+  }
+`;
+
+export {
+  table_header_row_styles_default
+};

package/cdn/chunks/chunk.2XBRUWJK.js

@@ -0,0 +1,72 @@
+import {
+  component_styles_default
+} from "./chunk.B5IB4265.js";
+import {
+  i
+} from "./chunk.R7BJEFEU.js";
+
+// src/components/fieldset/fieldset.styles.ts
+var fieldset_styles_default = i`
+  ${component_styles_default}
+
+  :host {
+    display: block;
+  }
+
+  .fieldset {
+    display: flex;
+    flex-direction: column;
+    gap: var(--dsa-spacing-24);
+
+    background-color: var(--dsa-wc-fieldset-background);
+    padding: var(--dsa-spacing-24);
+    border-radius: var(--dsa-radius-8);
+    border-width: 1px;
+    border-style: solid;
+  }
+  .fieldset--on-base {
+    border-color: var(--dsa-wc-fieldset-border-color);
+  }
+  .fieldset--on-layer {
+    border-color: transparent;
+  }
+
+  .fieldset__legend {
+    display: flex;
+    flex-direction: column;
+    gap: var(--dsa-spacing-12);
+    color: var(--dsa-wc-fieldset-legend-color);
+    padding: 0;
+  }
+
+  .fieldset__first-line {
+    display: flex;
+    gap: var(--dsa-spacing-4);
+    align-items: center;
+  }
+  .fieldset__legend-title {
+    font: var(--dsa-wc-fieldset-title-font);
+  }
+  .fieldset__tooltip {
+    --dsa-wc-internal-icon-button-padding: var(--dsa-spacing-2);
+  }
+  .fieldset__legend-subtitle {
+    font: var(--dsa-font-small-normal);
+  }
+
+  .fieldset__content {
+    display: flex;
+    gap: var(--dsa-spacing-16);
+    flex-wrap: wrap;
+  }
+  .fieldset--vertical .fieldset__content {
+    flex-direction: column;
+  }
+  .fieldset--horizontal .fieldset__content {
+    flex-direction: row;
+  }
+`;
+
+export {
+  fieldset_styles_default
+};

package/cdn/chunks/chunk.2Y7A72NS.js

@@ -0,0 +1,63 @@
+import {
+  breadcrumb_styles_default
+} from "./chunk.QF4GNQLL.js";
+import {
+  LocalizeController
+} from "./chunk.EM2CIX7W.js";
+import {
+  ShoelaceElement,
+  e,
+  t
+} from "./chunk.JIQUSHGZ.js";
+import {
+  x
+} from "./chunk.7HUC6BF3.js";
+import {
+  __decorateClass
+} from "./chunk.4ZGVANML.js";
+
+// src/components/breadcrumb/breadcrumb.ts
+var DSABreadcrumb = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController(this);
+  }
+  handleSlotChange() {
+    const items = [
+      ...this.defaultSlot.assignedElements({ flatten: true })
+    ].filter(
+      (item) => item.tagName.toLowerCase() === "dsa-breadcrumb-item"
+    );
+    items.forEach((item, index) => {
+      if (index === items.length - 1) {
+        item.setAttribute("aria-current", "page");
+      } else {
+        item.removeAttribute("aria-current");
+      }
+    });
+  }
+  render() {
+    return x`
+      <nav
+        part="base"
+        aria-label=${this.localize.term("youAreHere")}
+        role="navigation"
+      >
+        <div role="list" class="breadcrumb__list">
+          <slot @slotchange=${this.handleSlotChange}></slot>
+        </div>
+      </nav>
+    `;
+  }
+};
+DSABreadcrumb.styles = breadcrumb_styles_default;
+__decorateClass([
+  e("slot")
+], DSABreadcrumb.prototype, "defaultSlot", 2);
+DSABreadcrumb = __decorateClass([
+  t("dsa-breadcrumb")
+], DSABreadcrumb);
+
+export {
+  DSABreadcrumb
+};

package/cdn/chunks/chunk.3F74OMTI.js

@@ -0,0 +1,234 @@
+import {
+  input_otp_styles_default
+} from "./chunk.QE4D6BZU.js";
+import {
+  InputBase
+} from "./chunk.CPFYSIPP.js";
+import {
+  l
+} from "./chunk.2RXI7QGS.js";
+import {
+  ifDefinedAndNotEmpty
+} from "./chunk.B6GVVW66.js";
+import {
+  o
+} from "./chunk.YQLIIKLI.js";
+import {
+  e2
+} from "./chunk.A2REDF56.js";
+import {
+  watch
+} from "./chunk.4FQJ3QJK.js";
+import {
+  e,
+  n,
+  r,
+  t
+} from "./chunk.JIQUSHGZ.js";
+import {
+  x
+} from "./chunk.7HUC6BF3.js";
+import {
+  __decorateClass
+} from "./chunk.4ZGVANML.js";
+
+// src/components/input-otp/input-otp.ts
+var DSAInputOTP = class extends InputBase {
+  constructor() {
+    super(...arguments);
+    this.currentIndex = 0;
+    this.length = 6;
+  }
+  handleFocus() {
+    this.currentIndex = this.value ? -1 : 0;
+    this.hasFocus = true;
+    this.emit("dsa-focus");
+  }
+  handleInput(event) {
+    var _a;
+    if (this.patternRegexp && !this.patternRegexp.test(this.input.value)) {
+      this.input.value = this.value;
+      this.handleCurrentIndexChange();
+      return;
+    }
+    if (this.input.value.length > this.length) {
+      this.input.value = this.input.value.slice(0, this.length);
+    } else {
+      this.value = this.input.value;
+      if (!event.data) {
+        if (this.currentIndex === 0) {
+          this.handleCurrentIndexChange();
+        } else if (this.currentIndex === -1) {
+          this.currentIndex = 0;
+        } else {
+          this.currentIndex -= 1;
+        }
+      } else {
+        if (((_a = event.data) == null ? void 0 : _a.length) === 1) {
+          this.currentIndex = this.currentIndex < this.length ? this.currentIndex + 1 : this.length - 1;
+        } else {
+          this.currentIndex = this.getLastIndex();
+        }
+      }
+      this.formControlController.updateValidity();
+      this.emit("dsa-input");
+    }
+  }
+  handleSelect() {
+    if (this.input.value.length > 1 && this.input.selectionStart === 0 && this.input.selectionEnd === this.input.value.length) {
+      this.currentIndex = -1;
+    }
+  }
+  handleKeyDown(event) {
+    super.handleKeyDown(event);
+    if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) {
+      event.preventDefault();
+      switch (event.key) {
+        case "ArrowLeft":
+          this.currentIndex = this.currentIndex > 0 ? this.currentIndex - 1 : 0;
+          break;
+        case "ArrowRight":
+          if (this.currentIndex === -1) {
+            this.currentIndex = this.getLastIndex();
+          } else if (this.currentIndex < this.value.length && this.currentIndex < this.length - 1) {
+            this.currentIndex += 1;
+          }
+          break;
+        case "ArrowUp":
+          this.currentIndex = 0;
+          break;
+        case "ArrowDown":
+          this.currentIndex = this.getLastIndex();
+          break;
+      }
+    }
+  }
+  handleSingleFieldClick(event) {
+    this.focus();
+    if (event.currentTarget instanceof HTMLElement) {
+      const clickedIndex = Number(event.currentTarget.dataset.fieldIndex);
+      this.currentIndex = clickedIndex < this.value.length ? clickedIndex : this.getLastIndex();
+    }
+  }
+  getLastIndex() {
+    return this.value.length > 0 ? Math.min(this.value.length, this.length - 1) : 0;
+  }
+  handleCurrentIndexChange() {
+    if (this.currentIndex === -1) {
+      this.input.setSelectionRange(0, this.input.value.length);
+    } else {
+      this.input.setSelectionRange(this.currentIndex, this.currentIndex + 1);
+    }
+  }
+  handlePatterChange() {
+    this.patternRegexp = new RegExp(this.pattern);
+  }
+  async getUpdateComplete() {
+    const result = await super.getUpdateComplete();
+    return result;
+  }
+  renderSingleField(index) {
+    const charValue = this.value.split("")[index];
+    const isCurrentField = this.currentIndex === index || this.currentIndex === -1 && charValue;
+    const inputClasses = e2({
+      "single-field": true,
+      "single-field--active": this.hasFocus && isCurrentField
+    });
+    return x`
+      <div
+        class=${inputClasses}
+        data-field-index=${index}
+        aria-hidden="true"
+        @click=${this.handleSingleFieldClick}
+      >
+        ${charValue || this.hasFocus && isCurrentField ? x`<span class="single-field__value">${charValue}</span>` : x`
+              <span class="single-field__placeholder"
+                >${this.placeholder.charAt(0)}</span
+              >
+            `}
+        ${this.hasFocus && isCurrentField && !charValue ? x` <div class="fake-caret"></div> ` : ""}
+      </div>
+    `;
+  }
+  renderInput() {
+    const hasLabelSlot = this.hasSlotController.test("label");
+    const hasLabel = this.label ? true : !!hasLabelSlot;
+    return x`
+      <div part="base" class="input__wrapper">
+        <div
+          class=${e2({
+      "visible-input": true,
+      "input--focused": this.hasFocus,
+      // Sizes
+      "input--small": this.size === "small",
+      "input--medium": this.size === "medium",
+      "input--large": this.size === "large",
+      // States
+      "input--error": this.error,
+      "input--success": this.success && !this.error,
+      "input--on-layer": this.variant === "layer",
+      "input--on-base": this.variant === "base",
+      "input--disabled": this.disabled
+    })}
+        >
+          ${Array.from(Array(this.length)).map(
+      (_, index) => this.renderSingleField(index)
+    )}
+        </div>
+        <input
+          part="input"
+          id="input"
+          class="hidden-input"
+          type="text"
+          name=${ifDefinedAndNotEmpty(this.name)}
+          ?disabled=${this.disabled}
+          ?required=${this.required}
+          minlength=${this.length}
+          maxlength=${this.length}
+          .value=${l(this.value)}
+          autocomplete="one-time-code"
+          ?autofocus=${this.autofocus}
+          pattern=${o(this.pattern)}
+          enterkeyhint=${o(this.enterkeyhint)}
+          inputmode=${o(this.inputmode)}
+          aria-label=${ifDefinedAndNotEmpty(hasLabel ? void 0 : this.title)}
+          aria-describedby=${this.getDescriptionIds()}
+          aria-invalid=${o(this.error ? "true" : void 0)}
+          @change=${this.handleChange}
+          @input=${this.handleInput}
+          @invalid=${this.handleInvalid}
+          @keydown=${this.handleKeyDown}
+          @focus=${this.handleFocus}
+          @blur=${this.handleBlur}
+          @select=${this.handleSelect}
+        />
+      </div>
+    `;
+  }
+};
+DSAInputOTP.styles = input_otp_styles_default;
+__decorateClass([
+  e("input")
+], DSAInputOTP.prototype, "input", 2);
+__decorateClass([
+  r()
+], DSAInputOTP.prototype, "currentIndex", 2);
+__decorateClass([
+  r()
+], DSAInputOTP.prototype, "patternRegexp", 2);
+__decorateClass([
+  n({ type: Number })
+], DSAInputOTP.prototype, "length", 2);
+__decorateClass([
+  watch("currentIndex", { waitUntilFirstUpdate: true })
+], DSAInputOTP.prototype, "handleCurrentIndexChange", 1);
+__decorateClass([
+  watch("pattern")
+], DSAInputOTP.prototype, "handlePatterChange", 1);
+DSAInputOTP = __decorateClass([
+  t("dsa-input-otp")
+], DSAInputOTP);
+
+export {
+  DSAInputOTP
+};