@ds-autonomie/web-components 2.7.0 → 2.8.0

package/dist/chunks/chunk.2BFULL4S.js

@@ -0,0 +1,91 @@
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+
+// src/components/sidenav/sidenav.styles.ts
+import { css } from "lit";
+var sidenav_styles_default = css`
+  ${component_styles_default}
+
+  :host {
+    --sidenav-expanded-width: var(--dsa-wc-sidenav-default-expanded-width);
+  }
+
+  .sidenav {
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+    height: 100%;
+    border-right: 1px solid var(--dsa-color-border-default);
+  }
+
+  .sidenav--collapsed {
+    width: var(--dsa-wc-sidenav-collapsed-width);
+  }
+  .sidenav--expanded {
+    width: var(--sidenav-expanded-width);
+  }
+
+  dsa-divider,
+  ::slotted(dsa-divider) {
+    --spacing-start: 0;
+    --spacing-end: 0;
+  }
+  .sidenav__top-divider {
+    margin-bottom: auto;
+  }
+  .sidenav__bottom-divider {
+    margin-top: auto;
+  }
+
+  .sidenav__button {
+    display: flex;
+    justify-content: flex-end;
+    align-items: center;
+    background: none;
+    border-width: 0 0 1px 0;
+    border-style: solid;
+    border-color: var(--dsa-color-border-default);
+    padding: 0;
+    height: var(--dsa-wc-sidenav-collapsed-width);
+    flex-shrink: 0;
+    outline-offset: -1px;
+    cursor: pointer;
+  }
+
+  .sidenav__expand-icon {
+    margin: 1.125rem;
+    width: 1.25rem;
+    height: 1.25rem;
+    transition: var(--dsa-wc-transition-medium) rotate ease;
+  }
+  .sidenav--expanded .sidenav__expand-icon {
+    rotate: 180deg;
+  }
+
+  .sidenav__content {
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+    height: 100%;
+    overflow: auto;
+  }
+
+  ::slotted(dsa-menu-navigation) {
+    border: none;
+    border-radius: 0;
+    padding: 0;
+    overflow: unset;
+  }
+
+  .sidenav:not(.sidenav--expanded)
+    ::slotted(
+      :not(dsa-menu-accordion):not(dsa-menu-navigation):not(dsa-divider)
+    ) {
+    display: none;
+  }
+`;
+
+export {
+  sidenav_styles_default
+};

package/dist/chunks/chunk.2X26TEKN.js

@@ -0,0 +1,44 @@
+import {
+  skip_links_styles_default
+} from "./chunk.DX25IW4S.js";
+import {
+  LocalizeController
+} from "./chunk.N3JDTZGM.js";
+import {
+  ShoelaceElement
+} from "./chunk.XZ5FE34T.js";
+import {
+  __decorateClass
+} from "./chunk.S3NI7NKU.js";
+
+// src/components/skip-links/skip-links.ts
+import { html } from "lit";
+import { customElement } from "lit/decorators.js";
+var DSASkipLinks = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController(this);
+  }
+  render() {
+    return html`
+      <nav
+        role="navigation"
+        part="base"
+        class="skip-links"
+        aria-label=${this.localize.term("skipLinksAriaLabel")}
+      >
+        <ul class="skip-links__list">
+          <slot></slot>
+        </ul>
+      </nav>
+    `;
+  }
+};
+DSASkipLinks.styles = skip_links_styles_default;
+DSASkipLinks = __decorateClass([
+  customElement("dsa-skip-links")
+], DSASkipLinks);
+
+export {
+  DSASkipLinks
+};

package/dist/chunks/chunk.3ZD3V2KP.js

@@ -0,0 +1,334 @@
+import {
+  DSACheckboxGroup
+} from "./chunk.SHJWL34V.js";
+import {
+  defaultValue
+} from "./chunk.CMJ2SRTL.js";
+import {
+  renderFormElementErrors
+} from "./chunk.6QDM5FUA.js";
+import {
+  checkbox_styles_default
+} from "./chunk.5NAZU6VJ.js";
+import {
+  FormControlController
+} from "./chunk.DQDLS6T7.js";
+import {
+  HasSlotController
+} from "./chunk.YIY5RM53.js";
+import {
+  a11yWarning
+} from "./chunk.PWL7QCVG.js";
+import {
+  ifDefinedAndNotEmpty
+} from "./chunk.ZQJVCRB2.js";
+import {
+  watch
+} from "./chunk.NOMN6DGD.js";
+import {
+  ShoelaceElement
+} from "./chunk.XZ5FE34T.js";
+import {
+  __decorateClass
+} from "./chunk.S3NI7NKU.js";
+
+// src/components/checkbox/checkbox.ts
+import { html } from "lit";
+import { customElement, property, query, state } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { ifDefined } from "lit/directives/if-defined.js";
+import { live } from "lit/directives/live.js";
+var DSACheckbox = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.formControlController = new FormControlController(this, {
+      value: (control) => control.checked ? control.value || "on" : void 0,
+      defaultValue: (control) => control.defaultChecked,
+      setValue: (control, checked) => control.checked = checked
+    });
+    this.hasSlotController = new HasSlotController(this, "[default]");
+    this.hasFocus = false;
+    this.title = "";
+    this.name = "";
+    this.size = "medium";
+    this.parentDisabled = false;
+    this.disabled = false;
+    this.checked = false;
+    this.indeterminate = false;
+    this.defaultChecked = false;
+    this.parentReadonly = false;
+    this.readonly = false;
+    this.error = false;
+    this.errorMessage = "";
+    this.form = "";
+    this.required = false;
+  }
+  /** Gets the validity state object */
+  get validity() {
+    return this.input.validity;
+  }
+  /** Gets the validation message */
+  get validationMessage() {
+    return this.input.validationMessage;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const parent = this.parentElement;
+    if (!this.hasAttribute("role") && parent instanceof DSACheckboxGroup) {
+      this.setAttribute("role", "listitem");
+    }
+  }
+  firstUpdated() {
+    this.formControlController.updateValidity();
+  }
+  handleClick(event) {
+    if (this.readonly || this.disabled || this.parentDisabled || this.parentReadonly) {
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+    this.checked = !this.checked;
+    this.indeterminate = false;
+    this.emit("dsa-change");
+  }
+  handleBlur() {
+    this.hasFocus = false;
+    this.emit("dsa-blur");
+  }
+  handleInput() {
+    this.emit("dsa-input");
+  }
+  handleInvalid(event) {
+    this.formControlController.setValidity(false);
+    this.formControlController.emitInvalidEvent(event);
+  }
+  handleFocus() {
+    this.hasFocus = true;
+    this.emit("dsa-focus");
+  }
+  handleDeactivatedChange() {
+    if (this.disabled || this.readonly || this.parentDisabled || this.parentReadonly) {
+      this.input.setAttribute("aria-disabled", "true");
+    } else {
+      this.input.removeAttribute("aria-disabled");
+    }
+    if (this.disabled || this.parentDisabled)
+      this.formControlController.setValidity(this.disabled);
+  }
+  handleStateChange() {
+    this.input.checked = this.checked;
+    this.input.indeterminate = this.indeterminate;
+    this.formControlController.updateValidity();
+  }
+  handleErrorChange() {
+    if (this.error) {
+      this.input.setAttribute("aria-invalid", "true");
+    } else {
+      this.input.removeAttribute("aria-invalid");
+    }
+  }
+  /** Simulates a click on the checkbox. */
+  click() {
+    this.input.click();
+  }
+  /** Sets focus on the checkbox. */
+  focus(options) {
+    this.input.focus(options);
+  }
+  /** Removes focus from the checkbox. */
+  blur() {
+    this.input.blur();
+  }
+  /** Checks for validity but does not show a validation message. Returns `true` when valid and `false` when invalid. */
+  checkValidity() {
+    return this.input.checkValidity();
+  }
+  /** Gets the associated form, if one exists. */
+  getForm() {
+    return this.formControlController.getForm();
+  }
+  /** Checks for validity and shows the browser's validation message if the control is invalid. */
+  reportValidity() {
+    return this.input.reportValidity();
+  }
+  /**
+   * Sets a custom validation message. The value provided will be shown to the user when the form is submitted. To clear
+   * the custom validation message, call this method with an empty string.
+   */
+  setCustomValidity(message) {
+    this.input.setCustomValidity(message);
+    this.formControlController.updateValidity();
+  }
+  render() {
+    const hasLabelSlot = this.hasSlotController.test("[default]");
+    const isDisabled = this.disabled || this.parentDisabled;
+    const isReadonly = this.readonly || this.parentReadonly;
+    const isDeactivated = isDisabled || isReadonly;
+    if (!this.hasSlotController.test("[default]") && !this.accessibleName && !(this.tabIndex === -1)) {
+      a11yWarning(
+        "<dsa-checkbox> requires an accessible name in the default slot for accessibility"
+      );
+    }
+    if (this.error && !this.errorMessage) {
+      a11yWarning(
+        "<dsa-checkbox> requires an error-message attribute for accessibility when the error attribute is set"
+      );
+    }
+    return html`
+      <div
+        part="base"
+        class=${classMap({
+      "form-control": true,
+      "form-control--error": this.error,
+      "form-control--small": this.size === "small",
+      "form-control--medium": this.size === "medium",
+      "form-control--large": this.size === "large"
+    })}
+      >
+        <label
+          for="input"
+          class=${classMap({
+      checkbox: true,
+      "checkbox--checked": this.checked,
+      "checkbox--error": this.error,
+      "checkbox--disabled": isDisabled,
+      "checkbox--readonly": isReadonly,
+      "checkbox--focused": this.hasFocus,
+      "checkbox--indeterminate": this.indeterminate,
+      "checkbox--has-label": hasLabelSlot,
+      "checkbox--small": this.size === "small",
+      "checkbox--medium": this.size === "medium",
+      "checkbox--large": this.size === "large"
+    })}
+        >
+          <input
+            id="input"
+            class="checkbox__input"
+            type="checkbox"
+            title=${this.title}
+            name=${ifDefinedAndNotEmpty(this.name)}
+            value=${ifDefined(this.value)}
+            .indeterminate=${live(this.indeterminate)}
+            .checked=${live(this.checked)}
+            .disabled=${isDisabled}
+            .required=${this.required}
+            aria-label=${ifDefinedAndNotEmpty(
+      this.accessibleName || this.ariaLabel
+    )}
+            aria-checked=${this.checked ? "true" : "false"}
+            aria-describedby=${ifDefined(this.error ? "error-text" : void 0)}
+            aria-disabled="${ifDefined(isDeactivated ? "true" : void 0)}"
+            aria-invalid=${ifDefined(this.error ? "true" : void 0)}
+            @click=${this.handleClick}
+            @input=${this.handleInput}
+            @invalid=${this.handleInvalid}
+            @blur=${this.handleBlur}
+            @focus=${this.handleFocus}
+          />
+          <dsa-internal-checkbox-box
+            ?checked=${this.checked}
+            ?indeterminate=${this.indeterminate}
+            size=${this.size}
+            ?disabled=${isDisabled}
+            ?readonly=${isReadonly}
+            ?error=${this.error}
+          ></dsa-internal-checkbox-box>
+
+          <div part="label" class="checkbox__label">
+            ${this.required ? html`<span class="checkbox__label-required">*</span>` : ""}
+            <slot></slot>
+          </div>
+        </label>
+        ${this.error && !isDeactivated && this.errorMessage ? renderFormElementErrors(this.errorMessage) : ""}
+      </div>
+    `;
+  }
+};
+DSACheckbox.styles = checkbox_styles_default;
+__decorateClass([
+  query('input[type="checkbox"]')
+], DSACheckbox.prototype, "input", 2);
+__decorateClass([
+  state()
+], DSACheckbox.prototype, "hasFocus", 2);
+__decorateClass([
+  property()
+], DSACheckbox.prototype, "title", 2);
+__decorateClass([
+  property({ reflect: true })
+], DSACheckbox.prototype, "name", 2);
+__decorateClass([
+  property({ reflect: true })
+], DSACheckbox.prototype, "value", 2);
+__decorateClass([
+  property({ reflect: true })
+], DSACheckbox.prototype, "size", 2);
+__decorateClass([
+  property({ type: Boolean })
+], DSACheckbox.prototype, "parentDisabled", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSACheckbox.prototype, "disabled", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSACheckbox.prototype, "checked", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSACheckbox.prototype, "indeterminate", 2);
+__decorateClass([
+  defaultValue("checked")
+], DSACheckbox.prototype, "defaultChecked", 2);
+__decorateClass([
+  property({ type: Boolean })
+], DSACheckbox.prototype, "parentReadonly", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSACheckbox.prototype, "readonly", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSACheckbox.prototype, "error", 2);
+__decorateClass([
+  property({
+    attribute: "error-message",
+    converter: {
+      fromAttribute: (value) => value ? value.split("|") : "",
+      toAttribute: (value) => {
+        if (typeof value === "string") {
+          return value;
+        } else {
+          return value.join("|");
+        }
+      }
+    }
+  })
+], DSACheckbox.prototype, "errorMessage", 2);
+__decorateClass([
+  property({ reflect: true })
+], DSACheckbox.prototype, "form", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSACheckbox.prototype, "required", 2);
+__decorateClass([
+  property({ attribute: "aria-label", reflect: true })
+], DSACheckbox.prototype, "ariaLabel", 2);
+__decorateClass([
+  property({ attribute: "accessible-name", reflect: true })
+], DSACheckbox.prototype, "accessibleName", 2);
+__decorateClass([
+  watch(["disabled", "readonly", "parentDisabled", "parentReadonly"], {
+    waitUntilFirstUpdate: true
+  })
+], DSACheckbox.prototype, "handleDeactivatedChange", 1);
+__decorateClass([
+  watch(["checked", "indeterminate"], { waitUntilFirstUpdate: true })
+], DSACheckbox.prototype, "handleStateChange", 1);
+__decorateClass([
+  watch("error", { waitUntilFirstUpdate: true })
+], DSACheckbox.prototype, "handleErrorChange", 1);
+DSACheckbox = __decorateClass([
+  customElement("dsa-checkbox")
+], DSACheckbox);
+
+export {
+  DSACheckbox
+};

package/dist/chunks/chunk.42QDYDUA.js

@@ -0,0 +1,175 @@
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+
+// src/components/tree-item/tree-item.styles.ts
+import { css } from "lit";
+var tree_item_styles_default = css`
+  ${component_styles_default}
+
+  :host {
+    display: block;
+    outline: 0;
+    z-index: 0;
+  }
+
+  :host(:focus) {
+    outline: none;
+  }
+
+  slot:not([name])::slotted(dsa-icon) {
+    margin-inline-end: var(--dsa-wc-tree-item-icon-margin-end);
+  }
+
+  .tree-item {
+    position: relative;
+    display: flex;
+    align-items: stretch;
+    flex-direction: column;
+    color: var(--dsa-wc-tree-item-color);
+    cursor: pointer;
+    user-select: none;
+    min-width: fit-content;
+  }
+
+  .tree-item__checkbox {
+    pointer-events: none;
+    margin-inline-end: 0.5rem;
+  }
+
+  .tree-item__expand-button,
+  .tree-item__checkbox,
+  .tree-item__label {
+    font: var(--dsa-wc-tree-item-font);
+  }
+
+  .tree-item__checkbox::part(base) {
+    display: flex;
+    align-items: center;
+  }
+
+  .tree-item__indentation {
+    display: block;
+    width: 1em;
+    flex-shrink: 0;
+  }
+
+  .tree-item__expand-button {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-sizing: content-box;
+    padding: var(--dsa-wc-tree-item-icon-padding);
+    width: 1.5rem;
+    height: 1.5rem;
+    flex-shrink: 0;
+    cursor: pointer;
+  }
+
+  .tree-item__expand-button {
+    transition: var(--dsa-wc-transition-medium) rotate ease;
+  }
+
+  .tree-item--expanded .tree-item__expand-button {
+    rotate: 90deg;
+  }
+
+  .tree-item--expanded.tree-item--rtl .tree-item__expand-button {
+    rotate: -90deg;
+  }
+
+  .tree-item--expanded .tree-item__expand-icon,
+  .tree-item:not(.tree-item--expanded) .tree-item__collapse-icon {
+    display: none;
+  }
+
+  .tree-item:not(.tree-item--has-expand-button) .tree-item__expand-icon,
+  .tree-item:not(.tree-item--has-expand-button) .tree-item__collapse-icon {
+    display: none;
+  }
+
+  .tree-item__expand-button--visible {
+    cursor: pointer;
+  }
+
+  .tree-item__item {
+    display: flex;
+    align-items: center;
+    border-inline-start: solid 3px transparent;
+  }
+
+  .tree-item--disabled .tree-item__item {
+    opacity: 0.5;
+    outline: none;
+    cursor: not-allowed;
+  }
+
+  :host(:focus-visible) .tree-item__item {
+    outline: var(--dsa-wc-focus-ring);
+    outline-offset: var(--dsa-wc-focus-ring-offset);
+    border-radius: var(--dsa-wc-focus-ring-radius);
+    z-index: 2;
+  }
+
+  :host(:not([aria-disabled='true'])) .tree-item--selected .tree-item__item {
+    background-color: var(--dsa-wc-tree-item-selected-background-color);
+    border-inline-start-color: var(--dsa-wc-tree-item-selected-border-color);
+  }
+
+  :host(:not([aria-disabled='true'])) .tree-item__expand-button {
+    color: var(--dsa-wc-tree-item-color);
+  }
+
+  .tree-item__label {
+    display: flex;
+    align-items: center;
+    transition: var(--dsa-wc-transition-fast) color;
+  }
+
+  .tree-item__selected-icon {
+    margin-inline-start: auto;
+    margin-inline-end: var(--dsa-spacing-8);
+    font: var(--dsa-wc-tree-item-font);
+    color: var(--dsa-wc-tree-item-selected-border-color);
+  }
+
+  .tree-item__children {
+    display: block;
+    font-size: calc(1em + var(--dsa-wc-tree-indent-size));
+  }
+
+  /* Indentation lines */
+  .tree-item__children {
+    position: relative;
+  }
+
+  .tree-item__children::before {
+    content: '';
+    position: absolute;
+    top: var(--dsa-wc-tree-indent-guide-offset);
+    bottom: var(--dsa-wc-tree-indent-guide-offset);
+    left: calc(
+      1em + var(--dsa-wc-tree-indent-size-offset, 0) -
+        (var(--dsa-wc-tree-indent-guide-width) / 2) - 1px
+    );
+    border-inline-end: var(--dsa-wc-tree-indent-guide-width)
+      var(--dsa-wc-tree-indent-guide-style)
+      var(--dsa-wc-tree-indent-guide-color);
+    z-index: 1;
+  }
+
+  .tree-item--rtl .tree-item__children::before {
+    left: auto;
+    right: 1em;
+  }
+
+  @media (forced-colors: active) {
+    :host(:not([aria-disabled='true'])) .tree-item--selected .tree-item__item {
+      outline: dashed 1px SelectedItem;
+    }
+  }
+`;
+
+export {
+  tree_item_styles_default
+};

package/dist/chunks/chunk.4734BI3P.js

@@ -0,0 +1,41 @@
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+
+// src/components/table-toolbar/table-toolbar.styles.ts
+import { css } from "lit";
+var table_toolbar_styles_default = css`
+  ${component_styles_default}
+
+  :host {
+    display: flex;
+    justify-content: space-between;
+    gap: var(--dsa-spacing-16);
+    padding-inline: var(--dsa-spacing-12);
+  }
+
+  [part~='filters'] {
+    display: flex;
+    flex-direction: row;
+    gap: var(--dsa-spacing-16);
+    flex-wrap: wrap;
+  }
+
+  .table-toolbar__right {
+    height: fit-content;
+    display: flex;
+    flex-direction: row;
+    gap: var(--dsa-spacing-16);
+    flex-wrap: wrap-reverse;
+    justify-content: flex-end;
+  }
+
+  [part~='search'] {
+    display: flex;
+    flex-direction: row;
+  }
+`;
+
+export {
+  table_toolbar_styles_default
+};

package/dist/chunks/chunk.4EHJHIX6.js

@@ -0,0 +1,21 @@
+import {
+  form_control_styles_default
+} from "./chunk.EHTCYJUT.js";
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+
+// src/components/radio-group/radio-group.styles.ts
+import { css } from "lit";
+var radio_group_styles_default = css`
+  ${component_styles_default}
+  ${form_control_styles_default}
+
+  :host {
+    display: block;
+  }
+`;
+
+export {
+  radio_group_styles_default
+};