@sbb-esta/lyne-elements 2.6.0 → 2.7.0

package/development/chip/chip/chip.js

@@ -0,0 +1,213 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, LitElement, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { SbbLanguageController } from "../../core/controllers.js";
+import { forceType } from "../../core/decorators.js";
+import { EventEmitter } from "../../core/eventing.js";
+import { i18nChipDelete } from "../../core/i18n.js";
+import { SbbNegativeMixin, SbbDisabledMixin } from "../../core/mixins.js";
+import "../../button/mini-button.js";
+import "../../screen-reader-only.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-chip-background-color: var(--sbb-color-milk);
+  --sbb-chip-border: var(--sbb-border-width-1x) solid var(--sbb-chip-border-color);
+  --sbb-chip-border-color: var(--sbb-color-cloud);
+  --sbb-chip-border-radius: var(--sbb-border-radius-2x);
+  --sbb-chip-color: var(--sbb-color-granite);
+  --sbb-chip-color-active: var(--sbb-color-charcoal);
+  --sbb-chip-color-hover: var(--sbb-color-charcoal);
+  --sbb-chip-background-color-active: var(--sbb-color-white);
+  --sbb-chip-background-color-hover: var(--sbb-color-white);
+  --sbb-chip-height: 1.5rem;
+  --sbb-chip-label-padding-inline: var(--sbb-spacing-fixed-2x);
+  --sbb-chip-transition-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  outline: none !important;
+  display: inline-block;
+}
+
+:host([negative]) {
+  --sbb-chip-border-color: var(--sbb-color-iron);
+  --sbb-chip-background-color: var(--sbb-color-charcoal);
+  --sbb-chip-color: var(--sbb-color-cloud);
+  --sbb-chip-color-active: var(--sbb-color-white);
+  --sbb-chip-color-hover: var(--sbb-color-white);
+  --sbb-chip-background-color-active: var(--sbb-color-midnight);
+  --sbb-chip-background-color-hover: var(--sbb-color-midnight);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+}
+
+.sbb-chip {
+  background-color: var(--sbb-chip-background-color);
+  border-radius: var(--sbb-chip-border-radius);
+  color: var(--sbb-chip-color);
+  display: flex;
+  align-items: stretch;
+  height: var(--sbb-chip-height);
+}
+:host(:focus) .sbb-chip {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  --sbb-focus-outline-offset: -0.0625rem;
+  --sbb-focus-outline-style: initial;
+}
+
+.sbb-chip__label-wrapper {
+  border: var(--sbb-chip-border);
+  border-inline-end: none;
+  border-radius: var(--sbb-chip-border-radius) 0 0 var(--sbb-chip-border-radius);
+  display: flex;
+  align-items: center;
+  padding-inline: var(--sbb-chip-label-padding-inline);
+  outline: none;
+  overflow: hidden;
+}
+:host(:is([disabled], [readonly])) .sbb-chip__label-wrapper {
+  border: var(--sbb-chip-border);
+  border-radius: var(--sbb-chip-border-radius);
+}
+
+.sbb-chip__label {
+  --sbb-text-font-size: var(--sbb-font-size-text-xxs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  display: inline-block;
+  transition: transform var(--sbb-chip-transition-duration) var(--sbb-animation-easing);
+}
+
+.sbb-chip__delete {
+  --sbb-button-border-radius: 0 var(--sbb-chip-border-radius) var(--sbb-chip-border-radius) 0;
+  --sbb-button-color-text: var(--sbb-chip-color);
+  --sbb-button-color-active-background: var(--sbb-chip-background-color-active);
+  --sbb-button-color-hover-background: var(--sbb-chip-background-color-hover);
+  --sbb-icon-svg-width: calc(var(--sbb-size-icon-ui-small) - var(--sbb-border-width-1x) * 2);
+  --sbb-icon-svg-height: calc(var(--sbb-size-icon-ui-small) - var(--sbb-border-width-1x) * 2);
+  border: var(--sbb-chip-border);
+  border-radius: 0 var(--sbb-chip-border-radius) var(--sbb-chip-border-radius) 0;
+}
+:host(:is([disabled], [readonly])) .sbb-chip__delete {
+  display: none;
+}
+@media (any-hover: hover) {
+  :host(:not([disabled])) .sbb-chip__delete:hover {
+    --sbb-button-color-text: var(--sbb-chip-color-hover);
+  }
+}`;
+let SbbChipElement = (() => {
+  var _value_accessor_storage, _readonly_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-chip")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbNegativeMixin(SbbDisabledMixin(LitElement));
+  let _value_decorators;
+  let _value_initializers = [];
+  let _value_extraInitializers = [];
+  let _readonly_decorators;
+  let _readonly_initializers = [];
+  let _readonly_extraInitializers = [];
+  var SbbChipElement2 = (_a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _value_accessor_storage);
+      __privateAdd(this, _readonly_accessor_storage);
+      __privateSet(this, _value_accessor_storage, __runInitializers(this, _value_initializers, ""));
+      __privateSet(this, _readonly_accessor_storage, (__runInitializers(this, _value_extraInitializers), __runInitializers(this, _readonly_initializers, false)));
+      this._requestDelete = (__runInitializers(this, _readonly_extraInitializers), new EventEmitter(this, SbbChipElement2.events.requestDelete));
+      this._language = new SbbLanguageController(this);
+      const internals = this.attachInternals();
+      internals.role = "option";
+    }
+    /** The value of chip. Will be used as label if nothing is slotted. */
+    get value() {
+      return __privateGet(this, _value_accessor_storage);
+    }
+    set value(value) {
+      __privateSet(this, _value_accessor_storage, value);
+    }
+    /** Whether the component is readonly */
+    get readonly() {
+      return __privateGet(this, _readonly_accessor_storage);
+    }
+    set readonly(value) {
+      __privateSet(this, _readonly_accessor_storage, value);
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("disabled")) {
+        if (this.disabled) {
+          this.removeAttribute("tabindex");
+        } else {
+          this.setAttribute("tabindex", "-1");
+        }
+      }
+    }
+    firstUpdated(_changedProperties) {
+      super.firstUpdated(_changedProperties);
+      setTimeout(() => this._deleteButton().removeAttribute("tabindex"));
+    }
+    _deleteButton() {
+      return this.shadowRoot.querySelector("sbb-mini-button");
+    }
+    render() {
+      return html`
+      <div class="sbb-chip">
+        <div class="sbb-chip__label-wrapper">
+          <span class="sbb-chip__label">
+            <slot>${this.value}</slot>
+          </span>
+        </div>
+        <sbb-mini-button
+          aria-hidden="true"
+          class="sbb-chip__delete"
+          icon-name="cross-tiny-small"
+          @click=${() => this._requestDelete.emit()}
+        >
+        </sbb-mini-button>
+        <sbb-screen-reader-only>, ${i18nChipDelete[this._language.current]}</sbb-screen-reader-only>
+      </div>
+    `;
+    }
+  }, _value_accessor_storage = new WeakMap(), _readonly_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _value_decorators = [forceType(), property()];
+    _readonly_decorators = [forceType(), property({ type: Boolean, reflect: true })];
+    __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: (obj) => "value" in obj, get: (obj) => obj.value, set: (obj, value) => {
+      obj.value = value;
+    } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+    __esDecorate(_a, null, _readonly_decorators, { kind: "accessor", name: "readonly", static: false, private: false, access: { has: (obj) => "readonly" in obj, get: (obj) => obj.readonly, set: (obj, value) => {
+      obj.readonly = value;
+    } }, metadata: _metadata }, _readonly_initializers, _readonly_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    SbbChipElement2 = _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = style, _a.events = {
+    requestDelete: "requestDelete"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a);
+  return SbbChipElement2 = _classThis;
+})();
+export {
+  SbbChipElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/chip/chip-group/chip-group.js

@@ -0,0 +1,350 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, LitElement, isServer, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { inputAutocompleteEvent } from "../../autocomplete.js";
+import { isArrowKeyPressed, getNextElementIndex } from "../../core/a11y.js";
+import { SbbLanguageController } from "../../core/controllers.js";
+import { isLean } from "../../core/dom.js";
+import { EventEmitter } from "../../core/eventing.js";
+import { i18nSelectionRequired, i18nChipGroupInputDescription } from "../../core/i18n.js";
+import { SbbRequiredMixin, SbbDisabledMixin, SbbNegativeMixin, SbbFormAssociatedMixin } from "../../core/mixins.js";
+import { SbbChipElement } from "../chip.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-chip-group-input-min-width: 9.375rem;
+  max-width: 100%;
+}
+
+:host([data-size=s]:not([data-empty])) {
+  --sbb-chip-group-margin-block: 0.375rem 0.3125rem;
+}
+@media (min-width: calc(52.5rem)) {
+  :host([data-size=s]:not([data-empty])) {
+    --sbb-chip-group-margin-block: 0.3125rem 0.1875rem;
+  }
+}
+
+::slotted(input) {
+  flex: 1 1 var(--sbb-chip-group-input-min-width);
+}
+
+::slotted(sbb-chip) {
+  max-width: 100%;
+}
+
+.sbb-chip-group {
+  width: 100%;
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--sbb-spacing-fixed-1x);
+  align-items: center;
+  margin-block: var(--sbb-chip-group-margin-block);
+}`;
+let SbbChipGroupElement = (() => {
+  var _separatorKeys_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-chip-group")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbRequiredMixin(SbbDisabledMixin(SbbNegativeMixin(SbbFormAssociatedMixin(LitElement))));
+  let _instanceExtraInitializers = [];
+  let _set_value_decorators;
+  let _separatorKeys_decorators;
+  let _separatorKeys_initializers = [];
+  let _separatorKeys_extraInitializers = [];
+  var SbbChipGroupElement2 = (_a = class extends _classSuper {
+    constructor() {
+      var _a2, _b;
+      super();
+      __privateAdd(this, _separatorKeys_accessor_storage);
+      __privateSet(this, _separatorKeys_accessor_storage, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _separatorKeys_initializers, ["Enter"])));
+      this._change = (__runInitializers(this, _separatorKeys_extraInitializers), new EventEmitter(this, SbbChipGroupElement2.events.change));
+      this._input = new EventEmitter(this, SbbChipGroupElement2.events.input);
+      this._chipInputTokenEnd = new EventEmitter(this, SbbChipGroupElement2.events.chipInputTokenEnd);
+      this._inputAttributeObserver = !isServer ? new MutationObserver(() => this._reactToInputChanges()) : null;
+      this._formFieldAttributeObserver = !isServer ? new MutationObserver(() => this._inheritSize()) : null;
+      this._language = new SbbLanguageController(this);
+      this.internals.role = "listbox";
+      (_a2 = this.addEventListener) == null ? void 0 : _a2.call(this, SbbChipElement.events.requestDelete, (ev) => this._deleteChip(ev.target));
+      (_b = this.addEventListener) == null ? void 0 : _b.call(this, "keydown", (ev) => this._onChipKeyDown(ev));
+    }
+    /** Value of the form element. */
+    set value(value) {
+      value = value ?? [];
+      super.value = value;
+      const oldValue = this.value;
+      const toRemove = [...oldValue];
+      for (const c of value) {
+        if (toRemove.includes(c)) {
+          toRemove.splice(toRemove.indexOf(c), 1);
+        }
+      }
+      toRemove.forEach((value2) => {
+        var _a2;
+        return (_a2 = this._chipElements().find((c) => c.value === value2)) == null ? void 0 : _a2.remove();
+      });
+      const toAdd = [...value];
+      for (const c of oldValue) {
+        if (toAdd.includes(c)) {
+          toAdd.splice(toAdd.indexOf(c), 1);
+        }
+      }
+      toAdd.forEach((c) => this._createChipElement(c));
+    }
+    get value() {
+      return this._chipElements().map((c) => c.value);
+    }
+    /** The array of keys that will trigger a `chipInputTokenEnd` event. Default `['Enter']` */
+    get separatorKeys() {
+      return __privateGet(this, _separatorKeys_accessor_storage);
+    }
+    set separatorKeys(value) {
+      __privateSet(this, _separatorKeys_accessor_storage, value);
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this._setupComponent();
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("disabled") || changedProperties.has("formDisabled") || changedProperties.has("negative")) {
+        this._proxyStateToChips();
+      }
+    }
+    /** @internal */
+    formResetCallback() {
+      this.value = null;
+    }
+    /** @internal */
+    formStateRestoreCallback(state, _reason) {
+      if (!state) {
+        this.value = null;
+        return;
+      }
+      this.value = state.map((entries) => entries[1]);
+    }
+    updateFormValue() {
+      const data = new FormData();
+      this.value.forEach((el) => data.append(this.name, el));
+      this.internals.setFormValue(data);
+      this.validate();
+      this._updateInputDescription();
+    }
+    shouldValidate(name) {
+      return super.shouldValidate(name) || name === "required";
+    }
+    validate() {
+      super.validate();
+      if (this.required && this.value.length === 0) {
+        this.setValidityFlag("valueMissing", i18nSelectionRequired[this._language.current]);
+      } else {
+        this.removeValidityFlag("valueMissing");
+      }
+    }
+    /** Return the list of chip elements **/
+    _chipElements() {
+      var _a2;
+      return Array.from(((_a2 = this.querySelectorAll) == null ? void 0 : _a2.call(this, "sbb-chip")) ?? []);
+    }
+    /** Return the list of enabled chip elements **/
+    _enabledChipElements() {
+      var _a2;
+      return Array.from(((_a2 = this.querySelectorAll) == null ? void 0 : _a2.call(this, "sbb-chip:not([disabled])")) ?? []);
+    }
+    _setupComponent() {
+      var _a2, _b, _c, _d, _e;
+      const input = this.querySelector("input");
+      if (input && input !== this._inputElement) {
+        (_a2 = this._inputAbortController) == null ? void 0 : _a2.abort();
+        (_b = this._inputAttributeObserver) == null ? void 0 : _b.disconnect();
+        this._inputElement = input;
+        this._inputAbortController = new AbortController();
+        this._inputElement.addEventListener("keydown", (ev) => this._onInputKeyDown(ev), {
+          signal: this._inputAbortController.signal
+        });
+        this._inputElement.addEventListener(inputAutocompleteEvent, () => this._createChipFromInput("autocomplete"), {
+          signal: this._inputAbortController.signal
+        });
+        (_c = this._inputAttributeObserver) == null ? void 0 : _c.observe(this._inputElement, {
+          attributes: true,
+          attributeFilter: ["readonly", "disabled"]
+        });
+      }
+      this._inheritSize();
+      (_d = this._formFieldAttributeObserver) == null ? void 0 : _d.disconnect();
+      const formField = this.closest("sbb-form-field");
+      if (formField) {
+        (_e = this._formFieldAttributeObserver) == null ? void 0 : _e.observe(formField, {
+          attributes: true,
+          attributeFilter: ["size"]
+        });
+      }
+      this.toggleAttribute("data-empty", this.value.length === 0);
+      this._reactToInputChanges();
+      this.updateFormValue();
+    }
+    /**
+     * Listen for keyboard events on the chip elements
+     **/
+    _onChipKeyDown(event) {
+      const eventTarget = event.target;
+      if (eventTarget.localName !== "sbb-chip") {
+        return;
+      }
+      if (isArrowKeyPressed(event)) {
+        const focusSteps = this._enabledChipElements();
+        const next = getNextElementIndex(event, focusSteps.indexOf(eventTarget), focusSteps.length);
+        focusSteps[next].focus();
+        return;
+      }
+      switch (event.key) {
+        case "Backspace":
+        case "Delete":
+          if (!eventTarget.readonly && !eventTarget.disabled) {
+            event.preventDefault();
+            this._deleteChip(eventTarget);
+          }
+          break;
+      }
+    }
+    /**
+     * Listen for keyboard events on the input
+     **/
+    _onInputKeyDown(event) {
+      switch (event.key) {
+        case "Backspace":
+        case "ArrowLeft":
+          if (!this._inputElement.value) {
+            this._focusChip();
+          }
+          break;
+        case "Enter":
+          event.preventDefault();
+          break;
+      }
+      if (this.separatorKeys.includes(event.key)) {
+        event.preventDefault();
+        this._createChipFromInput("input");
+      }
+    }
+    /**
+     * If the input is not empty, create a chip with its value
+     */
+    _createChipFromInput(origin = "input") {
+      const inputValue = this._inputElement.value.trim();
+      if (!inputValue) {
+        return;
+      }
+      const eventDetail = {
+        origin,
+        value: inputValue,
+        label: void 0,
+        setValue: (value) => eventDetail.value = value,
+        setLabel: (label) => eventDetail.label = label
+      };
+      if (!this._chipInputTokenEnd.emit(eventDetail)) {
+        return;
+      }
+      this._createChipElement(eventDetail.value, eventDetail.label);
+      this._inputElement.value = "";
+      this._emitInputEvents();
+    }
+    _deleteChip(chip) {
+      const chips = this._enabledChipElements();
+      chip.remove();
+      this._emitInputEvents();
+      this._focusChip(chips.indexOf(chip));
+    }
+    /**
+     * Focus an enabled chip. If none are present, focus the input
+     * @param index The index of the enabled chip. If null, focus the last one.
+     */
+    _focusChip(index) {
+      var _a2;
+      const enabledChips = this._enabledChipElements();
+      if (index !== void 0 && enabledChips[index]) {
+        enabledChips[index].focus();
+        return;
+      }
+      if (enabledChips.length > 0) {
+        enabledChips[enabledChips.length - 1].focus();
+        return;
+      }
+      (_a2 = this._inputElement) == null ? void 0 : _a2.focus();
+    }
+    _emitInputEvents() {
+      this._input.emit();
+      this._change.emit();
+    }
+    _createChipElement(value, label) {
+      const newChip = document.createElement("sbb-chip");
+      newChip.setAttribute("value", value);
+      newChip.innerText = label ?? "";
+      this.insertBefore(newChip, this._inputElement);
+    }
+    _reactToInputChanges() {
+      var _a2;
+      this.disabled = ((_a2 = this._inputElement) == null ? void 0 : _a2.disabled) ?? false;
+      this._proxyStateToChips();
+    }
+    _proxyStateToChips() {
+      this._chipElements().forEach((c) => {
+        var _a2;
+        c.disabled = this.disabled || this.formDisabled;
+        c.readonly = ((_a2 = this._inputElement) == null ? void 0 : _a2.hasAttribute("readonly")) ?? false;
+        c.negative = this.negative;
+      });
+    }
+    _inheritSize() {
+      var _a2;
+      this.setAttribute("data-size", ((_a2 = this.closest("sbb-form-field")) == null ? void 0 : _a2.size) ?? (isLean() ? "s" : "m"));
+    }
+    _updateInputDescription() {
+      if (!this._inputElement) {
+        return;
+      }
+      this._inputElement.setAttribute("aria-description", `${i18nChipGroupInputDescription[this._language.current]} ${this.value.length}`);
+    }
+    render() {
+      return html`
+      <div class="sbb-chip-group">
+        <slot @slotchange=${this._setupComponent}></slot>
+      </div>
+    `;
+    }
+  }, _separatorKeys_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _set_value_decorators = [property({ type: Array })];
+    _separatorKeys_decorators = [property({ attribute: "separator-keys", type: Array })];
+    __esDecorate(_a, null, _set_value_decorators, { kind: "setter", name: "value", static: false, private: false, access: { has: (obj) => "value" in obj, set: (obj, value) => {
+      obj.value = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _separatorKeys_decorators, { kind: "accessor", name: "separatorKeys", static: false, private: false, access: { has: (obj) => "separatorKeys" in obj, get: (obj) => obj.separatorKeys, set: (obj, value) => {
+      obj.separatorKeys = value;
+    } }, metadata: _metadata }, _separatorKeys_initializers, _separatorKeys_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    SbbChipGroupElement2 = _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = style, _a.events = {
+    input: "input",
+    change: "change",
+    chipInputTokenEnd: "chipInputTokenEnd"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a);
+  return SbbChipGroupElement2 = _classThis;
+})();
+export {
+  SbbChipGroupElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chip-group.js","sources":["../../../../../src/elements/chip/chip-group/chip-group.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport { inputAutocompleteEvent } from '../../autocomplete.js';\nimport { getNextElementIndex, isArrowKeyPressed } from '../../core/a11y.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { isLean } from '../../core/dom.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { i18nChipGroupInputDescription, i18nSelectionRequired } from '../../core/i18n.js';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbDisabledMixin,\n  SbbFormAssociatedMixin,\n  SbbNegativeMixin,\n  SbbRequiredMixin,\n} from '../../core/mixins.js';\nimport { SbbChipElement } from '../chip.js';\n\nimport style from './chip-group.scss?lit&inline';\n\nexport interface SbbChipInputTokenEndEventDetails {\n  /** The element that triggered the chip creation */\n  origin: 'input' | 'autocomplete';\n  /** The value of the new chip. Either the input or the option value depending on the origin */\n  value: string;\n  label?: string;\n  /** Set a new value for the chip that will be created */\n  setValue(value: string): void;\n  /** Set a label for the chip that will be created */\n  setLabel(value: string): void;\n}\n\n/**\n * The `sbb-chip-group` component is used as a container for one or multiple `sbb-chip`.\n *\n * @event {CustomEvent<void>} change - Notifies that the component's value has changed.\n * @event {CustomEvent<void>} input - Notifies that the component's value has changed.\n * @event {CustomEvent<SbbChipInputTokenEndEventDetails>} chipInputTokenEnd - Notifies that a chip is about to be created. Can be used to customize the value and the label. Can be prevented.\n * @slot - Use the unnamed slot to add `sbb-chip` elements.\n * @overrideType value - string[] | null\n */\nexport\n@customElement('sbb-chip-group')\nclass SbbChipGroupElement extends SbbRequiredMixin(\n  SbbDisabledMixin(\n    SbbNegativeMixin(SbbFormAssociatedMixin<typeof LitElement, string[]>(LitElement)),\n  ),\n) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    input: 'input',\n    change: 'change',\n    chipInputTokenEnd: 'chipInputTokenEnd',\n  } as const;\n\n  /** Value of the form element. */\n  @property({ type: Array })\n  public override set value(value: string[] | null) {\n    value = value ?? [];\n    super.value = value;\n    const oldValue = this.value;\n\n    // Subtract from 'oldValue' the new 'value'\n    // The result are the chips to remove (handle duplicates)\n    const toRemove = [...oldValue];\n    for (const c of value) {\n      if (toRemove.includes(c)) {\n        toRemove.splice(toRemove.indexOf(c), 1);\n      }\n    }\n    toRemove.forEach((value) =>\n      this._chipElements()\n        .find((c) => c.value === value)\n        ?.remove(),\n    );\n\n    // Subtract from the new 'value' what was already present\n    // The result are the new chips to add (handle duplicates)\n    const toAdd = [...value];\n    for (const c of oldValue) {\n      if (toAdd.includes(c)) {\n        toAdd.splice(toAdd.indexOf(c), 1);\n      }\n    }\n    toAdd.forEach((c) => this._createChipElement(c));\n  }\n  public override get value(): string[] {\n    return this._chipElements().map((c) => c.value);\n  }\n\n  /** The array of keys that will trigger a `chipInputTokenEnd` event. Default `['Enter']` */\n  @property({ attribute: 'separator-keys', type: Array })\n  public accessor separatorKeys: string[] = ['Enter'];\n\n  /** Notifies that the component's value has changed. */\n  private _change: EventEmitter = new EventEmitter(this, SbbChipGroupElement.events.change);\n\n  /** Notifies that the component's value has changed. */\n  private _input: EventEmitter = new EventEmitter(this, SbbChipGroupElement.events.input);\n\n  /** Notifies that a chip is about to be created. Can be prevented. */\n  private _chipInputTokenEnd = new EventEmitter<SbbChipInputTokenEndEventDetails>(\n    this,\n    SbbChipGroupElement.events.chipInputTokenEnd,\n  );\n\n  /**\n   * Listens to the changes on `readonly` and `disabled` attributes of `<input>`.\n   */\n  private _inputAttributeObserver = !isServer\n    ? new MutationObserver(() => this._reactToInputChanges())\n    : null;\n\n  /**\n   * Listens to the 'size' changes on the `sbb-form-field`.\n   */\n  private _formFieldAttributeObserver = !isServer\n    ? new MutationObserver(() => this._inheritSize())\n    : null;\n\n  private _inputElement: HTMLInputElement | undefined;\n  private _inputAbortController: AbortController | undefined;\n  private _language = new SbbLanguageController(this);\n\n  public constructor() {\n    super();\n\n    /** @internal */\n    this.internals.role = 'listbox';\n\n    this.addEventListener?.(SbbChipElement.events.requestDelete, (ev) =>\n      this._deleteChip(ev.target as SbbChipElement),\n    );\n\n    this.addEventListener?.('keydown', (ev) => this._onChipKeyDown(ev));\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this._setupComponent();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues): void {\n    super.willUpdate(changedProperties);\n\n    if (\n      changedProperties.has('disabled') ||\n      changedProperties.has('formDisabled') ||\n      changedProperties.has('negative')\n    ) {\n      this._proxyStateToChips();\n    }\n  }\n\n  /** @internal */\n  public formResetCallback(): void {\n    this.value = null;\n  }\n\n  /** @internal */\n  public formStateRestoreCallback(\n    state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {\n    if (!state) {\n      this.value = null;\n      return;\n    }\n\n    // the state format is ['field-name', 'value'][]\n    this.value = (state as [string, string][]).map((entries) => entries[1]);\n  }\n\n  protected updateFormValue(): void {\n    const data = new FormData();\n    this.value.forEach((el) => data.append(this.name, el));\n    this.internals.setFormValue(data);\n    this.validate();\n    this._updateInputDescription();\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return super.shouldValidate(name) || name === 'required';\n  }\n\n  protected override validate(): void {\n    super.validate();\n    if (this.required && this.value.length === 0) {\n      this.setValidityFlag('valueMissing', i18nSelectionRequired[this._language.current]);\n    } else {\n      this.removeValidityFlag('valueMissing');\n    }\n  }\n\n  /** Return the list of chip elements **/\n  private _chipElements(): SbbChipElement[] {\n    return Array.from(this.querySelectorAll?.('sbb-chip') ?? []);\n  }\n\n  /** Return the list of enabled chip elements **/\n  private _enabledChipElements(): SbbChipElement[] {\n    return Array.from(this.querySelectorAll?.('sbb-chip:not([disabled])') ?? []);\n  }\n\n  private _setupComponent(): void {\n    const input = this.querySelector('input');\n\n    // Connect to the input\n    if (input && input !== this._inputElement) {\n      this._inputAbortController?.abort();\n      this._inputAttributeObserver?.disconnect();\n      this._inputElement = input;\n\n      this._inputAbortController = new AbortController();\n      this._inputElement.addEventListener('keydown', (ev) => this._onInputKeyDown(ev), {\n        signal: this._inputAbortController.signal,\n      });\n      this._inputElement.addEventListener(\n        inputAutocompleteEvent,\n        () => this._createChipFromInput('autocomplete'),\n        {\n          signal: this._inputAbortController.signal,\n        },\n      );\n\n      this._inputAttributeObserver?.observe(this._inputElement, {\n        attributes: true,\n        attributeFilter: ['readonly', 'disabled'],\n      });\n    }\n\n    // Inherit size from the form-field and observe for changes\n    this._inheritSize();\n    this._formFieldAttributeObserver?.disconnect();\n    const formField = this.closest('sbb-form-field');\n    if (formField) {\n      this._formFieldAttributeObserver?.observe(formField, {\n        attributes: true,\n        attributeFilter: ['size'],\n      });\n    }\n\n    this.toggleAttribute('data-empty', this.value.length === 0);\n    this._reactToInputChanges();\n    this.updateFormValue();\n  }\n\n  /**\n   * Listen for keyboard events on the chip elements\n   **/\n  private _onChipKeyDown(event: KeyboardEvent): void {\n    const eventTarget = event.target as SbbChipElement;\n    if (eventTarget.localName !== 'sbb-chip') {\n      return;\n    }\n\n    // Arrow keys allow navigation between chips focus steps\n    if (isArrowKeyPressed(event)) {\n      const focusSteps = this._enabledChipElements();\n      const next = getNextElementIndex(event, focusSteps.indexOf(eventTarget), focusSteps.length);\n      focusSteps[next].focus();\n      return;\n    }\n\n    switch (event.key) {\n      case 'Backspace':\n      case 'Delete':\n        if (!eventTarget.readonly && !eventTarget.disabled) {\n          event.preventDefault();\n          this._deleteChip(eventTarget);\n        }\n        break;\n    }\n  }\n\n  /**\n   * Listen for keyboard events on the input\n   **/\n  private _onInputKeyDown(event: KeyboardEvent): void {\n    switch (event.key) {\n      case 'Backspace':\n      case 'ArrowLeft':\n        if (!this._inputElement!.value) {\n          this._focusChip();\n        }\n        break;\n      case 'Enter':\n        event.preventDefault(); // Prevents the form submit\n        break;\n    }\n\n    // if the user typed one of the separator keys, trigger a chipInputTokenEnd event\n    if (this.separatorKeys.includes(event.key)) {\n      event.preventDefault(); // prevent typing the separator key into the input\n      this._createChipFromInput('input');\n    }\n  }\n\n  /**\n   * If the input is not empty, create a chip with its value\n   */\n  private _createChipFromInput(origin: 'input' | 'autocomplete' = 'input'): void {\n    const inputValue = this._inputElement!.value.trim();\n    if (!inputValue) {\n      return;\n    }\n\n    const eventDetail: SbbChipInputTokenEndEventDetails = {\n      origin: origin,\n      value: inputValue,\n      label: undefined,\n      setValue: (value: string) => (eventDetail.value = value),\n      setLabel: (label: string) => (eventDetail.label = label),\n    };\n\n    if (!this._chipInputTokenEnd.emit(eventDetail)) {\n      return; // event prevented; do nothing (the consumer has to create the chip)\n    }\n\n    this._createChipElement(eventDetail.value, eventDetail.label);\n    this._inputElement!.value = ''; // Empty the input\n    this._emitInputEvents();\n  }\n\n  private _deleteChip(chip: SbbChipElement): void {\n    const chips = this._enabledChipElements();\n    chip.remove();\n    this._emitInputEvents();\n    this._focusChip(chips.indexOf(chip)); // Focus the next chip\n  }\n\n  /**\n   * Focus an enabled chip. If none are present, focus the input\n   * @param index The index of the enabled chip. If null, focus the last one.\n   */\n  private _focusChip(index?: number): void {\n    const enabledChips = this._enabledChipElements();\n\n    if (index !== undefined && enabledChips[index]) {\n      enabledChips[index].focus();\n      return;\n    }\n\n    if (enabledChips.length > 0) {\n      enabledChips[enabledChips.length - 1].focus();\n      return;\n    }\n\n    this._inputElement?.focus();\n  }\n\n  private _emitInputEvents(): void {\n    this._input.emit();\n    this._change.emit();\n  }\n\n  private _createChipElement(value: string, label?: string): void {\n    const newChip = document.createElement('sbb-chip');\n    newChip.setAttribute('value', value);\n    newChip.innerText = label ?? '';\n    this.insertBefore(newChip, this._inputElement!);\n  }\n\n  private _reactToInputChanges(): void {\n    this.disabled = this._inputElement?.disabled ?? false;\n    this._proxyStateToChips();\n  }\n\n  private _proxyStateToChips(): void {\n    this._chipElements().forEach((c) => {\n      c.disabled = this.disabled || this.formDisabled;\n      c.readonly = this._inputElement?.hasAttribute('readonly') ?? false;\n      c.negative = this.negative;\n    });\n  }\n\n  private _inheritSize(): void {\n    this.setAttribute('data-size', this.closest('sbb-form-field')?.size ?? (isLean() ? 's' : 'm'));\n  }\n\n  private _updateInputDescription(): void {\n    if (!this._inputElement) {\n      return;\n    }\n    this._inputElement.setAttribute(\n      'aria-description',\n      `${i18nChipGroupInputDescription[this._language.current]} ${this.value.length}`,\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-chip-group\">\n        <slot @slotchange=${this._setupComponent}></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-chip-group': SbbChipGroupElement;\n  }\n}\n"],"names":["SbbChipGroupElement","_a","value"],"mappings":"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"}

package/development/chip/chip-group.d.ts

@@ -1,2 +1,5 @@
+/**
+ * @entrypoint
+ */
 export * from './chip-group/chip-group.js';
 //# sourceMappingURL=chip-group.d.ts.map

package/development/chip/chip-group.d.ts.map

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