@sbb-esta/lyne-elements 3.3.0 → 3.4.0

package/development/file-selector/common/file-selector-common.js

@@ -15,11 +15,9 @@ import { SbbLanguageController } from "../../core/controllers.js";
 import { forceType } from "../../core/decorators.js";
 import { isLean } from "../../core/dom.js";
 import { forwardEvent } from "../../core/eventing.js";
-import { i18nFileSelectorCurrentlySelected, i18nFileSelectorDeleteFile, i18nFileSelectorButtonLabel } from "../../core/i18n.js";
+import { i18nFileSelectorButtonLabelMultiple, i18nFileSelectorButtonLabel, i18nFileSelectorCurrentlySelected, i18nFileSelectorDeleteFile } from "../../core/i18n.js";
 import { SbbDisabledMixin, SbbFormAssociatedMixin, SbbElementInternalsMixin } from "../../core/mixins.js";
 import "../../button/secondary-button.js";
-import "../../button/secondary-button-static.js";
-import "../../icon.js";
 const SbbFileSelectorCommonElementMixin = (superclass) => {
   let SbbFileSelectorCommonElement = (() => {
     var _size_accessor_storage, _multiple_accessor_storage, _multipleMode_accessor_storage, _accept_accessor_storage, _accessibilityLabel_accessor_storage, _a;
@@ -58,6 +56,7 @@ const SbbFileSelectorCommonElementMixin = (superclass) => {
         this._files = (__runInitializers(this, _accessibilityLabel_extraInitializers), []);
         this._suffixes = ["B", "kB", "MB", "GB", "TB"];
         this.language = new SbbLanguageController(this);
+        this._counter = 0;
       }
       /**
        * Size variant, either s or m.
@@ -158,10 +157,14 @@ const SbbFileSelectorCommonElementMixin = (superclass) => {
         forwardEvent(event, this);
       }
       createFileList(files) {
+        const fileArray = Array.from(files);
+        if (!this.multiple && files.length > 1 || this.accept && fileArray.some((file) => !this.accept.split(",").some((a) => file.name.endsWith(a.trim())))) {
+          return;
+        }
         if (!this.multiple || this.multipleMode !== "persistent" || this.files.length === 0) {
-          this.files = Array.from(files);
+          this.files = fileArray;
         } else {
-          this.files = Array.from(files).filter(
+          this.files = fileArray.filter(
             // Remove duplicates
             (newFile) => this.files.findIndex((oldFile) => this._checkFileEquality(newFile, oldFile)) === -1
           ).concat(this.files);
@@ -169,6 +172,9 @@ const SbbFileSelectorCommonElementMixin = (superclass) => {
         this._updateA11yLiveRegion();
         this._dispatchFileChangedEvent();
       }
+      getButtonLabel() {
+        return this.multiple ? i18nFileSelectorButtonLabelMultiple[this.language.current] : i18nFileSelectorButtonLabel[this.language.current];
+      }
       _removeFile(file) {
         this.files = this.files.filter((f) => !this._checkFileEquality(file, f));
         this._updateA11yLiveRegion();
@@ -214,24 +220,63 @@ const SbbFileSelectorCommonElementMixin = (superclass) => {
       </${unsafeStatic(TAG_NAME.WRAPPER)}>
     `;
       }
+      _onDragEnter(event) {
+        this._counter++;
+        if (!this.disabled && !this.formDisabled) {
+          this._setDragState(event.target, true);
+          this._blockEvent(event);
+        }
+      }
+      _onDragLeave(event) {
+        this._counter--;
+        if (!this.disabled && !this.formDisabled && event.target === this._dragTarget && this._counter === 0) {
+          this._setDragState();
+          this._blockEvent(event);
+        }
+      }
+      _onFileDrop(event) {
+        this._counter = 0;
+        if (!this.disabled && !this.formDisabled) {
+          this._setDragState();
+          this._blockEvent(event);
+          this.createFileList(event.dataTransfer.files);
+        }
+      }
+      _blockEvent(event) {
+        event.stopPropagation();
+        event.preventDefault();
+      }
+      _setDragState(dragTarget = void 0, isDragEnter = false) {
+        this._dragTarget = dragTarget;
+        this.toggleState("active", isDragEnter);
+        this.loadButton.toggleAttribute("data-active", isDragEnter);
+      }
       render() {
-        const ariaLabel = this.accessibilityLabel ? `${i18nFileSelectorButtonLabel[this.language.current]} - ${this.accessibilityLabel}` : void 0;
+        const ariaLabel = this.accessibilityLabel ? `${this.getButtonLabel()} - ${this.accessibilityLabel}` : void 0;
         return html`
         <div class="sbb-file-selector">
-          ${this.renderTemplate(html`<input
-              class="sbb-file-selector__visually-hidden"
-              type="file"
-              ?disabled="${this.disabled || this.formDisabled}"
-              ?multiple="${this.multiple}"
-              accept="${this.accept || nothing}"
-              aria-label="${ariaLabel || nothing}"
-              @change="${this._readFiles}"
-              @focus="${this._onFocus}"
-              @blur="${this._onBlur}"
-              ${ref((el) => {
+          <div
+            class="sbb-file-selector__input-container"
+            @dragenter=${this._onDragEnter}
+            @dragover=${this._blockEvent}
+            @dragleave=${this._onDragLeave}
+            @drop=${this._onFileDrop}
+          >
+            ${this.renderTemplate(html`<input
+                class="sbb-file-selector__visually-hidden"
+                type="file"
+                ?disabled="${this.disabled || this.formDisabled}"
+                ?multiple="${this.multiple}"
+                accept="${this.accept || nothing}"
+                aria-label="${ariaLabel || nothing}"
+                @change="${this._readFiles}"
+                @focus="${this._onFocus}"
+                @blur="${this._onBlur}"
+                ${ref((el) => {
           this._hiddenInput = el;
         })}
-            />`)}
+              />`)}
+          </div>
           <p
             role="status"
             class="sbb-file-selector__visually-hidden"
@@ -284,4 +329,4 @@ const SbbFileSelectorCommonElementMixin = (superclass) => {
 export {
   SbbFileSelectorCommonElementMixin
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"file-selector-common.js","sources":["../../../../../src/elements/file-selector/common/file-selector-common.ts"],"sourcesContent":["import type { LitElement, TemplateResult } from 'lit';\nimport { nothing } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { html, unsafeStatic } from 'lit/static-html.js';\n\nimport type { SbbSecondaryButtonStaticElement } from '../../button.js';\nimport { sbbInputModalityDetector } from '../../core/a11y.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { forceType } from '../../core/decorators.js';\nimport { isLean } from '../../core/dom.js';\nimport { forwardEvent } from '../../core/eventing.js';\nimport {\n  i18nFileSelectorButtonLabel,\n  i18nFileSelectorCurrentlySelected,\n  i18nFileSelectorDeleteFile,\n} from '../../core/i18n.js';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbDisabledMixin,\n  SbbFormAssociatedMixin,\n  type Constructor,\n  SbbElementInternalsMixin,\n} from '../../core/mixins.js';\n\nimport '../../button/secondary-button.js';\nimport '../../button/secondary-button-static.js';\nimport '../../icon.js';\n\nexport declare abstract class SbbFileSelectorCommonElementMixinType extends SbbDisabledMixin(\n  SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement)),\n) {\n  public accessor size: 's' | 'm';\n  public accessor multiple: boolean;\n  public accessor multipleMode: 'default' | 'persistent';\n  public accessor accept: string;\n  public accessor accessibilityLabel: string;\n  public accessor files: Readonly<File>[];\n  public override get value(): string | null;\n  public override set value(value: string | null);\n  protected loadButton: SbbSecondaryButtonStaticElement;\n  protected language: SbbLanguageController;\n  protected abstract renderTemplate(input: TemplateResult): TemplateResult;\n  protected createFileList(files: FileList): void;\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFileSelectorCommonElementMixin = <T extends Constructor<LitElement>>(\n  superclass: T,\n): Constructor<SbbFileSelectorCommonElementMixinType> & T => {\n  abstract class SbbFileSelectorCommonElement\n    extends SbbDisabledMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(superclass)))\n    implements Partial<SbbFileSelectorCommonElementMixinType>\n  {\n    public static readonly events = {\n      filechanged: 'filechanged',\n    } as const;\n\n    /**\n     * Size variant, either s or m.\n     * @default 'm' / 's' (lean)\n     */\n    @property({ reflect: true }) public accessor size: 's' | 'm' = isLean() ? 's' : 'm';\n\n    /** Whether more than one file can be selected. */\n    @forceType()\n    @property({ type: Boolean })\n    public accessor multiple: boolean = false;\n\n    /** Whether the newly added files should override the previously added ones. */\n    @property({ attribute: 'multiple-mode' })\n    public accessor multipleMode: 'default' | 'persistent' = 'default';\n\n    /** A comma-separated list of allowed unique file type specifiers. */\n    @forceType()\n    @property()\n    public accessor accept: string = '';\n\n    /** This will be forwarded as aria-label to the native input element. */\n    @forceType()\n    @property({ attribute: 'accessibility-label' })\n    public accessor accessibilityLabel: string = '';\n\n    /** The path of the first selected file. Empty string ('') if no file is selected */\n    @property({ attribute: false })\n    public set value(value: string | null) {\n      this._hiddenInput.value = value ?? '';\n\n      if (!value) {\n        this.files = [];\n      }\n    }\n    public get value(): string | null {\n      return this._hiddenInput?.value;\n    }\n\n    /** The list of selected files. */\n    @property({ attribute: false })\n    public set files(value: Readonly<File>[]) {\n      this._files = value ?? [];\n\n      // update the inner input\n      const dt: DataTransfer = new DataTransfer();\n      this.files.forEach((e: Readonly<File>) => dt.items.add(e));\n      this._hiddenInput.files = dt.files;\n\n      this.updateFormValue();\n    }\n    public get files(): Readonly<File>[] {\n      return this._files;\n    }\n    private _files: Readonly<File>[] = [];\n\n    /**\n     * Form type of element.\n     * @default 'file'\n     */\n    public override get type(): string {\n      return 'file';\n    }\n\n    private _hiddenInput!: HTMLInputElement;\n    private _suffixes: string[] = ['B', 'kB', 'MB', 'GB', 'TB'];\n    private _liveRegion!: HTMLParagraphElement;\n    protected loadButton!: SbbSecondaryButtonStaticElement;\n    protected language = new SbbLanguageController(this);\n\n    protected abstract renderTemplate(input: TemplateResult): TemplateResult;\n\n    public override formResetCallback(): void {\n      this.files = [];\n    }\n\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason?: FormRestoreReason,\n    ): void {\n      if (!state) {\n        return;\n      }\n      this.files = (state as FormData).getAll(this.name) as Readonly<File>[];\n    }\n\n    protected override updateFormValue(): void {\n      const formValue = new FormData();\n      this.files.forEach((file) => formValue.append(this.name, file));\n      this.internals.setFormValue(formValue);\n    }\n\n    private _checkFileEquality(file1: Readonly<File>, file2: Readonly<File>): boolean {\n      return (\n        file1.name === file2.name &&\n        file1.size === file2.size &&\n        file1.lastModified === file2.lastModified\n      );\n    }\n\n    private _onFocus(): void {\n      if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n        this.loadButton.toggleAttribute('data-focus-visible', true);\n      }\n    }\n\n    private _onBlur(): void {\n      this.loadButton.removeAttribute('data-focus-visible');\n    }\n\n    private _readFiles(event: Event): void {\n      const fileInput = event.target as HTMLInputElement;\n      if (fileInput.files) {\n        this.createFileList(fileInput.files);\n      }\n      forwardEvent(event, this);\n    }\n\n    protected createFileList(files: FileList): void {\n      if (!this.multiple || this.multipleMode !== 'persistent' || this.files.length === 0) {\n        this.files = Array.from(files);\n      } else {\n        this.files = Array.from(files)\n          .filter(\n            // Remove duplicates\n            (newFile: Readonly<File>): boolean =>\n              this.files!.findIndex((oldFile: Readonly<File>) =>\n                this._checkFileEquality(newFile, oldFile),\n              ) === -1,\n          )\n          .concat(this.files);\n      }\n      this._updateA11yLiveRegion();\n      this._dispatchFileChangedEvent();\n    }\n\n    private _removeFile(file: Readonly<File>): void {\n      this.files = this.files.filter((f: Readonly<File>) => !this._checkFileEquality(file, f));\n      this._updateA11yLiveRegion();\n\n      // Dispatch native events as if the reset is done via the file selection window.\n      /** The input event fires when the value has been changed as a direct result of a user action. */\n      this.dispatchEvent(\n        new InputEvent('input', {\n          bubbles: true,\n          composed: true,\n        }),\n      );\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      this._dispatchFileChangedEvent();\n    }\n\n    private _dispatchFileChangedEvent(): void {\n      /**\n       * @type {CustomEvent<Readonly<File>[]>}\n       * An event which is emitted each time the file list changes.\n       */\n      this.dispatchEvent(\n        new CustomEvent<Readonly<File>[]>('filechanged', {\n          bubbles: true,\n          composed: true,\n          detail: this.files,\n        }),\n      );\n    }\n\n    /** Calculates the correct unit for the file's size. */\n    private _formatFileSize(size: number): string {\n      const i: number = Math.floor(Math.log(size) / Math.log(1024));\n      return `${(size / Math.pow(1024, i)).toFixed(0)} ${this._suffixes[i]}`;\n    }\n\n    private _updateA11yLiveRegion(): void {\n      this._liveRegion.innerText = i18nFileSelectorCurrentlySelected(this.files.map((e) => e.name))[\n        this.language.current\n      ];\n    }\n\n    private _renderFileList(): TemplateResult {\n      const TAG_NAME: Record<string, string> =\n        this.files.length > 1\n          ? { WRAPPER: 'ul', ELEMENT: 'li' }\n          : { WRAPPER: 'div', ELEMENT: 'span' };\n\n      /* eslint-disable lit/binding-positions */\n      return html`\n      <${unsafeStatic(TAG_NAME.WRAPPER)} class='sbb-file-selector__file-list'>\n        ${this.files.map(\n          (file: Readonly<File>) => html`\n            <${unsafeStatic(TAG_NAME.ELEMENT)} class='sbb-file-selector__file'>\n                <span class='sbb-file-selector__file-details'>\n                  <span class='sbb-file-selector__file-name'>${file.name}</span>\n                  <span class='sbb-file-selector__file-size'>${this._formatFileSize(file.size)}</span>\n                </span>\n              <sbb-secondary-button\n                size='${this.size}'\n                icon-name='trash-small'\n                @click='${() => this._removeFile(file)}'\n                aria-label='${`${i18nFileSelectorDeleteFile[this.language.current]} - ${file.name}`}'\n              ></sbb-secondary-button>\n            </${unsafeStatic(TAG_NAME.ELEMENT)}>`,\n        )}\n      </${unsafeStatic(TAG_NAME.WRAPPER)}>\n    `;\n      /* eslint-enable lit/binding-positions */\n    }\n\n    protected override render(): TemplateResult {\n      const ariaLabel = this.accessibilityLabel\n        ? `${i18nFileSelectorButtonLabel[this.language.current]} - ${this.accessibilityLabel}`\n        : undefined;\n      return html`\n        <div class=\"sbb-file-selector\">\n          ${this.renderTemplate(\n            html`<input\n              class=\"sbb-file-selector__visually-hidden\"\n              type=\"file\"\n              ?disabled=\"${this.disabled || this.formDisabled}\"\n              ?multiple=\"${this.multiple}\"\n              accept=\"${this.accept || nothing}\"\n              aria-label=\"${ariaLabel || nothing}\"\n              @change=\"${this._readFiles}\"\n              @focus=\"${this._onFocus}\"\n              @blur=\"${this._onBlur}\"\n              ${ref((el?: Element): void => {\n                this._hiddenInput = el as HTMLInputElement;\n              })}\n            />`,\n          )}\n          <p\n            role=\"status\"\n            class=\"sbb-file-selector__visually-hidden\"\n            ${ref((p?: Element) => (this._liveRegion = p as HTMLParagraphElement))}\n          ></p>\n          ${this.files.length > 0 ? this._renderFileList() : nothing}\n          <div class=\"sbb-file-selector__error\">\n            <slot name=\"error\"></slot>\n          </div>\n        </div>\n      `;\n    }\n  }\n  return SbbFileSelectorCommonElement as unknown as Constructor<SbbFileSelectorCommonElementMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"file-selector-common.js","sources":["../../../../../src/elements/file-selector/common/file-selector-common.ts"],"sourcesContent":["import type { LitElement, TemplateResult } from 'lit';\nimport { nothing } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { html, unsafeStatic } from 'lit/static-html.js';\n\nimport type { SbbSecondaryButtonStaticElement } from '../../button.js';\nimport { sbbInputModalityDetector } from '../../core/a11y.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { forceType } from '../../core/decorators.js';\nimport { isLean } from '../../core/dom.js';\nimport { forwardEvent } from '../../core/eventing.js';\nimport {\n  i18nFileSelectorButtonLabel,\n  i18nFileSelectorButtonLabelMultiple,\n  i18nFileSelectorCurrentlySelected,\n  i18nFileSelectorDeleteFile,\n} from '../../core/i18n.js';\nimport {\n  type Constructor,\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbDisabledMixin,\n  SbbElementInternalsMixin,\n  SbbFormAssociatedMixin,\n} from '../../core/mixins.js';\n\nimport '../../button/secondary-button.js';\n\nexport declare abstract class SbbFileSelectorCommonElementMixinType extends SbbDisabledMixin(\n  SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement)),\n) {\n  public accessor size: 's' | 'm';\n  public accessor multiple: boolean;\n  public accessor multipleMode: 'default' | 'persistent';\n  public accessor accept: string;\n  public accessor accessibilityLabel: string;\n  public accessor files: Readonly<File>[];\n  public override get value(): string | null;\n  public override set value(value: string | null);\n  protected loadButton: SbbSecondaryButtonStaticElement;\n  protected language: SbbLanguageController;\n  protected abstract renderTemplate(input: TemplateResult): TemplateResult;\n  protected createFileList(files: FileList): void;\n  protected getButtonLabel(): string;\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFileSelectorCommonElementMixin = <T extends Constructor<LitElement>>(\n  superclass: T,\n): Constructor<SbbFileSelectorCommonElementMixinType> & T => {\n  abstract class SbbFileSelectorCommonElement\n    extends SbbDisabledMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(superclass)))\n    implements Partial<SbbFileSelectorCommonElementMixinType>\n  {\n    public static readonly events = {\n      filechanged: 'filechanged',\n    } as const;\n\n    /**\n     * Size variant, either s or m.\n     * @default 'm' / 's' (lean)\n     */\n    @property({ reflect: true }) public accessor size: 's' | 'm' = isLean() ? 's' : 'm';\n\n    /** Whether more than one file can be selected. */\n    @forceType()\n    @property({ type: Boolean })\n    public accessor multiple: boolean = false;\n\n    /** Whether the newly added files should override the previously added ones. */\n    @property({ attribute: 'multiple-mode' })\n    public accessor multipleMode: 'default' | 'persistent' = 'default';\n\n    /** A comma-separated list of allowed unique file type specifiers. */\n    @forceType()\n    @property()\n    public accessor accept: string = '';\n\n    /** This will be forwarded as aria-label to the native input element. */\n    @forceType()\n    @property({ attribute: 'accessibility-label' })\n    public accessor accessibilityLabel: string = '';\n\n    /** The path of the first selected file. Empty string ('') if no file is selected */\n    @property({ attribute: false })\n    public set value(value: string | null) {\n      this._hiddenInput.value = value ?? '';\n\n      if (!value) {\n        this.files = [];\n      }\n    }\n    public get value(): string | null {\n      return this._hiddenInput?.value;\n    }\n\n    /** The list of selected files. */\n    @property({ attribute: false })\n    public set files(value: Readonly<File>[]) {\n      this._files = value ?? [];\n\n      // update the inner input\n      const dt: DataTransfer = new DataTransfer();\n      this.files.forEach((e: Readonly<File>) => dt.items.add(e));\n      this._hiddenInput.files = dt.files;\n\n      this.updateFormValue();\n    }\n    public get files(): Readonly<File>[] {\n      return this._files;\n    }\n    private _files: Readonly<File>[] = [];\n\n    /**\n     * Form type of element.\n     * @default 'file'\n     */\n    public override get type(): string {\n      return 'file';\n    }\n\n    private _hiddenInput!: HTMLInputElement;\n    private _suffixes: string[] = ['B', 'kB', 'MB', 'GB', 'TB'];\n    private _liveRegion!: HTMLParagraphElement;\n    protected loadButton!: SbbSecondaryButtonStaticElement;\n    protected language = new SbbLanguageController(this);\n\n    // Safari has a peculiar behavior when dragging files on the inner button in 'dropzone' variant;\n    // this will require a counter to correctly handle the dragEnter/dragLeave.\n    private _counter: number = 0;\n    private _dragTarget?: HTMLElement;\n\n    protected abstract renderTemplate(input: TemplateResult): TemplateResult;\n\n    public override formResetCallback(): void {\n      this.files = [];\n    }\n\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason?: FormRestoreReason,\n    ): void {\n      if (!state) {\n        return;\n      }\n      this.files = (state as FormData).getAll(this.name) as Readonly<File>[];\n    }\n\n    protected override updateFormValue(): void {\n      const formValue = new FormData();\n      this.files.forEach((file) => formValue.append(this.name, file));\n      this.internals.setFormValue(formValue);\n    }\n\n    private _checkFileEquality(file1: Readonly<File>, file2: Readonly<File>): boolean {\n      return (\n        file1.name === file2.name &&\n        file1.size === file2.size &&\n        file1.lastModified === file2.lastModified\n      );\n    }\n\n    private _onFocus(): void {\n      if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n        this.loadButton.toggleAttribute('data-focus-visible', true);\n      }\n    }\n\n    private _onBlur(): void {\n      this.loadButton.removeAttribute('data-focus-visible');\n    }\n\n    private _readFiles(event: Event): void {\n      const fileInput = event.target as HTMLInputElement;\n      if (fileInput.files) {\n        this.createFileList(fileInput.files);\n      }\n      forwardEvent(event, this);\n    }\n\n    protected createFileList(files: FileList): void {\n      const fileArray = Array.from(files);\n      if (\n        (!this.multiple && files.length > 1) ||\n        (this.accept &&\n          fileArray.some(\n            (file) => !this.accept.split(',').some((a) => file.name.endsWith(a.trim())),\n          ))\n      ) {\n        // If multiple files are selected but the selector is not in multiple mode,\n        // ignore the selection (like native behavior).\n        // If the accept attribute is set, check if the selected files match the allowed types.\n        return;\n      }\n\n      if (!this.multiple || this.multipleMode !== 'persistent' || this.files.length === 0) {\n        this.files = fileArray;\n      } else {\n        this.files = fileArray\n          .filter(\n            // Remove duplicates\n            (newFile: Readonly<File>): boolean =>\n              this.files!.findIndex((oldFile: Readonly<File>) =>\n                this._checkFileEquality(newFile, oldFile),\n              ) === -1,\n          )\n          .concat(this.files);\n      }\n      this._updateA11yLiveRegion();\n      this._dispatchFileChangedEvent();\n    }\n\n    protected getButtonLabel(): string {\n      return this.multiple\n        ? i18nFileSelectorButtonLabelMultiple[this.language.current]\n        : i18nFileSelectorButtonLabel[this.language.current];\n    }\n\n    private _removeFile(file: Readonly<File>): void {\n      this.files = this.files.filter((f: Readonly<File>) => !this._checkFileEquality(file, f));\n      this._updateA11yLiveRegion();\n\n      // Dispatch native events as if the reset is done via the file selection window.\n      /** The input event fires when the value has been changed as a direct result of a user action. */\n      this.dispatchEvent(\n        new InputEvent('input', {\n          bubbles: true,\n          composed: true,\n        }),\n      );\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      this._dispatchFileChangedEvent();\n    }\n\n    private _dispatchFileChangedEvent(): void {\n      /**\n       * @type {CustomEvent<Readonly<File>[]>}\n       * An event which is emitted each time the file list changes.\n       */\n      this.dispatchEvent(\n        new CustomEvent<Readonly<File>[]>('filechanged', {\n          bubbles: true,\n          composed: true,\n          detail: this.files,\n        }),\n      );\n    }\n\n    /** Calculates the correct unit for the file's size. */\n    private _formatFileSize(size: number): string {\n      const i: number = Math.floor(Math.log(size) / Math.log(1024));\n      return `${(size / Math.pow(1024, i)).toFixed(0)} ${this._suffixes[i]}`;\n    }\n\n    private _updateA11yLiveRegion(): void {\n      this._liveRegion.innerText = i18nFileSelectorCurrentlySelected(this.files.map((e) => e.name))[\n        this.language.current\n      ];\n    }\n\n    private _renderFileList(): TemplateResult {\n      const TAG_NAME: Record<string, string> =\n        this.files.length > 1\n          ? { WRAPPER: 'ul', ELEMENT: 'li' }\n          : { WRAPPER: 'div', ELEMENT: 'span' };\n\n      /* eslint-disable lit/binding-positions */\n      return html`\n      <${unsafeStatic(TAG_NAME.WRAPPER)} class='sbb-file-selector__file-list'>\n        ${this.files.map(\n          (file: Readonly<File>) => html`\n            <${unsafeStatic(TAG_NAME.ELEMENT)} class='sbb-file-selector__file'>\n                <span class='sbb-file-selector__file-details'>\n                  <span class='sbb-file-selector__file-name'>${file.name}</span>\n                  <span class='sbb-file-selector__file-size'>${this._formatFileSize(file.size)}</span>\n                </span>\n              <sbb-secondary-button\n                size='${this.size}'\n                icon-name='trash-small'\n                @click='${() => this._removeFile(file)}'\n                aria-label='${`${i18nFileSelectorDeleteFile[this.language.current]} - ${file.name}`}'\n              ></sbb-secondary-button>\n            </${unsafeStatic(TAG_NAME.ELEMENT)}>`,\n        )}\n      </${unsafeStatic(TAG_NAME.WRAPPER)}>\n    `;\n      /* eslint-enable lit/binding-positions */\n    }\n\n    private _onDragEnter(event: DragEvent): void {\n      this._counter++;\n      if (!this.disabled && !this.formDisabled) {\n        this._setDragState(event.target as HTMLElement, true);\n        this._blockEvent(event);\n      }\n    }\n\n    private _onDragLeave(event: DragEvent): void {\n      this._counter--;\n      if (\n        !this.disabled &&\n        !this.formDisabled &&\n        event.target === this._dragTarget &&\n        this._counter === 0\n      ) {\n        this._setDragState();\n        this._blockEvent(event);\n      }\n    }\n\n    private _onFileDrop(event: DragEvent): void {\n      this._counter = 0;\n      if (!this.disabled && !this.formDisabled) {\n        this._setDragState();\n        this._blockEvent(event);\n        this.createFileList(event.dataTransfer!.files);\n      }\n    }\n\n    private _blockEvent(event: DragEvent): void {\n      event.stopPropagation();\n      event.preventDefault();\n    }\n\n    private _setDragState(\n      dragTarget: HTMLElement | undefined = undefined,\n      isDragEnter: boolean = false,\n    ): void {\n      this._dragTarget = dragTarget;\n      this.toggleState('active', isDragEnter);\n      this.loadButton.toggleAttribute('data-active', isDragEnter);\n    }\n\n    protected override render(): TemplateResult {\n      const ariaLabel = this.accessibilityLabel\n        ? `${this.getButtonLabel()} - ${this.accessibilityLabel}`\n        : undefined;\n      return html`\n        <div class=\"sbb-file-selector\">\n          <div\n            class=\"sbb-file-selector__input-container\"\n            @dragenter=${this._onDragEnter}\n            @dragover=${this._blockEvent}\n            @dragleave=${this._onDragLeave}\n            @drop=${this._onFileDrop}\n          >\n            ${this.renderTemplate(\n              html`<input\n                class=\"sbb-file-selector__visually-hidden\"\n                type=\"file\"\n                ?disabled=\"${this.disabled || this.formDisabled}\"\n                ?multiple=\"${this.multiple}\"\n                accept=\"${this.accept || nothing}\"\n                aria-label=\"${ariaLabel || nothing}\"\n                @change=\"${this._readFiles}\"\n                @focus=\"${this._onFocus}\"\n                @blur=\"${this._onBlur}\"\n                ${ref((el?: Element): void => {\n                  this._hiddenInput = el as HTMLInputElement;\n                })}\n              />`,\n            )}\n          </div>\n          <p\n            role=\"status\"\n            class=\"sbb-file-selector__visually-hidden\"\n            ${ref((p?: Element) => (this._liveRegion = p as HTMLParagraphElement))}\n          ></p>\n          ${this.files.length > 0 ? this._renderFileList() : nothing}\n          <div class=\"sbb-file-selector__error\">\n            <slot name=\"error\"></slot>\n          </div>\n        </div>\n      `;\n    }\n  }\n  return SbbFileSelectorCommonElement as unknown as Constructor<SbbFileSelectorCommonElementMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}

package/development/file-selector/common.js

@@ -1,5 +1,5 @@
 import { SbbFileSelectorCommonElementMixin } from "./common/file-selector-common.js";
-import { f } from "../file-selector-common-csww18o8.js";
+import { f } from "../file-selector-common-BxXdRZxt.js";
 export {
   SbbFileSelectorCommonElementMixin,
   f as fileSelectorCommonStyle

package/development/file-selector/file-selector/file-selector.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-selector.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/file-selector/file-selector/file-selector.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAU3E,OAAO,kCAAkC,CAAC;AAC1C,OAAO,yCAAyC,CAAC;AACjD,OAAO,eAAe,CAAC;;AAEvB;;;;GAIG;AACH,qBAGM,sBAAuB,SAAQ,2BAA6C;IAChF,OAAuB,MAAM,EAAE,cAAc,CAA2B;IACxE,gBAAuB,MAAM;;MAElB;cAEQ,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc;CAmBzE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,mBAAmB,EAAE,sBAAsB,CAAC;KAC7C;CACF"}
+{"version":3,"file":"file-selector.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/file-selector/file-selector/file-selector.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAS3E,OAAO,yCAAyC,CAAC;;AAEjD;;;;GAIG;AACH,qBAGM,sBAAuB,SAAQ,2BAA6C;IAChF,OAAuB,MAAM,EAAE,cAAc,CAA2B;IACxE,gBAAuB,MAAM;;MAElB;cAEQ,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc;CAiBzE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,mBAAmB,EAAE,sBAAsB,CAAC;KAC7C;CACF"}

package/development/file-selector/file-selector/file-selector.component.js

@@ -4,11 +4,8 @@ import { customElement } from "lit/decorators.js";
 import { ref } from "lit/directives/ref.js";
 import { html } from "lit/static-html.js";
 import { slotState } from "../../core/decorators.js";
-import { i18nFileSelectorButtonLabel } from "../../core/i18n.js";
 import { SbbFileSelectorCommonElementMixin, fileSelectorCommonStyle } from "../common.js";
-import "../../button/secondary-button.js";
 import "../../button/secondary-button-static.js";
-import "../../icon.js";
 let SbbFileSelectorElement = (() => {
   var _a;
   let _classDecorators = [customElement("sbb-file-selector"), slotState()];
@@ -19,21 +16,19 @@ let SbbFileSelectorElement = (() => {
   _a = class extends _classSuper {
     renderTemplate(input) {
       return html`
-      <div class="sbb-file-selector__input-container">
-        <label>
-          <sbb-secondary-button-static
-            size=${this.size}
-            icon-name="folder-open-small"
-            ?disabled=${this.disabled || this.formDisabled}
-            ${ref((el) => {
+      <label>
+        <sbb-secondary-button-static
+          size=${this.size}
+          icon-name="folder-open-small"
+          ?disabled=${this.disabled || this.formDisabled}
+          ${ref((el) => {
         this.loadButton = el;
       })}
-          >
-            ${i18nFileSelectorButtonLabel[this.language.current]}
-          </sbb-secondary-button-static>
-          ${input}
-        </label>
-      </div>
+        >
+          ${this.getButtonLabel()}
+        </sbb-secondary-button-static>
+        ${input}
+      </label>
     `;
     }
   }, _classThis = _a, (() => {
@@ -49,4 +44,4 @@ let SbbFileSelectorElement = (() => {
 export {
   SbbFileSelectorElement
 };
-//# 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/file-selector/file-selector-dropzone/file-selector-dropzone.component.d.ts

@@ -12,13 +12,6 @@ export declare class SbbFileSelectorDropzoneElement extends SbbFileSelectorDropz
     };
     /** The title displayed in `dropzone` variant. */
     accessor titleContent: string;
-    private _counter;
-    private _dragTarget?;
-    private _blockEvent;
-    private _onDragEnter;
-    private _onDragLeave;
-    private _onFileDrop;
-    private _setDragState;
     protected renderTemplate(input: TemplateResult): TemplateResult;
 }
 declare global {

package/development/file-selector/file-selector-dropzone/file-selector-dropzone.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-selector-dropzone.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/file-selector/file-selector-dropzone/file-selector-dropzone.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAU3E,OAAO,kCAAkC,CAAC;AAC1C,OAAO,yCAAyC,CAAC;AACjD,OAAO,eAAe,CAAC;;AAIvB;;;;GAIG;AACH,qBAGM,8BAA+B,SAAQ,mCAA6C;IACxF,OAAuB,MAAM,EAAE,cAAc,CAAoC;IACjF,gBAAuB,MAAM;;MAElB;IAEX,iDAAiD;IACjD,SAEgB,YAAY,EAAE,MAAM,CAAM;IAI1C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,WAAW,CAAC,CAAc;IAElC,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,aAAa;cASF,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc;CAqCzE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,4BAA4B,EAAE,8BAA8B,CAAC;KAC9D;CACF"}
+{"version":3,"file":"file-selector-dropzone.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/file-selector/file-selector-dropzone/file-selector-dropzone.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAa3E,OAAO,yCAAyC,CAAC;AACjD,OAAO,eAAe,CAAC;;AAIvB;;;;GAIG;AACH,qBAGM,8BAA+B,SAAQ,mCAA6C;IACxF,OAAuB,MAAM,EAAE,cAAc,CAAoC;IACjF,gBAAuB,MAAM;;MAElB;IAEX,iDAAiD;IACjD,SAEgB,YAAY,EAAE,MAAM,CAAM;cAEvB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc;CA+BzE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,4BAA4B,EAAE,8BAA8B,CAAC;KAC9D;CACF"}

package/development/file-selector/file-selector-dropzone/file-selector-dropzone.component.js

@@ -5,15 +5,14 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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 { __runInitializers, __esDecorate } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { css, LitElement } from "lit";
 import { customElement, property } from "lit/decorators.js";
 import { ref } from "lit/directives/ref.js";
 import { html } from "lit/static-html.js";
 import { slotState, forceType } from "../../core/decorators.js";
-import { i18nFileSelectorSubtitleLabel, i18nFileSelectorButtonLabel } from "../../core/i18n.js";
+import { i18nFileSelectorSubtitleLabelMultiple, i18nFileSelectorSubtitleLabel } from "../../core/i18n.js";
 import { SbbFileSelectorCommonElementMixin, fileSelectorCommonStyle } from "../common.js";
-import "../../button/secondary-button.js";
 import "../../button/secondary-button-static.js";
 import "../../icon.js";
 const style = css`*,
@@ -42,18 +41,15 @@ const style = css`*,
 
 .sbb-file-selector__dropzone-area--title {
   font-weight: bold;
-  --sbb-title-line-height: var(--sbb-typo-line-height-titles);
-  --sbb-title-margin-block-start: 0;
-  --sbb-title-margin-block-end: 0;
-  margin: 0;
-  margin-block: var(--sbb-title-margin-block-start) var(--sbb-title-margin-block-end);
+  --sbb-title-font-size: var(--sbb-title-font-size-level-6);
+  --sbb-title-line-height: var(--sbb-typo-line-height-body-text);
+  margin-block: var(--sbb-title-margin-block-start, 0) var(--sbb-title-margin-block-end, 0);
+  margin-inline: 0;
   font-family: var(--sbb-typo-font-family);
   font-weight: bold;
-  line-height: var(--sbb-title-line-height);
+  line-height: var(--sbb-title-line-height, var(--sbb-typo-line-height-titles));
   letter-spacing: var(--sbb-typo-letter-spacing-titles);
   font-size: var(--sbb-title-font-size);
-  --sbb-title-font-size: var(--sbb-font-size-title-6);
-  --sbb-title-line-height: var(--sbb-typo-line-height-body-text);
   text-align: center;
   color: var(--sbb-file-selector-color);
 }
@@ -82,9 +78,8 @@ let SbbFileSelectorDropzoneElement = (() => {
   _a = class extends _classSuper {
     constructor() {
       super(...arguments);
-      __privateAdd(this, _titleContent_accessor_storage);
-      __privateSet(this, _titleContent_accessor_storage, __runInitializers(this, _titleContent_initializers, ""));
-      this._counter = (__runInitializers(this, _titleContent_extraInitializers), 0);
+      __privateAdd(this, _titleContent_accessor_storage, __runInitializers(this, _titleContent_initializers, ""));
+      __runInitializers(this, _titleContent_extraInitializers);
     }
     /** The title displayed in `dropzone` variant. */
     get titleContent() {
@@ -93,72 +88,33 @@ let SbbFileSelectorDropzoneElement = (() => {
     set titleContent(value) {
       __privateSet(this, _titleContent_accessor_storage, value);
     }
-    _blockEvent(event) {
-      event.stopPropagation();
-      event.preventDefault();
-    }
-    _onDragEnter(event) {
-      this._counter++;
-      if (!this.disabled && !this.formDisabled) {
-        this._setDragState(event.target, true);
-        this._blockEvent(event);
-      }
-    }
-    _onDragLeave(event) {
-      this._counter--;
-      if (!this.disabled && !this.formDisabled && event.target === this._dragTarget && this._counter === 0) {
-        this._setDragState();
-        this._blockEvent(event);
-      }
-    }
-    _onFileDrop(event) {
-      this._counter = 0;
-      if (!this.disabled && !this.formDisabled) {
-        this._setDragState();
-        this._blockEvent(event);
-        this.createFileList(event.dataTransfer.files);
-      }
-    }
-    _setDragState(dragTarget = void 0, isDragEnter = false) {
-      this._dragTarget = dragTarget;
-      this.toggleAttribute("data-active", isDragEnter);
-      this.loadButton.toggleAttribute("data-active", isDragEnter);
-    }
     renderTemplate(input) {
       return html`
-      <div
-        class="sbb-file-selector__input-container"
-        @dragenter=${this._onDragEnter}
-        @dragover=${this._blockEvent}
-        @dragleave=${this._onDragLeave}
-        @drop=${this._onFileDrop}
-      >
-        <label>
-          <span class="sbb-file-selector__dropzone-area">
-            <span class="sbb-file-selector__dropzone-area--icon">
-              <sbb-icon
-                name=${this.size === "m" ? "folder-open-medium" : "folder-open-small"}
-              ></sbb-icon>
-            </span>
-            <span class="sbb-file-selector__dropzone-area--title">${this.titleContent}</span>
-            <span class="sbb-file-selector__dropzone-area--subtitle">
-              ${i18nFileSelectorSubtitleLabel[this.language.current]}
-            </span>
-            <span class="sbb-file-selector__dropzone-area--button">
-              <sbb-secondary-button-static
-                size=${this.size}
-                ?disabled=${this.disabled || this.formDisabled}
-                ${ref((el) => {
+      <label>
+        <span class="sbb-file-selector__dropzone-area">
+          <span class="sbb-file-selector__dropzone-area--icon">
+            <sbb-icon
+              name=${this.size === "m" ? "folder-open-medium" : "folder-open-small"}
+            ></sbb-icon>
+          </span>
+          <span class="sbb-file-selector__dropzone-area--title">${this.titleContent}</span>
+          <span class="sbb-file-selector__dropzone-area--subtitle">
+            ${this.multiple ? i18nFileSelectorSubtitleLabelMultiple[this.language.current] : i18nFileSelectorSubtitleLabel[this.language.current]}
+          </span>
+          <span class="sbb-file-selector__dropzone-area--button">
+            <sbb-secondary-button-static
+              size=${this.size}
+              ?disabled=${this.disabled || this.formDisabled}
+              ${ref((el) => {
         this.loadButton = el;
       })}
-              >
-                ${i18nFileSelectorButtonLabel[this.language.current]}
-              </sbb-secondary-button-static>
-            </span>
+            >
+              ${this.getButtonLabel()}
+            </sbb-secondary-button-static>
           </span>
-          ${input}
-        </label>
-      </div>
+        </span>
+        ${input}
+      </label>
     `;
     }
   }, _titleContent_accessor_storage = new WeakMap(), _classThis = _a, (() => {
@@ -178,4 +134,4 @@ let SbbFileSelectorDropzoneElement = (() => {
 export {
   SbbFileSelectorDropzoneElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"file-selector-dropzone.component.js","sources":["../../../../../src/elements/file-selector/file-selector-dropzone/file-selector-dropzone.component.ts"],"sourcesContent":["import { type CSSResultGroup, LitElement, type TemplateResult } from 'lit';\nimport { property, customElement } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { html } from 'lit/static-html.js';\n\nimport type { SbbSecondaryButtonStaticElement } from '../../button.js';\nimport { forceType, slotState } from '../../core/decorators.js';\nimport { i18nFileSelectorButtonLabel, i18nFileSelectorSubtitleLabel } from '../../core/i18n.js';\nimport { fileSelectorCommonStyle, SbbFileSelectorCommonElementMixin } from '../common.js';\n\nimport '../../button/secondary-button.js';\nimport '../../button/secondary-button-static.js';\nimport '../../icon.js';\n\nimport style from './file-selector-dropzone.scss?lit&inline';\n\n/**\n * It allows to select one or more file from storage devices via button click or drag and drop, and display them.\n *\n * @slot error - Use this to provide a `sbb-form-error` to show an error message.\n */\nexport\n@customElement('sbb-file-selector-dropzone')\n@slotState()\nclass SbbFileSelectorDropzoneElement extends SbbFileSelectorCommonElementMixin(LitElement) {\n  public static override styles: CSSResultGroup = [fileSelectorCommonStyle, style];\n  public static readonly events = {\n    filechanged: 'filechanged',\n  } as const;\n\n  /** The title displayed in `dropzone` variant. */\n  @forceType()\n  @property({ attribute: 'title-content' })\n  public accessor titleContent: string = '';\n\n  // Safari has a peculiar behavior when dragging files on the inner button in 'dropzone' variant;\n  // this will require a counter to correctly handle the dragEnter/dragLeave.\n  private _counter: number = 0;\n  private _dragTarget?: HTMLElement;\n\n  private _blockEvent(event: DragEvent): void {\n    event.stopPropagation();\n    event.preventDefault();\n  }\n\n  private _onDragEnter(event: DragEvent): void {\n    this._counter++;\n    if (!this.disabled && !this.formDisabled) {\n      this._setDragState(event.target as HTMLElement, true);\n      this._blockEvent(event);\n    }\n  }\n\n  private _onDragLeave(event: DragEvent): void {\n    this._counter--;\n    if (\n      !this.disabled &&\n      !this.formDisabled &&\n      event.target === this._dragTarget &&\n      this._counter === 0\n    ) {\n      this._setDragState();\n      this._blockEvent(event);\n    }\n  }\n\n  private _onFileDrop(event: DragEvent): void {\n    this._counter = 0;\n    if (!this.disabled && !this.formDisabled) {\n      this._setDragState();\n      this._blockEvent(event);\n      this.createFileList(event.dataTransfer!.files);\n    }\n  }\n\n  private _setDragState(\n    dragTarget: HTMLElement | undefined = undefined,\n    isDragEnter: boolean = false,\n  ): void {\n    this._dragTarget = dragTarget;\n    this.toggleAttribute('data-active', isDragEnter);\n    this.loadButton.toggleAttribute('data-active', isDragEnter);\n  }\n\n  protected override renderTemplate(input: TemplateResult): TemplateResult {\n    return html`\n      <div\n        class=\"sbb-file-selector__input-container\"\n        @dragenter=${this._onDragEnter}\n        @dragover=${this._blockEvent}\n        @dragleave=${this._onDragLeave}\n        @drop=${this._onFileDrop}\n      >\n        <label>\n          <span class=\"sbb-file-selector__dropzone-area\">\n            <span class=\"sbb-file-selector__dropzone-area--icon\">\n              <sbb-icon\n                name=${this.size === 'm' ? 'folder-open-medium' : 'folder-open-small'}\n              ></sbb-icon>\n            </span>\n            <span class=\"sbb-file-selector__dropzone-area--title\">${this.titleContent}</span>\n            <span class=\"sbb-file-selector__dropzone-area--subtitle\">\n              ${i18nFileSelectorSubtitleLabel[this.language.current]}\n            </span>\n            <span class=\"sbb-file-selector__dropzone-area--button\">\n              <sbb-secondary-button-static\n                size=${this.size}\n                ?disabled=${this.disabled || this.formDisabled}\n                ${ref((el?: Element): void => {\n                  this.loadButton = el as SbbSecondaryButtonStaticElement;\n                })}\n              >\n                ${i18nFileSelectorButtonLabel[this.language.current]}\n              </sbb-secondary-button-static>\n            </span>\n          </span>\n          ${input}\n        </label>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-file-selector-dropzone': SbbFileSelectorDropzoneElement;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwBM,kCAA8B,MAAA;;AAFnC,MAAA,mBAAA,CAAA,cAAc,4BAA4B,GAC1C,WAAW;;;;oBACiC,kCAAkC,UAAU;;;;AAApD,EAAA,mBAAQ,YAA6C;AAAA;;AASxF;AAAgB,yBAAA,gCAAA,kBAAA,MAAA,4BAAuB,EAAE;AAIjC,WAAA,YAAQ,kBAAA,MAAA,+BAAA,GAAW;AAAA,IAoF7B;AAAA;AAAA,IAxFE,IAAgB,eAAY;AAAA,aAAA,mBAAA;AAAA,IAAA;AAAA,IAA5B,IAAgB,aAAY,OAAA;AAAA,yBAAA,gCAAA;AAAA,IAAA;AAAA,IAOpB,YAAY,OAAgB;AAClC,YAAM,gBAAA;AACN,YAAM,eAAA;AAAA,IACR;AAAA,IAEQ,aAAa,OAAgB;AACnC,WAAK;AACL,UAAI,CAAC,KAAK,YAAY,CAAC,KAAK,cAAc;AACxC,aAAK,cAAc,MAAM,QAAuB,IAAI;AACpD,aAAK,YAAY,KAAK;AAAA,MACxB;AAAA,IACF;AAAA,IAEQ,aAAa,OAAgB;AACnC,WAAK;AACL,UACE,CAAC,KAAK,YACN,CAAC,KAAK,gBACN,MAAM,WAAW,KAAK,eACtB,KAAK,aAAa,GAClB;AACA,aAAK,cAAA;AACL,aAAK,YAAY,KAAK;AAAA,MACxB;AAAA,IACF;AAAA,IAEQ,YAAY,OAAgB;AAClC,WAAK,WAAW;AAChB,UAAI,CAAC,KAAK,YAAY,CAAC,KAAK,cAAc;AACxC,aAAK,cAAA;AACL,aAAK,YAAY,KAAK;AACtB,aAAK,eAAe,MAAM,aAAc,KAAK;AAAA,MAC/C;AAAA,IACF;AAAA,IAEQ,cACN,aAAsC,QACtC,cAAuB,OAAK;AAE5B,WAAK,cAAc;AACnB,WAAK,gBAAgB,eAAe,WAAW;AAC/C,WAAK,WAAW,gBAAgB,eAAe,WAAW;AAAA,IAC5D;AAAA,IAEmB,eAAe,OAAqB;AACrD,aAAO;AAAA;AAAA;AAAA,qBAGU,KAAK,YAAY;AAAA,oBAClB,KAAK,WAAW;AAAA,qBACf,KAAK,YAAY;AAAA,gBACtB,KAAK,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAMT,KAAK,SAAS,MAAM,uBAAuB,mBAAmB;AAAA;AAAA;AAAA,oEAGjB,KAAK,YAAY;AAAA;AAAA,gBAErE,8BAA8B,KAAK,SAAS,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA,uBAI7C,KAAK,IAAI;AAAA,4BACJ,KAAK,YAAY,KAAK,YAAY;AAAA,kBAC5C,IAAI,CAAC,OAAsB;AAC3B,aAAK,aAAa;AAAA,MACpB,CAAC,CAAC;AAAA;AAAA,kBAEA,4BAA4B,KAAK,SAAS,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA,YAIxD,KAAK;AAAA;AAAA;AAAA;AAAA,IAIf;AAAA,KAvFA;;gCAFC,aACA,SAAS,EAAE,WAAW,gBAAA,CAAiB,CAAC;AACzC,iBAAA,IAAA,MAAA,0BAAA,EAAA,MAAA,YAAA,MAAA,gBAAA,QAAA,OAAA,SAAA,OAAA,QAAA,EAAA,KAAA,CAAA,QAAA,kBAAA,KAAA,KAAA,CAAA,QAAA,IAAgB,cAAY,KAAA,CAAA,KAAA,UAAA;AAAA,UAAZ,eAAY;AAAA,IAAA,KAAA,UAAA,UAAA,GAAA,4BAAA,+BAAA;AAT9B,iBAAA,MAAA,mBAAA,EAAA,OAAA,WAAA,GAAA,kBAAA,EAAA,MAAA,SAAA,MAAA,WAAA,MAAA,UAAA,UAAA,GAAA,MAAA,uBAAA;;;QACyB,GAAA,SAAyB,CAAC,yBAAyB,KAAK,GACxD,GAAA,SAAS;AAAA,IAC9B,aAAa;AAAA,EAAA,GAHX,kBAAA,YAAA,uBAAA,GAA+B;;;"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/{file-selector-common-csww18o8.js → file-selector-common-BxXdRZxt.js}

@@ -27,12 +27,12 @@ const fileSelectorCommon = css`*,
   }
 }
 
-:host([data-active]) {
+:host(:is(:state(active), [state--active])) {
   --sbb-file-selector-background-color: var(--sbb-color-milk);
   --sbb-file-selector-border-color: var(--sbb-color-storm);
 }
 @media (forced-colors: active) {
-  :host([data-active]) {
+  :host(:is(:state(active), [state--active])) {
     --sbb-file-selector-border-color: Highlight;
   }
 }
@@ -102,4 +102,4 @@ const fileSelectorCommon = css`*,
 export {
   fileSelectorCommon as f
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zZWxlY3Rvci1jb21tb24tY3N3dzE4bzguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zZWxlY3Rvci1jb21tb24tQnhYZFJaeHQuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/development/file-selector.js

@@ -1,5 +1,5 @@
 import { SbbFileSelectorCommonElementMixin } from "./file-selector/common/file-selector-common.js";
-import { f } from "./file-selector-common-csww18o8.js";
+import { f } from "./file-selector-common-BxXdRZxt.js";
 import { SbbFileSelectorDropzoneElement } from "./file-selector/file-selector-dropzone/file-selector-dropzone.component.js";
 import { SbbFileSelectorElement } from "./file-selector/file-selector/file-selector.component.js";
 export {

package/development/form-field/form-field/form-field.component.d.ts

@@ -1,7 +1,7 @@
 import { CSSResultGroup, LitElement, PropertyValues, TemplateResult } from 'lit';
 /** An interface which allows a control to work inside of a `SbbFormField`. */
 export interface SbbFormFieldElementControl {
-    /** The id of the form field. */
+    /** The id of the form field control. */
     readonly id: string;
     /** Whether the control is empty. */
     readonly empty: boolean;
@@ -9,8 +9,11 @@ export interface SbbFormFieldElementControl {
     readonly readOnly?: boolean;
     /** Whether the control is disabled. */
     readonly disabled: boolean;
-    /** Handles a click on the control's container. */
-    onContainerClick(event: MouseEvent): void;
+    /**
+     * Handles a click on the control's container.
+     * If not implemented, focus() of the element is called.
+     */
+    onContainerClick?(event: MouseEvent): void;
 }
 export declare class SbbFormFieldControlEvent extends Event {
     private _control;

package/development/form-field/form-field/form-field.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form-field.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/form-field/form-field/form-field.component.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"form-field.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/form-field/form-field/form-field.component.ts"],"names":[],"mappings":"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"}