@sbb-esta/lyne-elements-dev 5.0.0-next.3-dev.1779195190 → 5.0.0-next.3-dev.1779200097

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

@@ -0,0 +1,395 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbElement, SbbFormAssociatedMixin, SbbLanguageController, SbbNegativeMixin, SbbPropertyWatcherController, SbbRequiredMixin, forceType, getNextElementIndex, i18nChipGroupInputDescription, i18nSelectionRequired, isArrowKeyPressed } from "./core.js";
+import { SbbChipElement } from "./chip/chip/chip.component.js";
+//#region src/elements/chip/chip-group/chip-group.scss?inline
+var chip_group_default = ":host {\n  width: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  gap: var(--sbb-chip-group-gap);\n  align-items: center;\n  margin-block: var(--sbb-chip-group-margin-block);\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host(:is(:is(:state(size-s),[state--size-s]), :is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: 0;\n}\n\n:host(:is(:state(size-s),[state--size-s]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-s);\n}\n\n:host(:is(:state(without-label),[state--without-label]):is(:state(size-s),[state--size-s]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-s);\n}\n\n:host(:is(:is(:state(size-l),[state--size-l]), :is(:state(size-m),[state--size-m]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-base-lm);\n}\n\n:host(:is(:state(without-label),[state--without-label]):is(:state(size-m),[state--size-m]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-m);\n}\n\n:host(:is(:state(without-label),[state--without-label]):not(:is(:state(empty),[state--empty]), :is(:state(size-s),[state--size-s]), :is(:state(size-m),[state--size-m]), :is(:state(size-l),[state--size-l]))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-no-label-not-empty);\n}\n\n:host(:not(:is(:state(without-label),[state--without-label])):is(:state(size-m),[state--size-m]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-m);\n}\n\n:host(:not(:is(:state(without-label),[state--without-label]), :is(:state(empty),[state--empty]), :is(:state(size-s),[state--size-s]), :is(:state(size-m),[state--size-m]), :is(:state(size-l),[state--size-l]))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-with-label-not-empty);\n}\n\n:host(:is(:state(without-label),[state--without-label]):is(:state(size-l),[state--size-l]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-l);\n}\n\n:host(:not(:is(:state(without-label),[state--without-label])):is(:state(size-l),[state--size-l]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-l);\n}\n\n::slotted(input) {\n  flex: 1 1 var(--sbb-chip-group-input-min-width);\n  max-height: 1.5rem;\n}\n\n::slotted(sbb-chip) {\n  max-width: 100%;\n}";
+//#endregion
+//#region src/elements/chip/chip-group/chip-group.component.ts
+var SbbChipInputTokenEndEvent = class extends Event {
+	constructor(options) {
+		super("chipinputtokenend", {
+			cancelable: true,
+			bubbles: true,
+			composed: true
+		});
+		this.origin = options.origin;
+		this.value = options.value;
+		this.label = options.label;
+	}
+	/** Set a new value for the chip that will be created */
+	setValue(value) {
+		this.value = value;
+	}
+	/** Set a label for the chip that will be created */
+	setLabel(label) {
+		this.label = label;
+	}
+};
+/**
+* The `sbb-chip-group` component is used as a container for one or multiple `sbb-chip`.
+*
+* @slot - Use the unnamed slot to add `sbb-chip` elements.
+* @event {SbbChipInputTokenEndEvent<T>} chipinputtokenend - Notifies that a chip is about to be created. Can be prevented.
+* @overrideType value - (T = string[]) | null
+*/
+var SbbChipGroupElement = (() => {
+	let _classSuper = SbbRequiredMixin(SbbDisabledMixin(SbbNegativeMixin(SbbFormAssociatedMixin(SbbElement))));
+	let _instanceExtraInitializers = [];
+	let _set_value_decorators;
+	let _displayWith_decorators;
+	let _displayWith_initializers = [];
+	let _displayWith_extraInitializers = [];
+	let _separatorKeys_decorators;
+	let _separatorKeys_initializers = [];
+	let _separatorKeys_extraInitializers = [];
+	let _addOnBlur_decorators;
+	let _addOnBlur_initializers = [];
+	let _addOnBlur_extraInitializers = [];
+	return class SbbChipGroupElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_set_value_decorators = [property({ type: Array })];
+			_displayWith_decorators = [property({ attribute: false })];
+			_separatorKeys_decorators = [property({
+				attribute: "separator-keys",
+				type: Array
+			})];
+			_addOnBlur_decorators = [forceType(), property({
+				attribute: "add-on-blur",
+				type: Boolean
+			})];
+			__esDecorate(this, 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(this, null, _displayWith_decorators, {
+				kind: "accessor",
+				name: "displayWith",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "displayWith" in obj,
+					get: (obj) => obj.displayWith,
+					set: (obj, value) => {
+						obj.displayWith = value;
+					}
+				},
+				metadata: _metadata
+			}, _displayWith_initializers, _displayWith_extraInitializers);
+			__esDecorate(this, 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(this, null, _addOnBlur_decorators, {
+				kind: "accessor",
+				name: "addOnBlur",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addOnBlur" in obj,
+					get: (obj) => obj.addOnBlur,
+					set: (obj, value) => {
+						obj.addOnBlur = value;
+					}
+				},
+				metadata: _metadata
+			}, _addOnBlur_initializers, _addOnBlur_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-chip-group";
+		}
+		static {
+			this.role = "listbox";
+		}
+		static {
+			this.styles = [unsafeCSS(chip_group_default)];
+		}
+		static {
+			this.events = {
+				input: "input",
+				change: "change",
+				chipinputtokenend: "chipinputtokenend"
+			};
+		}
+		/** Value of the form element. */
+		set value(value) {
+			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((value) => this._chipElements().find((c) => c.value === value)?.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);
+		}
+		#displayWith_accessor_storage;
+		/** Function that maps a chip's value to its display value. */
+		get displayWith() {
+			return this.#displayWith_accessor_storage;
+		}
+		set displayWith(value) {
+			this.#displayWith_accessor_storage = value;
+		}
+		#separatorKeys_accessor_storage;
+		/** The array of keys that will trigger a `chipinputtokenend` event. Default `['Enter']` */
+		get separatorKeys() {
+			return this.#separatorKeys_accessor_storage;
+		}
+		set separatorKeys(value) {
+			this.#separatorKeys_accessor_storage = value;
+		}
+		#addOnBlur_accessor_storage;
+		/** Whether to automatically add a chip when the input loses focus if there's a value. */
+		get addOnBlur() {
+			return this.#addOnBlur_accessor_storage;
+		}
+		set addOnBlur(value) {
+			this.#addOnBlur_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#displayWith_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _displayWith_initializers, null));
+			this.#separatorKeys_accessor_storage = (__runInitializers(this, _displayWith_extraInitializers), __runInitializers(this, _separatorKeys_initializers, ["Enter"]));
+			this.#addOnBlur_accessor_storage = (__runInitializers(this, _separatorKeys_extraInitializers), __runInitializers(this, _addOnBlur_initializers, false));
+			/**
+			* Listens to the changes on `readonly` and `disabled` attributes of `<input>`.
+			*/
+			this._inputAttributeObserver = (__runInitializers(this, _addOnBlur_extraInitializers), !isServer ? new MutationObserver(() => this._reactToInputChanges()) : null);
+			this._language = new SbbLanguageController(this);
+			this._previousSize = null;
+			this.addEventListener?.(SbbChipElement.events.requestdelete, (ev) => this._deleteChip(ev.target));
+			this.addEventListener?.("keydown", (ev) => this._onChipKeyDown(ev));
+			this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-form-field"), {
+				size: (formField) => this._updateSize(formField.size),
+				label: (formField) => this._updateLabelState(formField),
+				hiddenLabel: (formField) => this._updateLabelState(formField)
+			}));
+		}
+		_updateLabelState(formField) {
+			this.toggleState("without-label", !formField.label || formField.hiddenLabel);
+		}
+		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._readFormData(state).then((array) => this.value = array);
+		}
+		async _readFormData(formData) {
+			return Promise.all(formData.getAll(this.name).map(async (entry) => entry instanceof Blob ? JSON.parse(await entry.text()) : entry));
+		}
+		shouldValidate(name) {
+			return super.shouldValidate(name) || name === "required" || name === "value";
+		}
+		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() {
+			return Array.from(this.querySelectorAll?.("sbb-chip") ?? []);
+		}
+		/** Return the list of enabled chip elements **/
+		_enabledChipElements() {
+			return Array.from(this.querySelectorAll?.("sbb-chip:not([disabled])") ?? []);
+		}
+		_setupComponent() {
+			const input = this.querySelector("input");
+			if (input && input !== this._inputElement) {
+				this._inputAbortController?.abort();
+				this._inputAttributeObserver?.disconnect();
+				this._inputElement = input;
+				this._inputAbortController = new AbortController();
+				this._inputElement.addEventListener("keydown", (ev) => this._onInputKeyDown(ev), { signal: this._inputAbortController.signal });
+				this._inputElement.addEventListener("blur", () => this._onInputBlur(), {
+					signal: this._inputAbortController.signal,
+					capture: true
+				});
+				this._inputElement.addEventListener("inputAutocomplete", (event) => this._createChipFromInput("autocomplete", event.option.value), { signal: this._inputAbortController.signal });
+				this._inputAttributeObserver?.observe(this._inputElement, {
+					attributes: true,
+					attributeFilter: ["readonly", "disabled"]
+				});
+			}
+			if (!this.closest("sbb-form-field")) this._updateSize(null);
+			this.toggleState("empty", this.value.length === 0);
+			this._reactToInputChanges();
+			this._updateInputDescription();
+			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();
+				focusSteps[getNextElementIndex(event, focusSteps.indexOf(eventTarget), focusSteps.length)].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");
+			}
+		}
+		/**
+		* Handle blur event on the input
+		**/
+		_onInputBlur() {
+			if (this.addOnBlur) this._createChipFromInput("input");
+		}
+		/**
+		* If the input is not empty, create a chip with its value
+		*/
+		_createChipFromInput(origin = "input", value) {
+			const inputValue = value ?? this._inputElement.value.trim();
+			if (!inputValue) return;
+			const event = new SbbChipInputTokenEndEvent({
+				origin,
+				value: inputValue,
+				label: (value ? this.displayWith?.(value) : null) ?? void 0
+			});
+			if (!this.dispatchEvent(event)) return;
+			this._createChipElement(event.value, event.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) {
+			const enabledChips = this._enabledChipElements();
+			if (index !== void 0 && enabledChips[index]) {
+				enabledChips[index].focus();
+				return;
+			}
+			if (enabledChips.length > 0) {
+				enabledChips[enabledChips.length - 1].focus();
+				return;
+			}
+			this._inputElement?.focus();
+		}
+		_emitInputEvents() {
+			/** The input event fires when the value has been changed as a direct result of a user action. */
+			this.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				composed: true
+			}));
+			/**
+			* The change event is fired when the user modifies the element's value.
+			* Unlike the input event, the change event is not necessarily fired
+			* for each alteration to an element's value.
+			*/
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		_createChipElement(value, label) {
+			if (isServer) return;
+			const newChip = document.createElement("sbb-chip");
+			newChip.value = value;
+			newChip.innerText = label ?? (value ? this.displayWith?.(value) : null) ?? "";
+			this.insertBefore(newChip, this._inputElement ?? this.querySelector("input"));
+		}
+		_reactToInputChanges() {
+			this.disabled = this._inputElement?.disabled ?? false;
+			this._proxyStateToChips();
+		}
+		_proxyStateToChips() {
+			this._chipElements().forEach((c) => {
+				c.disabled = this.disabled || this.formDisabled;
+				c.readOnly = this._inputElement?.hasAttribute("readonly") ?? false;
+				c.negative = this.negative;
+			});
+		}
+		_updateSize(size) {
+			if (this._previousSize) this.internals.states.delete(`size-${this._previousSize}`);
+			this._previousSize = size;
+			if (this._previousSize) this.internals.states.add(`size-${this._previousSize}`);
+		}
+		_updateInputDescription() {
+			if (!this._inputElement) return;
+			this._inputElement.setAttribute("aria-description", `${i18nChipGroupInputDescription[this._language.current]} ${this.value.length}`);
+		}
+		render() {
+			return html`<slot @slotchange=${this._setupComponent}></slot>`;
+		}
+	};
+})();
+//#endregion
+export { SbbChipInputTokenEndEvent as n, SbbChipGroupElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chip-group.component-CVizDsAz.js","names":[],"sources":["../../../src/elements/chip/chip-group/chip-group.scss?inline","../../../src/elements/chip/chip-group/chip-group.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  width: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  gap: var(--sbb-chip-group-gap);\n  align-items: center;\n  margin-block: var(--sbb-chip-group-margin-block);\n\n  // Set the line-height for adjacent elements in order to prevent from influence of a consumer-set line-height.\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host(:is(:state(size-s), :state(empty))) {\n  --sbb-chip-group-margin-block: 0;\n}\n\n:host(:state(size-s):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-s);\n}\n\n:host(:state(without-label):state(size-s):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-s);\n}\n\n:host(:is(:state(size-l), :state(size-m))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-base-lm);\n}\n\n:host(:state(without-label):state(size-m):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-m);\n}\n\n:host(:state(without-label):not(:state(empty), :state(size-s), :state(size-m), :state(size-l))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-no-label-not-empty);\n}\n\n:host(:not(:state(without-label)):state(size-m):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-m);\n}\n\n:host(:not(:state(without-label), :state(empty), :state(size-s), :state(size-m), :state(size-l))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-with-label-not-empty);\n}\n\n:host(:state(without-label):state(size-l):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-l);\n}\n\n:host(:not(:state(without-label)):state(size-l):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-l);\n}\n\n::slotted(input) {\n  flex: 1 1 var(--sbb-chip-group-input-min-width);\n  max-height: #{sbb.px-to-rem-build(24)};\n}\n\n::slotted(sbb-chip) {\n  max-width: 100%;\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { SbbInputAutocompleteEvent } from '../../autocomplete/autocomplete-base-element.ts';\nimport {\n  forceType,\n  type FormRestoreReason,\n  type FormRestoreState,\n  getNextElementIndex,\n  i18nChipGroupInputDescription,\n  i18nSelectionRequired,\n  isArrowKeyPressed,\n  SbbDisabledMixin,\n  SbbElement,\n  SbbFormAssociatedMixin,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  SbbPropertyWatcherController,\n  SbbRequiredMixin,\n} from '../../core.ts';\nimport type { SbbFormFieldElement } from '../../form-field/form-field/form-field.component.ts';\nimport { SbbChipElement } from '../chip/chip.component.ts';\n\nimport style from './chip-group.scss?inline';\n\nlet displayWithWarningLogged = false;\n\nexport class SbbChipInputTokenEndEvent<T = string> extends Event {\n  /** The element that triggered the chip creation */\n  public origin: 'input' | 'autocomplete';\n  /**\n   * The value of the new chip. Either the input or the option value depending on the origin.\n   * Either the value from the input which is always `string` or the value from the selected option\n   * from an autocomplete, which can be either a string or any other type.\n   */\n  public value: T | string;\n  public label?: string;\n\n  public constructor(options: Pick<SbbChipInputTokenEndEvent, 'origin' | 'value' | 'label'>) {\n    super('chipinputtokenend', {\n      cancelable: true,\n      bubbles: true,\n      composed: true,\n    });\n    this.origin = options.origin;\n    this.value = options.value;\n    this.label = options.label;\n  }\n\n  /** Set a new value for the chip that will be created */\n  public setValue(value: T): void {\n    this.value = value;\n  }\n  /** Set a label for the chip that will be created */\n  public setLabel(label: string): void {\n    this.label = label;\n  }\n}\n\n/**\n * The `sbb-chip-group` component is used as a container for one or multiple `sbb-chip`.\n *\n * @slot - Use the unnamed slot to add `sbb-chip` elements.\n * @event {SbbChipInputTokenEndEvent<T>} chipinputtokenend - Notifies that a chip is about to be created. Can be prevented.\n * @overrideType value - (T = string[]) | null\n */\nexport class SbbChipGroupElement<T = string> extends SbbRequiredMixin(\n  SbbDisabledMixin(SbbNegativeMixin(SbbFormAssociatedMixin(SbbElement))),\n) {\n  public static override readonly elementName: string = 'sbb-chip-group';\n  public static override readonly role = 'listbox';\n  public static override styles: CSSResultGroup = [unsafeCSS(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 set value(value: (T | null)[] | null) {\n    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 get value(): (T | null)[] {\n    return this._chipElements().map((c) => c.value);\n  }\n\n  /** Function that maps a chip's value to its display value. */\n  @property({ attribute: false })\n  public accessor displayWith: ((value: T) => string) | null = null;\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  /** Whether to automatically add a chip when the input loses focus if there's a value. */\n  @forceType()\n  @property({ attribute: 'add-on-blur', type: Boolean })\n  public accessor addOnBlur: boolean = false;\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  private _inputElement: HTMLInputElement | undefined;\n  private _inputAbortController: AbortController | undefined;\n  private _language = new SbbLanguageController(this);\n  private _previousSize: SbbFormFieldElement['size'] = null;\n\n  public constructor() {\n    super();\n\n    this.addEventListener?.(SbbChipElement.events.requestdelete, (ev) =>\n      this._deleteChip(ev.target as SbbChipElement<T>),\n    );\n\n    this.addEventListener?.('keydown', (ev) => this._onChipKeyDown(ev));\n\n    this.addController(\n      new SbbPropertyWatcherController(this, () => this.closest('sbb-form-field'), {\n        size: (formField) => this._updateSize(formField.size),\n        label: (formField) => this._updateLabelState(formField),\n        hiddenLabel: (formField) => this._updateLabelState(formField),\n      }),\n    );\n  }\n\n  private _updateLabelState(formField: SbbFormFieldElement): void {\n    this.toggleState('without-label', !formField.label || formField.hiddenLabel);\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    this._readFormData(state as FormData).then((array) => (this.value = array));\n  }\n\n  private async _readFormData(formData: FormData): Promise<T[]> {\n    return Promise.all(\n      formData\n        .getAll(this.name)\n        .map(async (entry) =>\n          entry instanceof Blob ? JSON.parse(await entry.text()) : (entry as T),\n        ),\n    );\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return super.shouldValidate(name) || name === 'required' || name === 'value';\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<T>[] {\n    return Array.from(this.querySelectorAll?.<SbbChipElement<T>>('sbb-chip') ?? []);\n  }\n\n  /** Return the list of enabled chip elements **/\n  private _enabledChipElements(): SbbChipElement<T>[] {\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('blur', () => this._onInputBlur(), {\n        signal: this._inputAbortController.signal,\n        capture: true,\n      });\n      this._inputElement.addEventListener(\n        'inputAutocomplete',\n        (event: SbbInputAutocompleteEvent<T>) =>\n          this._createChipFromInput('autocomplete', event.option.value),\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    // If there is no form-field, reset size\n    if (!this.closest('sbb-form-field')) {\n      this._updateSize(null);\n    }\n\n    this.toggleState('empty', this.value.length === 0);\n    this._reactToInputChanges();\n    this._updateInputDescription();\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<T>;\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   * Handle blur event on the input\n   **/\n  private _onInputBlur(): void {\n    if (this.addOnBlur) {\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', value?: T): void {\n    const inputValue = value ?? this._inputElement!.value.trim();\n    if (!inputValue) {\n      return;\n    }\n\n    const event = new SbbChipInputTokenEndEvent<T>({\n      origin,\n      value: inputValue as string,\n      label: (value ? this.displayWith?.(value) : null) ?? undefined,\n    });\n    if (!this.dispatchEvent(event)) {\n      return; // event prevented; do nothing (the consumer has to create the chip)\n    }\n\n    this._createChipElement(event.value as T, event.label);\n    this._inputElement!.value = ''; // Empty the input\n    this._emitInputEvents();\n  }\n\n  private _deleteChip(chip: SbbChipElement<T>): 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    /** The input event fires when the value has been changed as a direct result of a user action. */\n    this.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n\n    /**\n     * The change event is fired when the user modifies the element's value.\n     * Unlike the input event, the change event is not necessarily fired\n     * for each alteration to an element's value.\n     */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\n  }\n\n  private _createChipElement(value: T | null, label?: string): void {\n    if (isServer) {\n      return;\n    }\n    const newChip = document.createElement('sbb-chip') as SbbChipElement<T>;\n    newChip.value = value;\n    newChip.innerText = label ?? (value ? this.displayWith?.(value) : null) ?? '';\n    if (\n      import.meta.env.DEV &&\n      !displayWithWarningLogged &&\n      !label &&\n      typeof value === 'object' &&\n      !this.displayWith\n    ) {\n      console.warn(\n        `displayWith has not been set yet for sbb-chip-group and value is an object.\n         If you are using object values, you need to provide displayWidth before\n         setting or selecting any value.`,\n      );\n      displayWithWarningLogged = true;\n    }\n    this.insertBefore(newChip, this._inputElement ?? this.querySelector('input'));\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 _updateSize(size: SbbFormFieldElement['size']): void {\n    if (this._previousSize) {\n      this.internals.states.delete(`size-${this._previousSize}`);\n    }\n    this._previousSize = size;\n    if (this._previousSize) {\n      this.internals.states.add(`size-${this._previousSize}`);\n    }\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`<slot @slotchange=${this._setupComponent}></slot>`;\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  interface HTMLElementEventMap {\n    chipinputtokenend: SbbChipInputTokenEndEvent<any>;\n  }\n}\n"],"mappings":"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"}

package/development/chip.js

@@ -1,4 +1,4 @@
-import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-Sgmi-kSy.js";
+import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-CVizDsAz.js";
 import { t as SbbChipElement } from "./chip.component-Uuf3tGFz.js";
 import "./chip.pure.js";
 //#region src/elements/chip.ts

package/development/chip.pure.js

@@ -1,3 +1,3 @@
-import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-Sgmi-kSy.js";
+import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-CVizDsAz.js";
 import { t as SbbChipElement } from "./chip.component-Uuf3tGFz.js";
 export { SbbChipElement, SbbChipGroupElement, SbbChipInputTokenEndEvent };

package/development/core/overlay/overlay-outside-pointer-event-listener.d.ts

@@ -20,7 +20,7 @@ export declare class SbbOverlayOutsidePointerEventListener {
 export declare const sbbOverlayOutsidePointerEventListener: SbbOverlayOutsidePointerEventListener;
 declare global {
     interface GlobalEventHandlersEventMap {
-        overlayOutsidePointer: CustomEvent;
+        overlayOutsidePointer: Event;
     }
 }
 //# sourceMappingURL=overlay-outside-pointer-event-listener.d.ts.map

package/development/core/overlay/overlay-outside-pointer-event-listener.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlay-outside-pointer-event-listener.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/overlay-outside-pointer-event-listener.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qBAAa,qCAAqC;IAChD,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,uBAAuB,CAAC,CAAc;IAC9C,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,oBAAoB,CAAC,CAAS;IAE/B,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAiBnC,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAW7C,OAAO,CAAC,wBAAwB;IAkBhC,+DAA+D;IAC/D,OAAO,CAAC,oBAAoB,CAE1B;IAEF,8EAA8E;IAC9E,OAAO,CAAC,cAAc,CAyBpB;CACH;AAED,oEAAoE;AACpE,eAAO,MAAM,qCAAqC,uCAA8C,CAAC;AAEjG,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,2BAA2B;QACnC,qBAAqB,EAAE,WAAW,CAAC;KACpC;CACF"}
+{"version":3,"file":"overlay-outside-pointer-event-listener.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/overlay-outside-pointer-event-listener.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qBAAa,qCAAqC;IAChD,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,uBAAuB,CAAC,CAAc;IAC9C,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,oBAAoB,CAAC,CAAS;IAE/B,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAiBnC,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAW7C,OAAO,CAAC,wBAAwB;IAkBhC,+DAA+D;IAC/D,OAAO,CAAC,oBAAoB,CAE1B;IAEF,8EAA8E;IAC9E,OAAO,CAAC,cAAc,CAyBpB;CACH;AAED,oEAAoE;AACpE,eAAO,MAAM,qCAAqC,uCAA8C,CAAC;AAEjG,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,2BAA2B;QACnC,qBAAqB,EAAE,KAAK,CAAC;KAC9B;CACF"}

package/development/core/overlay/overlay-outside-pointer-event-listener.js

@@ -20,7 +20,7 @@ var SbbOverlayOutsidePointerEventListener = class {
 			this._pointerDownEventTarget = void 0;
 			for (const overlay of Array.from(this._overlays).reverse()) {
 				if (containsPierceShadowDom(overlay, target) || containsPierceShadowDom(overlay, origin)) break;
-				overlay.dispatchEvent(new CustomEvent("overlayOutsidePointer"));
+				overlay.dispatchEvent(new Event("overlayOutsidePointer"));
 			}
 		};
 	}
@@ -63,4 +63,4 @@ var sbbOverlayOutsidePointerEventListener = new SbbOverlayOutsidePointerEventLis
 //#endregion
 export { SbbOverlayOutsidePointerEventListener, sbbOverlayOutsidePointerEventListener };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core.d.ts

@@ -44,7 +44,6 @@ export * from './core/eventing/forward-event.ts';
 export * from './core/eventing/is-event-prevented.ts';
 export * from './core/eventing/throttle.ts';
 export * from './core/i18n/i18n.ts';
-export * from './core/interfaces/overlay-close-details.ts';
 export * from './core/interfaces/types.ts';
 export * from './core/mixins/animation-complete-mixin.ts';
 export * from './core/mixins/constructor.ts';

package/development/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/elements/core.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,sDAAsD,CAAC;AACrE,cAAc,yBAAyB,CAAC;AACxC,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,mDAAmD,CAAC;AAClE,cAAc,iCAAiC,CAAC;AAChD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,0CAA0C,CAAC;AACzD,cAAc,uCAAuC,CAAC;AACtD,cAAc,wBAAwB,CAAC;AACvC,cAAc,wCAAwC,CAAC;AACvD,cAAc,sBAAsB,CAAC;AACrC,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iCAAiC,CAAC;AAChD,cAAc,0CAA0C,CAAC;AACzD,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iDAAiD,CAAC;AAChE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,wCAAwC,CAAC;AACvD,cAAc,qDAAqD,CAAC;AACpE,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0DAA0D,CAAC;AACzE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/elements/core.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,sDAAsD,CAAC;AACrE,cAAc,yBAAyB,CAAC;AACxC,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,mDAAmD,CAAC;AAClE,cAAc,iCAAiC,CAAC;AAChD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,0CAA0C,CAAC;AACzD,cAAc,uCAAuC,CAAC;AACtD,cAAc,wBAAwB,CAAC;AACvC,cAAc,wCAAwC,CAAC;AACvD,cAAc,sBAAsB,CAAC;AACrC,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iCAAiC,CAAC;AAChD,cAAc,0CAA0C,CAAC;AACzD,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iDAAiD,CAAC;AAChE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,wCAAwC,CAAC;AACvD,cAAc,qDAAqD,CAAC;AACpE,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0DAA0D,CAAC;AACzE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC"}

package/development/datepicker/datepicker/datepicker.component.d.ts

@@ -7,7 +7,7 @@ declare const SbbDatepickerElement_base: import('../../core.ts').AbstractConstru
 /**
  * A datepicker component that allows users to select a date from a calendar view.
  *
- * @event {CustomEvent<T>} dateselected - Event emitted on date selection.
+ * @event {SbbDateSelectedEvent<T>} dateselected - Event emitted on date selection.
  * @event {Event} change - The change event is fired on the datepicker's input when the user modifies the element's value. Unlike the input event, the change event is not necessarily fired for each alteration to an element's value.
  * @event {InputEvent} input - The input event fires  on the datepicker's input when the value has been changed as a direct result of a user action.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"datepicker.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker/datepicker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAGb,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAOL,KAAK,cAAc,EAIpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;;AAG9D;;;;;;GAMG;AACH,qBAAa,oBAAoB,CAAC,CAAC,GAAG,IAAI,CACxC,SAAQ,yBACR,YAAW,sBAAsB,CAAC,CAAC,CAAC;IAEpC,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,OAAuB,mBAAmB,EAAE,cAAc,EAAE,CAAwB;IACpF,OAAuB,MAAM,EAAE,cAAc,CAA4B;IACzE,gBAAuB,sBAAsB,QAAQ;IAErD,gDAAgD;IAChD,SAEgB,IAAI,EAAE,OAAO,CAAS;IAEtC;;;;OAIG;IACH,SAEgB,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAE5D,yEAAyE;IACzE,SAA4B,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAS;IAErE,OAAO,CAAC,qBAAqB,CAAC,CAAkB;IAChD,OAAO,CAAC,YAAY,CAA4E;IAChG,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,MAAM,CAAS;;IAaP,iBAAiB,IAAI,IAAI;IAczB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cAkBY,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAW9E,OAAO,CAAC,aAAa;cAmBF,aAAa,IAAI,cAAc;cAyB/B,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,oBAAoB,CAAC;KACxC;CACF"}
+{"version":3,"file":"datepicker.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker/datepicker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAIb,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAOL,KAAK,cAAc,EAIpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;;AAG9D;;;;;;GAMG;AACH,qBAAa,oBAAoB,CAAC,CAAC,GAAG,IAAI,CACxC,SAAQ,yBACR,YAAW,sBAAsB,CAAC,CAAC,CAAC;IAEpC,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,OAAuB,mBAAmB,EAAE,cAAc,EAAE,CAAwB;IACpF,OAAuB,MAAM,EAAE,cAAc,CAA4B;IACzE,gBAAuB,sBAAsB,QAAQ;IAErD,gDAAgD;IAChD,SAEgB,IAAI,EAAE,OAAO,CAAS;IAEtC;;;;OAIG;IACH,SAEgB,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAE5D,yEAAyE;IACzE,SAA4B,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAS;IAErE,OAAO,CAAC,qBAAqB,CAAC,CAAkB;IAChD,OAAO,CAAC,YAAY,CAA4E;IAChG,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,MAAM,CAAS;;IAaP,iBAAiB,IAAI,IAAI;IAczB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cAkBY,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAW9E,OAAO,CAAC,aAAa;cAmBF,aAAa,IAAI,cAAc;cAyB/B,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,oBAAoB,CAAC;KACxC;CACF"}