@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

package/development/core/mixins/form-associated-radio-button-mixin.js

@@ -0,0 +1,252 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { isServer } from "lit";
+import { property } from "lit/decorators.js";
+import { interactivityChecker, isArrowKeyPressed, getNextElementIndex } from "../a11y.js";
+import { SbbLanguageController } from "../controllers.js";
+import { i18nSelectionRequired } from "../i18n.js";
+import { SbbDisabledMixin } from "./disabled-mixin.js";
+import { SbbElementInternalsMixin } from "./element-internals-mixin.js";
+import { SbbFormAssociatedMixin } from "./form-associated-mixin.js";
+import { SbbRequiredMixin } from "./required-mixin.js";
+const radioButtonRegistry = /* @__PURE__ */ new WeakMap();
+const SbbFormAssociatedRadioButtonMixin = (superClass) => {
+  let SbbFormAssociatedRadioButtonElement = (() => {
+    var _a;
+    let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(superClass))));
+    let _instanceExtraInitializers = [];
+    let _set_checked_decorators;
+    let _set_name_decorators;
+    return _a = class extends _classSuper {
+      /**
+       * Whether the radio button is checked.
+       */
+      set checked(value) {
+        this._checked = !!value;
+        this.toggleState("checked", this.checked);
+        this.internals.ariaChecked = this.checked.toString();
+        this.updateFormValue();
+        this._synchronizeGroupState();
+      }
+      get checked() {
+        return this._checked;
+      }
+      set name(value) {
+        super.name = value;
+        this._disconnectFromRegistry();
+        this._connectToRegistry();
+        this._synchronizeGroupState();
+      }
+      get name() {
+        return super.name;
+      }
+      /**
+       * Form type of element.
+       * @default 'radio'
+       */
+      get type() {
+        return "radio";
+      }
+      constructor() {
+        super();
+        this._checked = (__runInitializers(this, _instanceExtraInitializers), false);
+        this._languageController = new SbbLanguageController(this);
+        this.addEventListener?.("keydown", (e) => this._handleArrowKeyDown(e));
+      }
+      connectedCallback() {
+        super.connectedCallback();
+        this._connectToRegistry();
+        this._synchronizeGroupState();
+      }
+      disconnectedCallback() {
+        super.disconnectedCallback();
+        this._disconnectFromRegistry();
+      }
+      /**
+       * Is called whenever the form is being reset.
+       * @internal
+       */
+      formResetCallback() {
+        this.checked = this.hasAttribute("checked");
+      }
+      /**
+       *  Called when the browser is trying to restore element’s state to state in which case
+       *  reason is "restore", or when the browser is trying to fulfill autofill on behalf of
+       *  user in which case reason is "autocomplete".
+       * @internal
+       */
+      formStateRestoreCallback(state, _reason) {
+        if (typeof state === "string" || state == null) {
+          this.checked = state === this.value;
+        } else if (state instanceof FormData) {
+          this._readFormData(state).then((data) => {
+            this.checked = data === this.value;
+          });
+        }
+      }
+      async _readFormData(formData) {
+        const data = formData.get(this.name);
+        return data instanceof Blob ? JSON.parse(await data.text()) : data;
+      }
+      willUpdate(changedProperties) {
+        super.willUpdate(changedProperties);
+        if (changedProperties.has("disabled")) {
+          this.updateFocusableRadios();
+        }
+      }
+      firstUpdated(changedProperties) {
+        super.firstUpdated(changedProperties);
+        this.updateFocusableRadios();
+      }
+      /**
+       * Called on `value` change
+       * If 'checked', update the value. Otherwise, do nothing.
+       */
+      updateFormValue() {
+        if (this.checked) {
+          super.updateFormValue();
+        } else {
+          this.internals.setFormValue(null);
+        }
+      }
+      shouldValidate(name) {
+        return super.shouldValidate(name) || name === "checked" || name === "required";
+      }
+      /**
+       * Sets the validity of all associated radio buttons.
+       * If any radio button is required, all associated are required as well.
+       */
+      validate() {
+        super.validate();
+        if (!this.associatedRadioButtons) {
+          return;
+        }
+        let required = false;
+        let checked = false;
+        for (const radio of this.associatedRadioButtons) {
+          required ||= radio.required;
+          checked ||= radio.checked;
+        }
+        if (required && !checked) {
+          this.associatedRadioButtons.forEach((r) => r.setValidityFlag("valueMissing", i18nSelectionRequired[this._languageController.current]));
+        } else {
+          this.associatedRadioButtons.forEach((r) => r.removeValidityFlag("valueMissing"));
+        }
+      }
+      /**
+       * Only a single radio should be focusable in the group. Defined as:
+       * - the checked radio;
+       * - the first non-disabled radio in DOM order;
+       */
+      updateFocusableRadios() {
+        if (!this.hasUpdated) {
+          return;
+        }
+        const radios = this._interactableGroupedRadios();
+        const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);
+        const focusableIndex = checkedIndex !== -1 ? checkedIndex : radios.findIndex((r) => !r.disabled && !r.formDisabled);
+        if (focusableIndex !== -1) {
+          radios[focusableIndex].tabIndex = 0;
+          radios.splice(focusableIndex, 1);
+        }
+        radios.forEach((r) => r.removeAttribute("tabindex"));
+      }
+      async navigateByKeyboard(next) {
+        next.checked = true;
+        this.emitChangeEvents();
+        await next.updateComplete;
+        next.focus();
+      }
+      emitChangeEvents() {
+        this.dispatchEvent(new InputEvent("input", { bubbles: true, cancelable: true, composed: true }));
+        this.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      _synchronizeGroupState() {
+        if (this.checked) {
+          this._deselectGroupedRadios();
+        }
+        this.updateFocusableRadios();
+      }
+      /**
+       * Add `this` to the radioButton registry
+       */
+      _connectToRegistry() {
+        if (!this.name || isServer) {
+          return;
+        }
+        const root = this.form ?? this.getRootNode();
+        this._radioButtonGroupsMap = radioButtonRegistry.get(root);
+        if (!this._radioButtonGroupsMap) {
+          this._radioButtonGroupsMap = /* @__PURE__ */ new Map();
+          radioButtonRegistry.set(root, this._radioButtonGroupsMap);
+        }
+        this.associatedRadioButtons = this._radioButtonGroupsMap.get(this.name);
+        if (!this.associatedRadioButtons) {
+          this.associatedRadioButtons = /* @__PURE__ */ new Set();
+          this._radioButtonGroupsMap.set(this.name, this.associatedRadioButtons);
+        }
+        const entries = Array.from(this.associatedRadioButtons);
+        this.associatedRadioButtons.clear();
+        const index = entries.findIndex((r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING);
+        if (index !== -1) {
+          entries.splice(index, 0, this);
+        } else {
+          entries.push(this);
+        }
+        entries.forEach((r) => this.associatedRadioButtons.add(r));
+        this.validate();
+      }
+      /**
+       * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map
+       */
+      _disconnectFromRegistry() {
+        this.associatedRadioButtons?.delete(this);
+        if (this.associatedRadioButtons?.size === 0) {
+          this._radioButtonGroupsMap?.delete(this.name);
+        } else {
+          this.validate();
+        }
+        this.associatedRadioButtons = void 0;
+        this._radioButtonGroupsMap = void 0;
+      }
+      /**
+       * Return a list of 'interactable' grouped radios, ordered in DOM order
+       */
+      _interactableGroupedRadios() {
+        return Array.from(this.associatedRadioButtons ?? []).filter((el) => interactivityChecker.isVisible(el));
+      }
+      /**
+       * Deselect other radio of the same group
+       */
+      _deselectGroupedRadios() {
+        Array.from(this.associatedRadioButtons ?? []).filter((r) => r !== this).forEach((r) => r.checked = false);
+      }
+      async _handleArrowKeyDown(evt) {
+        if (!isArrowKeyPressed(evt)) {
+          return;
+        }
+        evt.preventDefault();
+        const enabledRadios = this._interactableGroupedRadios().filter((r) => !r.disabled && !r.formDisabled);
+        const current = enabledRadios.indexOf(this);
+        const nextIndex = getNextElementIndex(evt, current, enabledRadios.length);
+        await this.navigateByKeyboard(enabledRadios[nextIndex]);
+      }
+    }, (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _set_checked_decorators = [property({ type: Boolean })];
+      _set_name_decorators = [property()];
+      __esDecorate(_a, null, _set_checked_decorators, { kind: "setter", name: "checked", static: false, private: false, access: { has: (obj) => "checked" in obj, set: (obj, value) => {
+        obj.checked = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(_a, null, _set_name_decorators, { kind: "setter", name: "name", static: false, private: false, access: { has: (obj) => "name" in obj, set: (obj, value) => {
+        obj.name = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a.role = "radio", _a;
+  })();
+  return SbbFormAssociatedRadioButtonElement;
+};
+export {
+  SbbFormAssociatedRadioButtonMixin,
+  radioButtonRegistry
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-radio-button-mixin.js","sources":["../../../../../src/elements/core/mixins/form-associated-radio-button-mixin.ts"],"sourcesContent":["import { isServer, type LitElement, type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from '../a11y.ts';\nimport { SbbLanguageController } from '../controllers.ts';\nimport { i18nSelectionRequired } from '../i18n.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbDisabledMixin } from './disabled-mixin.ts';\nimport { SbbElementInternalsMixin } from './element-internals-mixin.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from './form-associated-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\n/**\n * A static registry that holds a collection of grouped `radio-buttons`.\n * Groups of radio buttons are local to the form they belong (or the `renderRoot` if they're not part of any form)\n * Multiple groups of radio with the same name can coexist (as long as they belong to a different form / renderRoot)\n * It is mainly used to support the standalone groups of radios.\n * @internal\n */\nexport const radioButtonRegistry = new WeakMap<\n  Node,\n  Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>\n>();\n\nexport declare abstract class SbbFormAssociatedRadioButtonMixinType extends SbbDisabledMixin(\n  SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement))),\n) {\n  public accessor checked: boolean;\n\n  protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonMixinType>;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected updateFormValue(): void;\n  protected updateFocusableRadios(): void;\n  protected emitChangeEvents(): void;\n  protected navigateByKeyboard(radio: SbbFormAssociatedRadioButtonMixinType): Promise<void>;\n}\n\n/**\n * The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedRadioButtonMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> & T => {\n  abstract class SbbFormAssociatedRadioButtonElement\n    extends SbbDisabledMixin(\n      SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(superClass))),\n    )\n    implements Partial<SbbFormAssociatedRadioButtonMixinType>\n  {\n    public static override readonly role = 'radio';\n\n    /**\n     * Whether the radio button is checked.\n     */\n    @property({ type: Boolean })\n    public set checked(value: boolean) {\n      this._checked = !!value;\n\n      this.toggleState('checked', this.checked);\n      this.internals.ariaChecked = this.checked.toString();\n      this.updateFormValue();\n      this._synchronizeGroupState();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    @property()\n    public override set name(value: string) {\n      super.name = value;\n\n      this._disconnectFromRegistry();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n    public override get name(): string {\n      return super.name;\n    }\n\n    /**\n     * Form type of element.\n     * @default 'radio'\n     */\n    public override get type(): string {\n      return 'radio';\n    }\n\n    /**\n     * Set of radio buttons that belongs to the same group of `this`.\n     * Assume them ordered in DOM order\n     */\n    protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonElement>;\n    private _radioButtonGroupsMap?: Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>;\n    private _languageController = new SbbLanguageController(this);\n\n    protected constructor() {\n      super();\n      this.addEventListener?.('keydown', (e) => this._handleArrowKeyDown(e));\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this._disconnectFromRegistry();\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\n    }\n\n    /**\n     *  Called when the browser is trying to restore element’s state to state in which case\n     *  reason is \"restore\", or when the browser is trying to fulfill autofill on behalf of\n     *  user in which case reason is \"autocomplete\".\n     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (typeof state === 'string' || state == null) {\n        this.checked = state === this.value;\n      } else if (state instanceof FormData) {\n        this._readFormData(state).then((data) => {\n          this.checked = data === this.value;\n        });\n      }\n    }\n\n    private async _readFormData(formData: FormData): Promise<unknown> {\n      const data = formData.get(this.name);\n      return data instanceof Blob ? JSON.parse(await data.text()) : data;\n    }\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabled')) {\n        this.updateFocusableRadios();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Called on `value` change\n     * If 'checked', update the value. Otherwise, do nothing.\n     */\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        super.updateFormValue();\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    /**\n     * Sets the validity of all associated radio buttons.\n     * If any radio button is required, all associated are required as well.\n     */\n    protected override validate(): void {\n      super.validate();\n      if (!this.associatedRadioButtons) {\n        return;\n      }\n\n      let required = false;\n      let checked = false;\n      for (const radio of this.associatedRadioButtons) {\n        required ||= radio.required;\n        checked ||= radio.checked;\n      }\n\n      if (required && !checked) {\n        this.associatedRadioButtons.forEach((r) =>\n          r.setValidityFlag(\n            'valueMissing',\n            i18nSelectionRequired[this._languageController.current],\n          ),\n        );\n      } else {\n        this.associatedRadioButtons.forEach((r) => r.removeValidityFlag('valueMissing'));\n      }\n    }\n\n    /**\n     * Only a single radio should be focusable in the group. Defined as:\n     * - the checked radio;\n     * - the first non-disabled radio in DOM order;\n     */\n    protected updateFocusableRadios(): void {\n      if (!this.hasUpdated) {\n        return;\n      }\n      const radios = this._interactableGroupedRadios();\n      const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);\n      const focusableIndex =\n        checkedIndex !== -1\n          ? checkedIndex\n          : radios.findIndex((r) => !r.disabled && !r.formDisabled); // Get the first focusable radio\n\n      if (focusableIndex !== -1) {\n        radios[focusableIndex].tabIndex = 0;\n        radios.splice(focusableIndex, 1);\n      }\n\n      // Reset tabIndex on other radios\n      radios.forEach((r) => r.removeAttribute('tabindex'));\n    }\n\n    protected async navigateByKeyboard(next: SbbFormAssociatedRadioButtonElement): Promise<void> {\n      next.checked = true;\n      this.emitChangeEvents();\n\n      await next.updateComplete;\n      next.focus();\n    }\n\n    protected emitChangeEvents(): void {\n      // Manually dispatch events to simulate a user interaction\n      this.dispatchEvent(\n        new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n      );\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    }\n\n    private _synchronizeGroupState(): void {\n      if (this.checked) {\n        this._deselectGroupedRadios();\n      }\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Add `this` to the radioButton registry\n     */\n    private _connectToRegistry(): void {\n      if (!this.name || isServer) {\n        return;\n      }\n      const root = this.form ?? this.getRootNode();\n      this._radioButtonGroupsMap = radioButtonRegistry.get(root);\n\n      // Initialize the 'root' map entry\n      if (!this._radioButtonGroupsMap) {\n        this._radioButtonGroupsMap = new Map();\n        radioButtonRegistry.set(root, this._radioButtonGroupsMap);\n      }\n\n      this.associatedRadioButtons = this._radioButtonGroupsMap.get(\n        this.name,\n      ) as unknown as Set<SbbFormAssociatedRadioButtonElement>;\n\n      // Initialize the group set\n      if (!this.associatedRadioButtons) {\n        this.associatedRadioButtons = new Set();\n        this._radioButtonGroupsMap.set(\n          this.name,\n          this.associatedRadioButtons as unknown as Set<SbbFormAssociatedRadioButtonMixinType>,\n        );\n      }\n\n      // Insert the new radio into the set and sort following the DOM order.\n      // Since the order of a 'Set' is the insert order, we have to empty it and re-insert radios in order\n      const entries = Array.from(this.associatedRadioButtons);\n      this.associatedRadioButtons.clear();\n\n      // Find `this` position and insert it\n      const index = entries.findIndex(\n        (r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING,\n      );\n      if (index !== -1) {\n        entries.splice(index, 0, this);\n      } else {\n        entries.push(this);\n      }\n\n      // Repopulate the Set\n      entries.forEach((r) => this.associatedRadioButtons!.add(r));\n\n      this.validate();\n    }\n\n    /**\n     * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map\n     */\n    private _disconnectFromRegistry(): void {\n      this.associatedRadioButtons?.delete(this);\n\n      if (this.associatedRadioButtons?.size === 0) {\n        this._radioButtonGroupsMap?.delete(this.name);\n      } else {\n        this.validate();\n      }\n\n      this.associatedRadioButtons = undefined;\n      this._radioButtonGroupsMap = undefined;\n    }\n\n    /**\n     * Return a list of 'interactable' grouped radios, ordered in DOM order\n     */\n    private _interactableGroupedRadios(): SbbFormAssociatedRadioButtonElement[] {\n      return Array.from(this.associatedRadioButtons ?? []).filter((el) =>\n        interactivityChecker.isVisible(el),\n      );\n    }\n\n    /**\n     * Deselect other radio of the same group\n     */\n    private _deselectGroupedRadios(): void {\n      Array.from(this.associatedRadioButtons ?? [])\n        .filter((r) => r !== this)\n        .forEach((r) => (r.checked = false));\n    }\n\n    private async _handleArrowKeyDown(evt: KeyboardEvent): Promise<void> {\n      if (!isArrowKeyPressed(evt)) {\n        return;\n      }\n      evt.preventDefault();\n\n      const enabledRadios = this._interactableGroupedRadios().filter(\n        (r) => !r.disabled && !r.formDisabled,\n      );\n      const current: number = enabledRadios.indexOf(this);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledRadios.length);\n\n      await this.navigateByKeyboard(enabledRadios[nextIndex]);\n    }\n  }\n\n  return SbbFormAssociatedRadioButtonElement as unknown as AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}

package/development/core/mixins/hydration-mixin.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+import { AbstractConstructor } from './constructor.ts';
+export declare abstract class SbbHydrationMixinType {
+    /**
+     * Returns a Promise that resolves when the element has completed hydration.
+     * The Promise value is a boolean that is `true` if the element required hydration
+     * and `false` if not.
+     *
+     * @return A promise of a boolean that resolves to true once the hydration completed.
+     */
+    get hydrationComplete(): Promise<boolean>;
+    /** Returns whether hydration is required and not completed. */
+    protected get hydrationRequired(): boolean;
+}
+/**
+ * This mixin extends a base class with functionality to check if hydration is completed.
+ * It also delays slotchange events until hydration is complete.
+ *
+ * @param base The class to extend.
+ * @returns A class extended with the hydration check functionality.
+ */
+export declare const SbbHydrationMixin: <T extends AbstractConstructor<LitElement>>(base: T) => AbstractConstructor<SbbHydrationMixinType> & T;
+//# sourceMappingURL=hydration-mixin.d.ts.map

package/development/core/mixins/hydration-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration-mixin.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/mixins/hydration-mixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,KAAK,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5D,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,qBAAqB;IACjD;;;;;;OAMG;IACH,IAAW,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjD,+DAA+D;IAC/D,SAAS,KAAK,iBAAiB,IAAI,OAAO,CAAC;CAC5C;AAED;;;;;;GAMG;AAEH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,EACzE,MAAM,CAAC,KACN,mBAAmB,CAAC,qBAAqB,CAAC,GAAG,CAwE/C,CAAC"}

package/development/core/mixins/hydration-mixin.js

@@ -0,0 +1,56 @@
+const SbbHydrationMixin = (base) => {
+  class SbbHydrationMixinClass extends base {
+    /**
+     * Returns a Promise that resolves when the element has completed hydration.
+     * The Promise value is a boolean that is `true` if the element required hydration
+     * and `false` if not.
+     *
+     * @return A promise of a boolean that resolves to true once the hydration completed.
+     * @internal
+     */
+    get hydrationComplete() {
+      return this._hydrationComplete;
+    }
+    /** Returns whether hydration is required and not completed. */
+    get hydrationRequired() {
+      return this._hydrationRequired;
+    }
+    constructor(...args) {
+      super(...args);
+      this._hydrationComplete = new Promise((resolve) => this._resolveHydration = resolve);
+      this._hydrationRequired = !!this.shadowRoot;
+      if (!this._hydrationRequired) {
+        this._resolveHydration(false);
+      } else {
+        const suppressSlotchangeEvent = (event) => {
+          if (this._hydrationRequired) {
+            event.stopImmediatePropagation();
+          }
+        };
+        const eventOptions = { capture: true };
+        const slots = this.shadowRoot?.querySelectorAll("slot");
+        if (slots?.length) {
+          slots.forEach((slot) => slot.addEventListener("slotchange", suppressSlotchangeEvent, eventOptions));
+          this.hydrationComplete.then(() => slots.forEach((slot) => {
+            slot.removeEventListener("slotchange", suppressSlotchangeEvent, eventOptions);
+            if (slot.assignedNodes().length) {
+              slot.dispatchEvent(new Event("slotchange", { bubbles: true }));
+            }
+          }));
+        }
+      }
+    }
+    update(changedProperties) {
+      super.update(changedProperties);
+      if (this._hydrationRequired) {
+        this._hydrationRequired = false;
+        this._resolveHydration(true);
+      }
+    }
+  }
+  return SbbHydrationMixinClass;
+};
+export {
+  SbbHydrationMixin
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/mixins/named-slot-list-mixin.d.ts

@@ -0,0 +1,36 @@
+import { LitElement, TemplateResult } from 'lit';
+import { AbstractConstructor } from './constructor.ts';
+import { SbbHydrationMixinType } from './hydration-mixin.ts';
+export type SbbNamedSlotProperties = {
+    name: string;
+    ariaHidden: boolean;
+};
+/**
+ * Helper type for willUpdate or similar checks.
+ * Allows the usage of the string literal 'listChildren'.
+ *
+ * @example
+ * protected override willUpdate(changedProperties: PropertyValues<WithListChildren<this>>): void {
+ *   if (changedProperties.has('listChildren')) {
+ *     ...
+ *   }
+ * }
+ */
+export type WithListChildren<T extends SbbNamedSlotListMixinType<C>, C extends HTMLElement = HTMLElement> = T & {
+    listChildren: C[];
+};
+export declare abstract class SbbNamedSlotListMixinType<C extends HTMLElement> extends SbbHydrationMixinType {
+    protected abstract readonly listChildLocalNames: string[];
+    protected accessor listChildren: C[];
+    protected renderList(attributes?: {
+        class?: string;
+        ariaLabel?: string;
+        ariaLabelledby?: string;
+    }, listItemAttributes?: {
+        localNameVisualOnly?: string[];
+    }): TemplateResult;
+    protected listSlotEntries(): SbbNamedSlotProperties[];
+    protected renderHiddenSlot(): TemplateResult;
+}
+export declare const SbbNamedSlotListMixin: <C extends HTMLElement, T extends AbstractConstructor<LitElement>>(superClass: T) => AbstractConstructor<SbbNamedSlotListMixinType<C>> & T;
+//# sourceMappingURL=named-slot-list-mixin.d.ts.map

package/development/core/mixins/named-slot-list-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-slot-list-mixin.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/mixins/named-slot-list-mixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAW,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAG1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAqB,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAErF,OAAO,6BAA6B,CAAC;AAKrC,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,yBAAyB,CAAC,CAAC,CAAC,EACtC,CAAC,SAAS,WAAW,GAAG,WAAW,IACjC,CAAC,GAAG;IAAE,YAAY,EAAE,CAAC,EAAE,CAAA;CAAE,CAAC;AAE9B,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,yBAAyB,CACrD,CAAC,SAAS,WAAW,CACrB,SAAQ,qBAAqB;IAC7B,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC1D,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,EAAE,CAAC;IACrC,SAAS,CAAC,UAAU,CAClB,UAAU,CAAC,EAAE;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,EACD,kBAAkB,CAAC,EAAE;QACnB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;KAChC,GACA,cAAc;IACjB,SAAS,CAAC,eAAe,IAAI,sBAAsB,EAAE;IACrD,SAAS,CAAC,gBAAgB,IAAI,cAAc;CAC7C;AAGD,eAAO,MAAM,qBAAqB,GAChC,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,EAEzC,YAAY,CAAC,KACZ,mBAAmB,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,CAsItD,CAAC"}

package/development/core/mixins/named-slot-list-mixin.js

@@ -0,0 +1,133 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __runInitializers, __esDecorate } from "tslib";
+import { nothing, html } from "lit";
+import { state } from "lit/decorators.js";
+import { SbbHydrationMixin } from "./hydration-mixin.js";
+import "../../screen-reader-only.js";
+const SSR_CHILD_COUNT_ATTRIBUTE = "data-ssr-child-count";
+const SLOTNAME_PREFIX = "li";
+const SbbNamedSlotListMixin = (superClass) => {
+  let NamedSlotListElement = (() => {
+    var _listChildren_accessor_storage, _a;
+    let _classSuper = SbbHydrationMixin(superClass);
+    let _listChildren_decorators;
+    let _listChildren_initializers = [];
+    let _listChildren_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _listChildren_accessor_storage);
+        __privateSet(this, _listChildren_accessor_storage, __runInitializers(this, _listChildren_initializers, []));
+        this._handleSlotchange = (__runInitializers(this, _listChildren_extraInitializers), () => {
+          const listChildren = Array.from(this.children ?? []).filter((e) => this.listChildLocalNames.includes(e.localName));
+          if (listChildren.length === this.listChildren.length && this.listChildren.every((e, i) => listChildren[i] === e)) {
+            return;
+          }
+          this.listChildren.filter((c) => !listChildren.includes(c)).forEach((c) => c.removeAttribute("slot"));
+          this.listChildren = listChildren;
+          this.listChildren.forEach((c, index) => c.setAttribute("slot", `${SLOTNAME_PREFIX}-${index}`));
+          this.removeAttribute(SSR_CHILD_COUNT_ATTRIBUTE);
+        });
+      }
+      /**
+       * A list of children with the defined tag names.
+       * This array is only updated if there is an actual change
+       * to the child elements.
+       */
+      get listChildren() {
+        return __privateGet(this, _listChildren_accessor_storage);
+      }
+      set listChildren(value) {
+        __privateSet(this, _listChildren_accessor_storage, value);
+      }
+      connectedCallback() {
+        super.connectedCallback();
+        this.shadowRoot?.addEventListener("slotchange", this._handleSlotchange, { passive: true });
+      }
+      disconnectedCallback() {
+        super.disconnectedCallback();
+        this.shadowRoot?.removeEventListener("slotchange", this._handleSlotchange);
+      }
+      /**
+       * Renders list and list slots for slotted children or a number of list slots
+       * corresponding to the `data-ssr-child-count` attribute value.
+       *
+       * This is a possible optimization for SSR, as in an SSR Lit environment
+       * other elements are not available, but might be available in the meta
+       * framework wrapper (like e.g. React). This allows to provide the number of
+       * children to be passed via the `data-ssr-child-count` attribute value.
+       */
+      renderList(attributes = {}, listItemAttributes = {}) {
+        const listSlotNames = this.listSlotEntries(listItemAttributes);
+        if (listSlotNames.length >= 2) {
+          return html`
+          <ul
+            class=${attributes.class || this.localName}
+            aria-label=${attributes.ariaLabel || nothing}
+            aria-labelledby=${attributes.ariaLabelledby || nothing}
+          >
+            ${listSlotNames.map((slot) => html`
+                <li aria-hidden=${slot.ariaHidden || nothing}>
+                  <slot name=${slot.name}></slot>
+                </li>
+              `)}
+          </ul>
+          ${this.renderHiddenSlot()}
+        `;
+        } else if (listSlotNames.length === 1) {
+          return html`<sbb-screen-reader-only>${attributes.ariaLabel}</sbb-screen-reader-only>
+          <span class=${attributes.class || this.localName}>
+            <span><slot name=${listSlotNames[0].name}></slot></span>
+          </span>
+          ${this.renderHiddenSlot()} `;
+        } else {
+          return this.renderHiddenSlot();
+        }
+      }
+      /**
+       * Returns an array of SbbNamedSlotProperties, which holds the list slot names and the hidden property;
+       * its length corresponds to the number of matched children or the `data-ssr-child-count` attribute value.
+       *
+       * This is a possible optimization for SSR, as in an SSR Lit environment
+       * other elements are not available, but might be available in the meta
+       * framework wrapper (like e.g. React). This allows to provide the number of
+       * children to be passed via the `data-ssr-child-count` attribute value.
+       */
+      listSlotEntries(listItemAttributes) {
+        const listChildren = this.listChildren.length ? this.listChildren : Array.from({ length: +(this.getAttribute(SSR_CHILD_COUNT_ATTRIBUTE) ?? 0) });
+        return listChildren.map((e, i) => {
+          return {
+            name: `${SLOTNAME_PREFIX}-${i}`,
+            ariaHidden: listItemAttributes?.localNameVisualOnly?.includes(e.localName) ?? false
+          };
+        });
+      }
+      /**
+       * Returns a hidden slot, which is intended as the children change detection.
+       * When an element without a slot attribute is slotted to the element, it triggers
+       * the slotchange event, which can be used to assign it to the appropriate named slot.
+       */
+      renderHiddenSlot() {
+        return html`<span hidden><slot></slot></span>`;
+      }
+    }, _listChildren_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _listChildren_decorators = [state()];
+      __esDecorate(_a, null, _listChildren_decorators, { kind: "accessor", name: "listChildren", static: false, private: false, access: { has: (obj) => "listChildren" in obj, get: (obj) => obj.listChildren, set: (obj, value) => {
+        obj.listChildren = value;
+      } }, metadata: _metadata }, _listChildren_initializers, _listChildren_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a;
+  })();
+  return NamedSlotListElement;
+};
+export {
+  SbbNamedSlotListMixin
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"named-slot-list-mixin.js","sources":["../../../../../src/elements/core/mixins/named-slot-list-mixin.ts"],"sourcesContent":["import { html, type LitElement, nothing, type TemplateResult } from 'lit';\nimport { state } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbHydrationMixin, type SbbHydrationMixinType } from './hydration-mixin.ts';\n\nimport '../../screen-reader-only.ts';\n\nconst SSR_CHILD_COUNT_ATTRIBUTE = 'data-ssr-child-count';\nconst SLOTNAME_PREFIX = 'li';\n\nexport type SbbNamedSlotProperties = {\n  name: string;\n  ariaHidden: boolean;\n};\n\n/**\n * Helper type for willUpdate or similar checks.\n * Allows the usage of the string literal 'listChildren'.\n *\n * @example\n * protected override willUpdate(changedProperties: PropertyValues<WithListChildren<this>>): void {\n *   if (changedProperties.has('listChildren')) {\n *     ...\n *   }\n * }\n */\nexport type WithListChildren<\n  T extends SbbNamedSlotListMixinType<C>,\n  C extends HTMLElement = HTMLElement,\n> = T & { listChildren: C[] };\n\nexport declare abstract class SbbNamedSlotListMixinType<\n  C extends HTMLElement,\n> extends SbbHydrationMixinType {\n  protected abstract readonly listChildLocalNames: string[];\n  protected accessor listChildren: C[];\n  protected renderList(\n    attributes?: {\n      class?: string;\n      ariaLabel?: string;\n      ariaLabelledby?: string;\n    },\n    listItemAttributes?: {\n      localNameVisualOnly?: string[];\n    },\n  ): TemplateResult;\n  protected listSlotEntries(): SbbNamedSlotProperties[];\n  protected renderHiddenSlot(): TemplateResult;\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbNamedSlotListMixin = <\n  C extends HTMLElement,\n  T extends AbstractConstructor<LitElement>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbNamedSlotListMixinType<C>> & T => {\n  /**\n   * This base class provides named slot list observer functionality.\n   * This allows using the pattern of rendering a named slot for each child, which allows\n   * wrapping children in an ul/li list.\n   */\n  abstract class NamedSlotListElement<C extends HTMLElement = HTMLElement>\n    extends SbbHydrationMixin(superClass)\n    implements Partial<SbbNamedSlotListMixinType<C>>\n  {\n    /** A list of lower-cased tag names to match against. (e.g. `sbb-link`) */\n    protected abstract readonly listChildLocalNames: string[];\n\n    /**\n     * A list of children with the defined tag names.\n     * This array is only updated if there is an actual change\n     * to the child elements.\n     */\n    @state() protected accessor listChildren: C[] = [];\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this.shadowRoot?.addEventListener('slotchange', this._handleSlotchange, { passive: true });\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this.shadowRoot?.removeEventListener('slotchange', this._handleSlotchange);\n    }\n\n    private _handleSlotchange = (): void => {\n      const listChildren = Array.from(this.children ?? []).filter((e): e is C =>\n        this.listChildLocalNames.includes(e.localName),\n      );\n      // If the slotted child instances have not changed, we can skip syncing and updating\n      // the link reference list.\n      if (\n        listChildren.length === this.listChildren.length &&\n        this.listChildren.every((e, i) => listChildren[i] === e)\n      ) {\n        return;\n      }\n\n      this.listChildren\n        .filter((c) => !listChildren.includes(c))\n        .forEach((c) => c.removeAttribute('slot'));\n      this.listChildren = listChildren;\n      this.listChildren.forEach((c, index) =>\n        c.setAttribute('slot', `${SLOTNAME_PREFIX}-${index}`),\n      );\n\n      // Remove the ssr attribute, once we have actually initialized the children elements.\n      this.removeAttribute(SSR_CHILD_COUNT_ATTRIBUTE);\n    };\n\n    /**\n     * Renders list and list slots for slotted children or a number of list slots\n     * corresponding to the `data-ssr-child-count` attribute value.\n     *\n     * This is a possible optimization for SSR, as in an SSR Lit environment\n     * other elements are not available, but might be available in the meta\n     * framework wrapper (like e.g. React). This allows to provide the number of\n     * children to be passed via the `data-ssr-child-count` attribute value.\n     */\n    protected renderList(\n      attributes: { class?: string; ariaLabel?: string; ariaLabelledby?: string } = {},\n      listItemAttributes: { localNameVisualOnly?: string[] } = {},\n    ): TemplateResult {\n      const listSlotNames: SbbNamedSlotProperties[] = this.listSlotEntries(listItemAttributes);\n\n      if (listSlotNames.length >= 2) {\n        return html`\n          <ul\n            class=${attributes.class || this.localName}\n            aria-label=${attributes.ariaLabel || nothing}\n            aria-labelledby=${attributes.ariaLabelledby || nothing}\n          >\n            ${listSlotNames.map(\n              (slot) => html`\n                <li aria-hidden=${slot.ariaHidden || nothing}>\n                  <slot name=${slot.name}></slot>\n                </li>\n              `,\n            )}\n          </ul>\n          ${this.renderHiddenSlot()}\n        `;\n      } else if (listSlotNames.length === 1) {\n        return html`<sbb-screen-reader-only>${attributes.ariaLabel}</sbb-screen-reader-only>\n          <span class=${attributes.class || this.localName}>\n            <span><slot name=${listSlotNames[0].name}></slot></span>\n          </span>\n          ${this.renderHiddenSlot()} `;\n      } else {\n        return this.renderHiddenSlot();\n      }\n    }\n\n    /**\n     * Returns an array of SbbNamedSlotProperties, which holds the list slot names and the hidden property;\n     * its length corresponds to the number of matched children or the `data-ssr-child-count` attribute value.\n     *\n     * This is a possible optimization for SSR, as in an SSR Lit environment\n     * other elements are not available, but might be available in the meta\n     * framework wrapper (like e.g. React). This allows to provide the number of\n     * children to be passed via the `data-ssr-child-count` attribute value.\n     */\n    protected listSlotEntries(listItemAttributes: {\n      localNameVisualOnly?: string[];\n    }): SbbNamedSlotProperties[] {\n      const listChildren = this.listChildren.length\n        ? this.listChildren\n        : Array.from({ length: +(this.getAttribute(SSR_CHILD_COUNT_ATTRIBUTE) ?? 0) });\n      return listChildren.map((e, i) => {\n        return {\n          name: `${SLOTNAME_PREFIX}-${i}`,\n          ariaHidden:\n            listItemAttributes?.localNameVisualOnly?.includes((e as HTMLElement).localName) ??\n            false,\n        };\n      });\n    }\n\n    /**\n     * Returns a hidden slot, which is intended as the children change detection.\n     * When an element without a slot attribute is slotted to the element, it triggers\n     * the slotchange event, which can be used to assign it to the appropriate named slot.\n     */\n    protected renderHiddenSlot(): TemplateResult {\n      return html`<span hidden><slot></slot></span>`;\n    }\n  }\n\n  return NamedSlotListElement as unknown as AbstractConstructor<SbbNamedSlotListMixinType<C>> & T;\n};\n"],"names":[],"mappings":";;;;;;;;;;;;AAQA,MAAM,4BAA4B;AAClC,MAAM,kBAAkB;AA2CjB,MAAM,wBAAwB,CAInC,eACyD;MAM1C,wBAAoB,MAAA;;sBACzB,kBAAkB,UAAU;;;;AADvB,WAAA,mBACL,YAA6B;AAAA;;AAW5B;AAAmB,2BAAA,gCAAA,kBAAA,MAAA,4BAAoB,CAAA,CAAE;AAY1C,aAAA,qBAAiB,kBAAA,MAAA,+BAAA,GAAG,MAAW;AACrC,gBAAM,eAAe,MAAM,KAAK,KAAK,YAAY,CAAA,CAAE,EAAE,OAAO,CAAC,MAC3D,KAAK,oBAAoB,SAAS,EAAE,SAAS,CAAC;AAIhD,cACE,aAAa,WAAW,KAAK,aAAa,UAC1C,KAAK,aAAa,MAAM,CAAC,GAAG,MAAM,aAAa,CAAC,MAAM,CAAC,GACvD;AACA;AAAA,UACF;AAEA,eAAK,aACF,OAAO,CAAC,MAAM,CAAC,aAAa,SAAS,CAAC,CAAC,EACvC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,MAAM,CAAC;AAC3C,eAAK,eAAe;AACpB,eAAK,aAAa,QAAQ,CAAC,GAAG,UAC5B,EAAE,aAAa,QAAQ,GAAG,eAAe,IAAI,KAAK,EAAE,CAAC;AAIvD,eAAK,gBAAgB,yBAAyB;AAAA,QAChD;AAAA,MA8EF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAjHW,IAAmB,eAAY;AAAA,eAAA,mBAAA;AAAA,MAAA;AAAA,MAA/B,IAAmB,aAAY,OAAA;AAAA,2BAAA,gCAAA;AAAA,MAAA;AAAA,MAExB,oBAAiB;AAC/B,cAAM,kBAAA;AACN,aAAK,YAAY,iBAAiB,cAAc,KAAK,mBAAmB,EAAE,SAAS,MAAM;AAAA,MAC3F;AAAA,MAEgB,uBAAoB;AAClC,cAAM,qBAAA;AACN,aAAK,YAAY,oBAAoB,cAAc,KAAK,iBAAiB;AAAA,MAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAoCU,WACR,aAA8E,IAC9E,qBAAyD,CAAA,GAAE;AAE3D,cAAM,gBAA0C,KAAK,gBAAgB,kBAAkB;AAEvF,YAAI,cAAc,UAAU,GAAG;AAC7B,iBAAO;AAAA;AAAA,oBAEK,WAAW,SAAS,KAAK,SAAS;AAAA,yBAC7B,WAAW,aAAa,OAAO;AAAA,8BAC1B,WAAW,kBAAkB,OAAO;AAAA;AAAA,cAEpD,cAAc,IACd,CAAC,SAAS;AAAA,kCACU,KAAK,cAAc,OAAO;AAAA,+BAC7B,KAAK,IAAI;AAAA;AAAA,eAEzB,CACF;AAAA;AAAA,YAED,KAAK,kBAAkB;AAAA;AAAA,QAE7B,WAAW,cAAc,WAAW,GAAG;AACrC,iBAAO,+BAA+B,WAAW,SAAS;AAAA,wBAC1C,WAAW,SAAS,KAAK,SAAS;AAAA,+BAC3B,cAAc,CAAC,EAAE,IAAI;AAAA;AAAA,YAExC,KAAK,kBAAkB;AAAA,QAC7B,OAAO;AACL,iBAAO,KAAK,iBAAA;AAAA,QACd;AAAA,MACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAWU,gBAAgB,oBAEzB;AACC,cAAM,eAAe,KAAK,aAAa,SACnC,KAAK,eACL,MAAM,KAAK,EAAE,QAAQ,EAAE,KAAK,aAAa,yBAAyB,KAAK,IAAI;AAC/E,eAAO,aAAa,IAAI,CAAC,GAAG,MAAK;AAC/B,iBAAO;AAAA,YACL,MAAM,GAAG,eAAe,IAAI,CAAC;AAAA,YAC7B,YACE,oBAAoB,qBAAqB,SAAU,EAAkB,SAAS,KAC9E;AAAA,UAAA;AAAA,QAEN,CAAC;AAAA,MACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAOU,mBAAgB;AACxB,eAAO;AAAA,MACT;AAAA,IAAA,GAhHS;;AAAR,iCAAA,CAAA,OAAO;AAAC,mBAAA,IAAA,MAAA,0BAAA,EAAA,MAAA,YAAA,MAAA,gBAAA,QAAA,OAAA,SAAA,OAAA,QAAA,EAAA,KAAA,CAAA,QAAA,kBAAA,KAAA,KAAA,CAAA,QAAA,IAAmB,cAAY,KAAA,CAAA,KAAA,UAAA;AAAA,YAAZ,eAAY;AAAA,MAAA,KAAA,UAAA,UAAA,GAAA,4BAAA,+BAAA;;UAZ3B;AAAA;AA+Hf,SAAO;AACT;"}

package/development/core/mixins/negative-mixin.d.ts

@@ -0,0 +1,10 @@
+import { LitElement } from 'lit';
+import { AbstractConstructor } from './constructor.ts';
+export declare class SbbNegativeMixinType {
+    accessor negative: boolean;
+}
+/**
+ * Enhance your component with a negative property.
+ */
+export declare const SbbNegativeMixin: <T extends AbstractConstructor<LitElement>>(superClass: T) => AbstractConstructor<SbbNegativeMixinType> & T;
+//# sourceMappingURL=negative-mixin.d.ts.map

package/development/core/mixins/negative-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative-mixin.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/mixins/negative-mixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAKtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,SAAgB,QAAQ,EAAE,OAAO,CAAC;CACnC;AAED;;GAEG;AAEH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,EACxE,YAAY,CAAC,KACZ,mBAAmB,CAAC,oBAAoB,CAAC,GAAG,CAS9C,CAAC"}