@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/core/mixins.js

@@ -0,0 +1,425 @@
+import { property as l, state as _ } from "lit/decorators.js";
+import { defaultConverter as u, isServer as h, html as o, nothing as c } from "lit";
+import { hostAttributes as g } from "./decorators.js";
+import { preventScrollOnSpacebarPress as p, forwardEventToHost as C } from "./eventing.js";
+import { getLocalName as b } from "./dom.js";
+import "../screen-reader-only.js";
+var S = Object.defineProperty, k = Object.getOwnPropertyDescriptor, E = (a, r, s, t) => {
+  for (var e = k(r, s), i = a.length - 1, n; i >= 0; i--)
+    (n = a[i]) && (e = n(r, s, e) || e);
+  return e && S(r, s, e), e;
+};
+const y = (a) => {
+  class r extends a {
+    constructor() {
+      super(...arguments), this._disabled = !1;
+    }
+    set disabled(t) {
+      this._disabled = !!t;
+    }
+    get disabled() {
+      return this._disabled || this.isDisabledExternally();
+    }
+    /**
+     * Will be used as 'or' check to the current disabled state.
+     * Can e.g. be used to read disabled state of a group.
+     */
+    isDisabledExternally() {
+      return !1;
+    }
+  }
+  return E([
+    l({ reflect: !0, type: Boolean })
+  ], r.prototype, "disabled"), r;
+}, X = (a) => {
+  class r extends y(a) {
+    willUpdate(t) {
+      super.willUpdate(t), t.has("disabled") && (this.disabled ? (this.setAttribute("aria-disabled", "true"), this.removeAttribute("tabindex")) : (this.removeAttribute("aria-disabled"), this.setAttribute("tabindex", "0")));
+    }
+  }
+  return r;
+};
+var x = Object.defineProperty, w = Object.getOwnPropertyDescriptor, d = (a, r, s, t) => {
+  for (var e = t > 1 ? void 0 : t ? w(r, s) : r, i = a.length - 1, n; i >= 0; i--)
+    (n = a[i]) && (e = (t ? n(r, s, e) : n(e)) || e);
+  return t && e && x(r, s, e), e;
+};
+const $ = (a) => {
+  const s = class s extends a {
+    constructor() {
+      super(...arguments), this._value = null, this.internals = this.attachInternals(), this.formDisabled = !1;
+    }
+    /**
+     * Returns the form owner of internals target element.
+     */
+    get form() {
+      return this.internals.form;
+    }
+    set name(e) {
+      this.setAttribute("name", `${e}`);
+    }
+    get name() {
+      return this.getAttribute("name") ?? "";
+    }
+    /** @internal */
+    get type() {
+      return this.localName;
+    }
+    set value(e) {
+      this._value = e, this.updateFormValue();
+    }
+    get value() {
+      return this._value;
+    }
+    /**
+     * Returns the ValidityState object for internals target element.
+     *
+     * @internal
+     */
+    get validity() {
+      return this.internals.validity;
+    }
+    /**
+     * Returns the error message that would be shown to the user
+     * if internals target element was to be checked for validity.
+     *
+     * @internal
+     */
+    get validationMessage() {
+      return this.internals.validationMessage;
+    }
+    /**
+     * Returns true if internals target element will be validated
+     * when the form is submitted; false otherwise.
+     *
+     * @internal
+     */
+    get willValidate() {
+      return this.internals.willValidate;
+    }
+    attributeChangedCallback(e, i, n) {
+      (e !== "name" || i !== n) && super.attributeChangedCallback(e, i, n);
+    }
+    /**
+     * Returns true if internals target element has no validity problems; false otherwise.
+     * Fires an invalid event at the element in the latter case.
+     *
+     * @internal
+     */
+    checkValidity() {
+      return this.internals.checkValidity();
+    }
+    /**
+     * Returns true if internals target element has no validity problems; otherwise,
+     * returns false, fires an invalid event at the element,
+     * and (if the event isn't canceled) reports the problem to the user.
+     *
+     * @internal
+     */
+    reportValidity() {
+      return this.internals.reportValidity();
+    }
+    /**
+     * Is called whenever a surrounding form / fieldset changes disabled state.
+     * @param disabled
+     *
+     * @internal
+     */
+    formDisabledCallback(e) {
+      this.formDisabled = e;
+    }
+    /** Should be called when form value is changed. */
+    updateFormValue() {
+      this.internals.setFormValue(this.value);
+    }
+  };
+  s.formAssociated = !0;
+  let r = s;
+  return d([
+    l()
+  ], r.prototype, "name", 1), d([
+    l()
+  ], r.prototype, "value", 1), d([
+    _()
+  ], r.prototype, "formDisabled", 2), r;
+};
+var R = Object.defineProperty, A = Object.getOwnPropertyDescriptor, P = (a, r, s, t) => {
+  for (var e = A(r, s), i = a.length - 1, n; i >= 0; i--)
+    (n = a[i]) && (e = n(r, s, e) || e);
+  return e && R(r, s, e), e;
+};
+const O = (a) => {
+  class r extends a {
+    constructor() {
+      super(...arguments), this._required = !1;
+    }
+    set required(t) {
+      this._required = !!t;
+    }
+    get required() {
+      return this._required || this.isRequiredExternally();
+    }
+    async willUpdate(t) {
+      super.willUpdate(t), t.has("required") && (this.internals.ariaRequired = `${this.required}`);
+    }
+    /**
+     * Will be used as 'or' check to the current required state.
+     * Can e.g. be used to read required state of a group.
+     */
+    isRequiredExternally() {
+      return !1;
+    }
+  }
+  return P([
+    l({ reflect: !0, type: Boolean })
+  ], r.prototype, "required"), r;
+};
+var q = Object.defineProperty, L = Object.getOwnPropertyDescriptor, f = (a, r, s, t) => {
+  for (var e = t > 1 ? void 0 : t ? L(r, s) : r, i = a.length - 1, n; i >= 0; i--)
+    (n = a[i]) && (e = (t ? n(r, s, e) : n(e)) || e);
+  return t && e && q(r, s, e), e;
+};
+const z = (a) => {
+  let r = class extends y(O($(a))) {
+    constructor() {
+      super(), this._attributeMutationBlocked = !1, this._checked = !1, this._handleKeyboardInteraction = (s) => {
+        s.key === " " && this._handleUserInteraction();
+      }, this._handleUserInteraction = () => {
+        var s;
+        this.disabled || ((s = this.withUserInteraction) == null || s.call(this), this.checked = !this.checked, this._attributeMutationBlocked = !0, this.dispatchEvent(new InputEvent("input", { composed: !0, bubbles: !0 })), this.dispatchEvent(new Event("change", { bubbles: !0 })), this.dispatchEvent(new CustomEvent("didChange", { bubbles: !0 })));
+      }, this.internals.role = "checkbox";
+    }
+    set checked(s) {
+      const t = typeof s == "object" ? s.attribute : !1;
+      t && (s = s.value), this.hasUpdated && !t && (this._attributeMutationBlocked = !0), this._checked = !!s, this.updateFormValue();
+    }
+    get checked() {
+      return this._checked;
+    }
+    connectedCallback() {
+      super.connectedCallback(), this.addEventListener("click", this._handleUserInteraction), this.addEventListener("keydown", p), this.addEventListener("keyup", this._handleKeyboardInteraction);
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback(), this.removeEventListener("click", this._handleUserInteraction), this.removeEventListener("keydown", p), this.removeEventListener("keyup", this._handleKeyboardInteraction);
+    }
+    attributeChangedCallback(s, t, e) {
+      (s !== "checked" || !this._attributeMutationBlocked) && super.attributeChangedCallback(s, t, e);
+    }
+    /**
+     * Is called whenever the form is being reset.
+     *
+     * @internal
+     */
+    formResetCallback() {
+      this.checked = this.hasAttribute("checked"), this._attributeMutationBlocked = !1;
+    }
+    /**
+     *  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”.
+     *  In the case of “restore”, state is a string, File, or FormData object
+     *  previously set as the second argument to setFormValue.
+     *
+     * @internal
+     */
+    formStateRestoreCallback(s, t) {
+      s && (this.checked = s === "true");
+    }
+    updateFormValue() {
+      this.checked ? this.internals.setFormValue(this.value, `${this.checked}`) : this.internals.setFormValue(null);
+    }
+  };
+  return f([
+    l({
+      type: Boolean,
+      converter: {
+        ...u,
+        // We need to pass information to the setter so that we know it was called by attribute change.
+        fromAttribute: (s, t) => {
+          var i, n;
+          return { value: (n = (i = u).fromAttribute) == null ? void 0 : n.call(i, s, t), attribute: !0 };
+        }
+      }
+    })
+  ], r.prototype, "checked", 1), r = f([
+    g({
+      tabindex: "0"
+    })
+  ], r), r;
+}, U = "litElementHydrateSupport", D = h || globalThis.testGroup === "ssr-non-hydrated", M = (a) => {
+  class r extends a {
+    constructor() {
+      super(...arguments), this._hydrationRequired = !1, this._hydrationComplete = new Promise(
+        (t) => this._resolveHydration = t
+      ), this._handleBeforeHydrationSlotchange = (t) => {
+        if (!this._hydrationRequired)
+          return;
+        t.stopImmediatePropagation();
+        const e = t.target;
+        this.hydrationComplete.then(() => C(t, e));
+      };
+    }
+    /**
+     * 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;
+    }
+    createRenderRoot() {
+      var t, e;
+      if (this._hydrationRequired = !!this.shadowRoot && U in globalThis && (h || !D), !this._hydrationRequired)
+        this._resolveHydration(!1);
+      else {
+        const i = (t = this.shadowRoot) == null ? void 0 : t.querySelectorAll("slot");
+        i != null && i.length && (i.forEach(
+          (n) => n.addEventListener("slotchange", this._handleBeforeHydrationSlotchange, {
+            capture: !0
+          })
+        ), this.hydrationComplete.then(
+          () => i.forEach(
+            (n) => n.removeEventListener("slotchange", this._handleBeforeHydrationSlotchange)
+          )
+        )), (e = this.recoverSsrState) == null || e.call(this);
+      }
+      return super.createRenderRoot();
+    }
+    willUpdate(t) {
+      var e;
+      super.willUpdate(t), h && ((e = this.recoverSsrState) == null || e.call(this));
+    }
+    update(t) {
+      super.update(t), this._hydrationRequired && (this._hydrationRequired = !1, this._resolveHydration(!0));
+    }
+    /** Reads and removes an attribute with the given name. Either returns the attributte value or null. */
+    getAndRemoveAttribute(t) {
+      const e = this.getAttribute(t);
+      return this.removeAttribute(t), e;
+    }
+  }
+  return r;
+};
+var B = Object.defineProperty, H = (a, r, s, t) => {
+  for (var e = void 0, i = a.length - 1, n; i >= 0; i--)
+    (n = a[i]) && (e = n(r, s, e) || e);
+  return e && B(r, s, e), e;
+};
+const m = "data-ssr-child-count", v = "li", J = (a) => {
+  class r extends M(a) {
+    constructor() {
+      super(...arguments), this.listChildren = [], this._handleSlotchange = () => {
+        const t = Array.from(this.children ?? []).filter(
+          (e) => this.listChildLocalNames.includes(e.localName)
+        );
+        t.length === this.listChildren.length && this.listChildren.every((e, i) => t[i] === e) || (this.listChildren.filter((e) => !t.includes(e)).forEach((e) => e.removeAttribute("slot")), this.listChildren = t, this.listChildren.forEach(
+          (e, i) => e.setAttribute("slot", `${v}-${i}`)
+        ), this.removeAttribute(m));
+      };
+    }
+    connectedCallback() {
+      var t;
+      super.connectedCallback(), (t = this.shadowRoot) == null || t.addEventListener("slotchange", this._handleSlotchange, { passive: !0 });
+    }
+    disconnectedCallback() {
+      var t;
+      super.disconnectedCallback(), (t = this.shadowRoot) == null || t.removeEventListener("slotchange", this._handleSlotchange);
+    }
+    /**
+     * Renders list and list slots for slotted children or an amount 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 amount of
+     * children to be passed via the `data-ssr-child-count` attribute value.
+     */
+    renderList(t = {}) {
+      const e = this.listSlotNames();
+      return e.length >= 2 ? o`
+          <ul
+            class=${t.class || (this.localName ?? b(this))}
+            aria-label=${t.ariaLabel || c}
+            aria-labelledby=${t.ariaLabelledby || c}
+          >
+            ${e.map((i) => o`<li><slot name=${i}></slot></li>`)}
+          </ul>
+          ${this.renderHiddenSlot()}
+        ` : e.length === 1 ? o`<sbb-screen-reader-only>${t.ariaLabel}</sbb-screen-reader-only>
+          <span class=${t.class || (this.localName ?? b(this))}>
+            <span><slot name=${e[0]}></slot></span>
+          </span>
+          ${this.renderHiddenSlot()} ` : this.renderHiddenSlot();
+    }
+    /**
+     * Returns an array of list slot names with the length corresponding to the amount 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 amount of
+     * children to be passed via the `data-ssr-child-count` attribute value.
+     */
+    listSlotNames() {
+      return (this.listChildren.length ? this.listChildren : Array.from({ length: +(this.getAttribute(m) ?? 0) })).map((e, i) => `${v}-${i}`);
+    }
+    /**
+     * 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 o`<span hidden><slot></slot></span>`;
+    }
+  }
+  return H([
+    _()
+  ], r.prototype, "listChildren"), r;
+};
+var I = Object.defineProperty, N = (a, r, s, t) => {
+  for (var e = void 0, i = a.length - 1, n; i >= 0; i--)
+    (n = a[i]) && (e = n(r, s, e) || e);
+  return e && I(r, s, e), e;
+};
+const Q = (a) => {
+  class r extends a {
+    constructor() {
+      super(...arguments), this.negative = !1;
+    }
+  }
+  return N([
+    l({ reflect: !0, type: Boolean })
+  ], r.prototype, "negative"), r;
+}, W = (a) => {
+  class r extends a {
+    constructor() {
+      super(...arguments), this._updatePromise = Promise.resolve(), this._updateResolve = () => {
+      };
+    }
+    startUpdate() {
+      this._updatePromise = new Promise((t) => this._updateResolve = t);
+    }
+    completeUpdate() {
+      this._updateResolve();
+    }
+    async getUpdateComplete() {
+      const t = await super.getUpdateComplete();
+      return await this._updatePromise, t;
+    }
+  }
+  return r;
+};
+export {
+  y as SbbDisabledMixin,
+  X as SbbDisabledTabIndexActionMixin,
+  z as SbbFormAssociatedCheckboxMixin,
+  $ as SbbFormAssociatedMixin,
+  M as SbbHydrationMixin,
+  J as SbbNamedSlotListMixin,
+  Q as SbbNegativeMixin,
+  O as SbbRequiredMixin,
+  W as SbbUpdateSchedulerMixin
+};

package/core/observers/intersection-observer.d.ts

@@ -0,0 +1,14 @@
+export declare class NodeIntersectionObserver implements IntersectionObserver {
+    root: Element | Document | null;
+    rootMargin: string;
+    thresholds: number[];
+    disconnect(): void;
+    observe(): void;
+    takeRecords(): any;
+    unobserve(): void;
+}
+export declare const AgnosticIntersectionObserver: typeof NodeIntersectionObserver | {
+    new (callback: IntersectionObserverCallback, options?: IntersectionObserverInit | undefined): IntersectionObserver;
+    prototype: IntersectionObserver;
+};
+//# sourceMappingURL=intersection-observer.d.ts.map

package/core/observers/intersection-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection-observer.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/observers/intersection-observer.ts"],"names":[],"mappings":"AAAA,qBAAa,wBAAyB,YAAW,oBAAoB;IAC5D,IAAI,EAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC;IACjC,UAAU,EAAG,MAAM,CAAC;IACpB,UAAU,EAAG,MAAM,EAAE,CAAC;IAEtB,UAAU,IAAI,IAAI;IAIlB,OAAO,IAAI,IAAI;IAIf,WAAW,IAAI,GAAG;IAIlB,SAAS,IAAI,IAAI;CAGzB;AAGD,eAAO,MAAM,4BAA4B;;;CACsD,CAAC"}

package/core/observers/mutation-observer.d.ts

@@ -0,0 +1,7 @@
+export declare class NodeMutationObserver implements MutationObserver {
+    disconnect(): void;
+    observe(_target: Node, _options?: MutationObserverInit): void;
+    takeRecords(): MutationRecord[];
+}
+export declare const AgnosticMutationObserver: typeof MutationObserver;
+//# sourceMappingURL=mutation-observer.d.ts.map

package/core/observers/mutation-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-observer.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/observers/mutation-observer.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,YAAW,gBAAgB;IACpD,UAAU,IAAI,IAAI;IAIlB,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI;IAI7D,WAAW,IAAI,cAAc,EAAE;CAGvC;AAGD,eAAO,MAAM,wBAAwB,EAAE,OAAO,gBACqC,CAAC"}

package/core/observers/resize-observer.d.ts

@@ -0,0 +1,10 @@
+export declare class NodeResizeObserver implements ResizeObserver {
+    disconnect(): any;
+    observe(): any;
+    unobserve(): any;
+}
+export declare const AgnosticResizeObserver: {
+    new (callback: ResizeObserverCallback): ResizeObserver;
+    prototype: ResizeObserver;
+};
+//# sourceMappingURL=resize-observer.d.ts.map

package/core/observers/resize-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-observer.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/observers/resize-observer.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,YAAW,cAAc;IAChD,UAAU,IAAI,GAAG;IAIjB,OAAO,IAAI,GAAG;IAId,SAAS,IAAI,GAAG;CAGxB;AAGD,eAAO,MAAM,sBAAsB;;;CAC0C,CAAC"}

package/core/observers.d.ts

@@ -0,0 +1,4 @@
+export * from './observers/intersection-observer.js';
+export * from './observers/mutation-observer.js';
+export * from './observers/resize-observer.js';
+//# sourceMappingURL=observers.d.ts.map

package/core/observers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observers.d.ts","sourceRoot":"","sources":["../../../src/elements/core/observers.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC"}

package/core/observers.js

@@ -0,0 +1,38 @@
+class s {
+  disconnect() {
+  }
+  observe() {
+  }
+  takeRecords() {
+  }
+  unobserve() {
+  }
+}
+const i = typeof IntersectionObserver > "u" ? s : IntersectionObserver;
+class r {
+  disconnect() {
+  }
+  observe(n, o) {
+  }
+  takeRecords() {
+    return [];
+  }
+}
+const c = typeof MutationObserver > "u" ? r : MutationObserver;
+class t {
+  disconnect() {
+  }
+  observe() {
+  }
+  unobserve() {
+  }
+}
+const b = typeof ResizeObserver > "u" ? t : ResizeObserver;
+export {
+  i as AgnosticIntersectionObserver,
+  c as AgnosticMutationObserver,
+  b as AgnosticResizeObserver,
+  s as NodeIntersectionObserver,
+  r as NodeMutationObserver,
+  t as NodeResizeObserver
+};

package/core/overlay/overlay-option-panel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Places the overlay in the correct position.
+ * @param dialog The reference to the dialog element.
+ * @param originElement The reference to the element the dialog is attached to.
+ * @param optionContainer The reference to the option panel.
+ * @param container The element which has the position:fixed applied.
+ * @param element The reference to the component.
+ */
+export declare function setOverlayPosition(dialog: HTMLElement, originElement: HTMLElement, optionContainer: HTMLElement, container: HTMLElement, element: HTMLElement): void;
+//# sourceMappingURL=overlay-option-panel.d.ts.map

package/core/overlay/overlay-option-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-option-panel.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/overlay/overlay-option-panel.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,WAAW,EAC1B,eAAe,EAAE,WAAW,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,WAAW,GACnB,IAAI,CAmBN"}

package/core/overlay/overlay-trigger-attributes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Add meaningful aria attributes to trigger elements that are connected to
+ * overlay elements such as menus and dialogs.
+ */
+export declare function setAriaOverlayTriggerAttributes(trigger: HTMLElement, popupType: 'menu' | 'dialog', overlayId: string, state: string): void;
+/**
+ * Remove aria attributes from trigger elements.
+ */
+export declare function removeAriaOverlayTriggerAttributes(trigger: HTMLElement | null | undefined): void;
+/**
+ * Add meaningful aria attributes to trigger element of role='combobox'
+ */
+export declare function setAriaComboBoxAttributes(trigger: HTMLElement, overlayId: string, expanded: boolean): void;
+/**
+ * Remove aria attributes from trigger elements.
+ */
+export declare function removeAriaComboBoxAttributes(trigger?: HTMLElement): void;
+//# sourceMappingURL=overlay-trigger-attributes.d.ts.map

package/core/overlay/overlay-trigger-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-trigger-attributes.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/overlay/overlay-trigger-attributes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,MAAM,GAAG,QAAQ,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,IAAI,CAQN;AAED;;GAEG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAQhG;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,GAChB,IAAI,CAYN;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAYxE"}

package/core/overlay/overlay.d.ts

@@ -0,0 +1,21 @@
+import { TemplateResult } from 'lit';
+
+/**
+ * Used to create the "wrapping" effect around the anchor for overlays (es. autocomplete)
+ * Works in conjunction with the 'overlayGapFixCorners()' function in 'overlay.ts'
+ */
+export declare function overlayGapFixCorners(): TemplateResult;
+/**
+ * Applies inert to every other element on the page except the overlay.
+ */
+export declare function applyInertMechanism(overlay: HTMLElement): void;
+export declare function removeInertMechanism(): void;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        willOpen: CustomEvent<void>;
+        willClose: CustomEvent<void>;
+        didOpen: CustomEvent<void>;
+        didClose: CustomEvent<void>;
+    }
+}
+//# sourceMappingURL=overlay.d.ts.map

package/core/overlay/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/overlay/overlay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAK1C;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CASrD;AAqDD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAyB9D;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAqB3C;AACD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,2BAA2B;QACnC,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QAC5B,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QAC7B,OAAO,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QAC3B,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;KAC7B;CACF"}

package/core/overlay/position.d.ts

@@ -0,0 +1,41 @@
+export type ElementRectangle = Pick<HTMLElement, 'scrollHeight' | 'clientHeight' | 'offsetHeight' | 'scrollWidth' | 'clientWidth' | 'offsetWidth'>;
+export interface SbbAlignment {
+    horizontal: 'start' | 'center' | 'end';
+    vertical: 'above' | 'below';
+}
+export interface SbbElementPositionInfos {
+    top: number;
+    left: number;
+    maxHeight: string;
+    alignment: SbbAlignment;
+}
+/**
+ * Gets height and width of an element even if it's hidden (`display: none`).
+ */
+export declare function getElementRectangle(el: HTMLElement): ElementRectangle;
+/**
+ * Determines whether an event is fired on a specific element.
+ */
+export declare function isEventOnElement(element: HTMLElement, event: MouseEvent | PointerEvent): boolean;
+/**
+ * Determines the position of an element relative to a trigger element by evaluating
+ * the optimal position based on the available space.
+ *
+ * @param element The element of which to calculate the position.
+ * @param trigger The element relative to which to calculate the position.
+ * @param container The element which has the position:fixed applied.
+ * @param properties Properties to take into account in calculations (optional).
+ * @param properties.verticalOffset The distance to be added between the element and the trigger (optional).
+ * @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).
+ * @param properties.centered Whether the element should be placed in the center by default (optional).
+ * @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).
+ * @returns Returns an object containing the left position, the top position, the maximum height
+ * of the element and the current alignment object.
+ */
+export declare function getElementPosition(element: HTMLElement, trigger: HTMLElement, container: HTMLElement, properties?: {
+    verticalOffset?: number;
+    horizontalOffset?: number;
+    centered?: boolean;
+    responsiveHeight?: boolean;
+}): SbbElementPositionInfos;
+//# sourceMappingURL=position.d.ts.map

package/core/overlay/position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/overlay/position.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,WAAW,EACX,cAAc,GAAG,cAAc,GAAG,cAAc,GAAG,aAAa,GAAG,aAAa,GAAG,aAAa,CACjG,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,YAAY,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,gBAAgB,CAoCrE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,YAAY,GAAG,OAAO,CAYhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,WAAW,EACtB,UAAU,CAAC,EAAE;IACX,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GACA,uBAAuB,CAqGzB"}

package/core/overlay.d.ts

@@ -0,0 +1,5 @@
+export * from './overlay/overlay.js';
+export * from './overlay/overlay-option-panel.js';
+export * from './overlay/overlay-trigger-attributes.js';
+export * from './overlay/position.js';
+//# sourceMappingURL=overlay.d.ts.map

package/core/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../src/elements/core/overlay.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,uBAAuB,CAAC"}