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

package/development/container/sticky-bar/sticky-bar.component.js

@@ -0,0 +1,363 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+import { css, LitElement, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { isLean, isZeroAnimationDuration } from "../../core/dom.js";
+import { SbbUpdateSchedulerMixin, SbbElementInternalsMixin } from "../../core/mixins.js";
+import { boxSizingStyles } from "../../core/styles.js";
+const style = css`:host {
+  --sbb-sticky-bar-fade-in-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-5x)
+  );
+  --sbb-sticky-bar-fade-out-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-sticky-bar-slide-vertically-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-4x)
+  );
+  --_sbb-sticky-bar-background-animation-duration: var(
+    --sbb-sticky-bar-fade-out-animation-duration
+  );
+  display: contents;
+}
+
+:host([size=s]) {
+  --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xxxs);
+}
+
+:host([size=m]) {
+  --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xs);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))) {
+  --sbb-sticky-bar-sticky-background-color: var(
+    --sbb-container-background-color,
+    var(--sbb-background-color-1)
+  );
+  --_sbb-sticky-bar-intersector-background-color: var(--sbb-sticky-bar-sticky-background-color);
+  --_sbb-sticky-bar-background-animation-duration: var(--sbb-sticky-bar-fade-in-animation-duration);
+}
+@media (forced-colors: active) {
+  :host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))) {
+    --_sbb-sticky-bar-forced-colors-border: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=white]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-1);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=milk]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-3);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=midnight]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-1-negative);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=charcoal]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-2-negative);
+}
+
+:host(:is(:is(:state(sticking),[state--sticking]):is(:is(:state(slide-vertically),[state--slide-vertically]), :is(:state(state-sticking),[state--state-sticking]), :is(:state(state-unsticking),[state--state-unsticking])),
+:is(:state(state-unsticky),[state--state-unsticky]))) {
+  --_sbb-sticky-bar-background-animation-duration: 0s;
+}
+
+:host(:is(:state(sticking),[state--sticking]):is(:is(:state(slide-vertically),[state--slide-vertically]):not(:is(:state(state-unsticky),[state--state-unsticky]), :is(:state(state-unsticking),[state--state-unsticking])),
+:is(:state(state-sticking),[state--state-sticking]))) {
+  --sbb-sticky-bar-slide-vertically-animation-name: slide-in;
+}
+
+:host(:is(:state(sticking),[state--sticking]):is(:state(state-unsticking),[state--state-unsticking])) {
+  --sbb-sticky-bar-slide-vertically-animation-name: slide-out;
+}
+
+:host(:is(:not(:is(:state(initialized),[state--initialized])), :is(:state(state-unsticky),[state--state-unsticky]))) {
+  --sbb-sticky-bar-position: relative;
+}
+
+.sbb-sticky-bar__wrapper {
+  position: var(--sbb-sticky-bar-position);
+  inset-block-end: 0;
+  display: block;
+  z-index: var(--sbb-sticky-bar-z-index);
+  animation-name: var(--sbb-sticky-bar-slide-vertically-animation-name, unset);
+  animation-duration: var(--sbb-sticky-bar-slide-vertically-animation-duration);
+  animation-timing-function: var(--sbb-sticky-bar-slide-vertically-animation-easing);
+  animation-delay: 0s;
+  animation-fill-mode: backwards;
+}
+.sbb-sticky-bar__wrapper::after, .sbb-sticky-bar__wrapper::before {
+  content: "";
+  inset: 0;
+  position: absolute;
+  display: block;
+  z-index: -1;
+}
+.sbb-sticky-bar__wrapper::before {
+  background-color: var(--sbb-container-background-color);
+  padding: 0 !important;
+}
+:host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar__wrapper::before {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
+  margin-inline: auto;
+  width: 100%;
+}
+@media (min-width: calc(90rem)) {
+  :host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar__wrapper::before {
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
+  }
+}
+.sbb-sticky-bar__wrapper::after {
+  background-color: var(--sbb-sticky-bar-sticky-background-color, transparent);
+  border-start-start-radius: var(--sbb-sticky-bar-border-radius);
+  border-start-end-radius: var(--sbb-sticky-bar-border-radius);
+  transition: background-color var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  border: var(--_sbb-sticky-bar-forced-colors-border, none);
+}
+
+.sbb-sticky-bar {
+  display: flex;
+  padding-block: var(--sbb-sticky-bar-padding-block);
+  margin-block-end: -1px;
+}
+.sbb-sticky-bar::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  border-start-start-radius: var(--sbb-sticky-bar-border-radius);
+  border-start-end-radius: var(--sbb-sticky-bar-border-radius);
+  transition: box-shadow var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  clip-path: polygon(-100% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)), 150% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)), 150% 100%, -100% 100%);
+}
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))) .sbb-sticky-bar::before {
+  box-shadow: var(--sbb-box-shadow-level-11-soft);
+}
+:host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
+  margin-inline: auto;
+  width: 100%;
+}
+@media (min-width: calc(90rem)) {
+  :host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar {
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
+  }
+}
+:host(:is(:state(expanded),[state--expanded])) .sbb-sticky-bar {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));
+}
+
+.sbb-sticky-bar__intersector {
+  height: 1px;
+}
+.sbb-sticky-bar__intersector::after {
+  content: "";
+  display: block;
+  position: absolute;
+  width: 100%;
+  height: calc(var(--sbb-sticky-bar-bottom-overlapping-height, 0) + 1px);
+  background-color: var(--_sbb-sticky-bar-intersector-background-color, transparent);
+  pointer-events: none;
+  transition: background-color var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+}
+
+@keyframes slide-in {
+  from {
+    transform: translateY(100%);
+  }
+  to {
+    transform: translateY(0%);
+  }
+}
+@keyframes slide-out {
+  from {
+    transform: translateY(0%);
+  }
+  to {
+    transform: translateY(100%);
+  }
+}`;
+let SbbStickyBarElement = (() => {
+  var _color_accessor_storage, _size_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-sticky-bar")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbUpdateSchedulerMixin(SbbElementInternalsMixin(LitElement));
+  let _color_decorators;
+  let _color_initializers = [];
+  let _color_extraInitializers = [];
+  let _size_decorators;
+  let _size_initializers = [];
+  let _size_extraInitializers = [];
+  _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _color_accessor_storage);
+      __privateAdd(this, _size_accessor_storage);
+      __privateSet(this, _color_accessor_storage, __runInitializers(this, _color_initializers, null));
+      __privateSet(this, _size_accessor_storage, (__runInitializers(this, _color_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m")));
+      this._stateInternal = __runInitializers(this, _size_extraInitializers);
+      this._observer = new IntersectionController(this, {
+        // Although `this` is observed, we have to postpone observing
+        // into firstUpdated() to achieve a correct initial state.
+        target: null,
+        callback: (entries) => this._detectStickyState(entries[0])
+      });
+      this._state = "sticky";
+    }
+    /** Color of the container, like transparent, white etc. */
+    get color() {
+      return __privateGet(this, _color_accessor_storage);
+    }
+    set color(value) {
+      __privateSet(this, _color_accessor_storage, value);
+    }
+    /**
+     * Size of the container.
+     * @default 'm' / 's' (lean)
+     */
+    get size() {
+      return __privateGet(this, _size_accessor_storage);
+    }
+    set size(value) {
+      __privateSet(this, _size_accessor_storage, value);
+    }
+    /** The state of the component. */
+    set _state(state) {
+      if (this._stateInternal) {
+        this.internals.states.delete(`state-${this._stateInternal}`);
+      }
+      this._stateInternal = state;
+      if (this._stateInternal) {
+        this.internals.states.add(`state-${this._stateInternal}`);
+      }
+    }
+    get _state() {
+      return this._stateInternal;
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this.slot ||= "sticky-bar";
+      this.startUpdate();
+      const container = this.closest("sbb-container");
+      if (container) {
+        this.toggleState("expanded", container.expanded);
+      }
+      if (this._intersector) {
+        this._observer.observe(this._intersector);
+      }
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this.internals.states.delete("initialized");
+    }
+    firstUpdated(changedProperties) {
+      super.firstUpdated(changedProperties);
+      if (!this._intersector) {
+        this._intersector = this.shadowRoot.querySelector(".sbb-sticky-bar__intersector");
+        this._observer.observe(this._intersector);
+      }
+      this._observer.observe(this);
+    }
+    _isZeroAnimationDuration() {
+      return isZeroAnimationDuration(this, "--sbb-sticky-bar-slide-vertically-animation-duration");
+    }
+    _detectStickyState(entry) {
+      this.internals.states.add("initialized");
+      const isSticky = !entry.isIntersecting && entry.boundingClientRect.top > 0;
+      const intersectorRect = this._intersector?.getBoundingClientRect();
+      const stickyBarRect = this.shadowRoot.querySelector(".sbb-sticky-bar__wrapper").getBoundingClientRect();
+      const HEIGHT_TOLERANCE = 30;
+      this.toggleState("slide-vertically", isSticky && this._intersector && Math.abs(intersectorRect.bottom - stickyBarRect.bottom) > HEIGHT_TOLERANCE);
+      this.toggleState("sticking", isSticky);
+      this.completeUpdate();
+    }
+    /** Animates from normal content flow position to `position: sticky`. */
+    stick() {
+      if (this._state !== "unsticky" || !this._dispatchBeforeStickEvent()) {
+        return;
+      }
+      this._state = "sticking";
+      if (!this.internals.states.has("sticking") || this._isZeroAnimationDuration()) {
+        this._stickyCallback();
+      }
+    }
+    /** Animates `position: sticky` to normal content flow position. */
+    unstick() {
+      if (this._state !== "sticky" || !this._dispatchBeforeUnStickEvent()) {
+        return;
+      }
+      this._state = "unsticking";
+      if (!this.internals.states.has("sticking") || this._isZeroAnimationDuration()) {
+        this._unstickyCallback();
+      }
+    }
+    _stickyCallback() {
+      this._state = "sticky";
+      this.dispatchEvent(new Event("stick"));
+    }
+    _unstickyCallback() {
+      this.dispatchEvent(new Event("unstick"));
+      this._state = "unsticky";
+    }
+    _onAnimationEnd(event) {
+      if ((this._state === "sticking" || this._state === "sticky") && event.animationName === "slide-in") {
+        this._stickyCallback();
+      } else if (this._state === "unsticking" && event.animationName === "slide-out") {
+        this._unstickyCallback();
+      }
+    }
+    _dispatchBeforeStickEvent() {
+      return this.dispatchEvent(new Event("beforestick", { cancelable: true }));
+    }
+    _dispatchBeforeUnStickEvent() {
+      return this.dispatchEvent(new Event("beforeunstick", { cancelable: true }));
+    }
+    render() {
+      return html`
+      <div class="sbb-sticky-bar__wrapper" @animationend=${this._onAnimationEnd}>
+        <div class="sbb-sticky-bar">
+          <slot></slot>
+        </div>
+      </div>
+      <div class="sbb-sticky-bar__intersector"></div>
+    `;
+    }
+  }, _color_accessor_storage = new WeakMap(), _size_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _color_decorators = [property({ reflect: true })];
+    _size_decorators = [property({ reflect: true })];
+    __esDecorate(_a, null, _color_decorators, { kind: "accessor", name: "color", static: false, private: false, access: { has: (obj) => "color" in obj, get: (obj) => obj.color, set: (obj, value) => {
+      obj.color = value;
+    } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+    __esDecorate(_a, null, _size_decorators, { kind: "accessor", name: "size", static: false, private: false, access: { has: (obj) => "size" in obj, get: (obj) => obj.size, set: (obj, value) => {
+      obj.size = value;
+    } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = [boxSizingStyles, style], _a.events = {
+    beforestick: "beforestick",
+    stick: "stick",
+    beforeunstick: "beforeunstick",
+    unstick: "unstick"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbStickyBarElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sticky-bar.component.js","sources":["../../../../../src/elements/container/sticky-bar/sticky-bar.component.ts"],"sourcesContent":["import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport { isLean, isZeroAnimationDuration } from '../../core/dom.ts';\nimport { SbbElementInternalsMixin, SbbUpdateSchedulerMixin } from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\n\nimport style from './sticky-bar.scss?lit&inline';\n\ntype StickyState = 'sticking' | 'sticky' | 'unsticking' | 'unsticky';\n\n/**\n * A container that sticks to the bottom of the page if slotted into `sbb-container`.\n *\n * @slot - Use the unnamed slot to add content to the sticky bar.\n * @cssprop [--sbb-sticky-bar-padding-block=var(--sbb-spacing-responsive-xs)] - Block padding of the sticky bar.\n * @cssprop [--sbb-sticky-bar-bottom-overlapping-height=0px] - Define an additional area where\n * the sticky bar overlaps the following content on the bottom.\n * This area becomes visible when the sticky bar transitions from sticky to the normal document flow.\n * @cssprop [--sbb-sticky-bar-z-index] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable.\n */\nexport\n@customElement('sbb-sticky-bar')\nclass SbbStickyBarElement extends SbbUpdateSchedulerMixin(SbbElementInternalsMixin(LitElement)) {\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  public static readonly events = {\n    beforestick: 'beforestick',\n    stick: 'stick',\n    beforeunstick: 'beforeunstick',\n    unstick: 'unstick',\n  } as const;\n\n  /** Color of the container, like transparent, white etc. */\n  @property({ reflect: true }) public accessor color:\n    | 'white'\n    | 'milk'\n    | 'midnight'\n    | 'charcoal'\n    | null = null;\n\n  /**\n   * Size of the container.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n  /** The state of the component. */\n  private set _state(state: StickyState) {\n    if (this._stateInternal) {\n      this.internals.states.delete(`state-${this._stateInternal}`);\n    }\n    this._stateInternal = state;\n    if (this._stateInternal) {\n      this.internals.states.add(`state-${this._stateInternal}`);\n    }\n  }\n  private get _state(): StickyState {\n    return this._stateInternal;\n  }\n  private _stateInternal!: StickyState;\n\n  private _intersector?: HTMLSpanElement;\n  private _observer = new IntersectionController(this, {\n    // Although `this` is observed, we have to postpone observing\n    // into firstUpdated() to achieve a correct initial state.\n    target: null,\n    callback: (entries) => this._detectStickyState(entries[0]),\n  });\n\n  public constructor() {\n    super();\n\n    this._state = 'sticky';\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.slot ||= 'sticky-bar';\n\n    // Sticky bar needs to be hidden until first observer callback\n    this.startUpdate();\n\n    const container = this.closest('sbb-container');\n    if (container) {\n      this.toggleState('expanded', container.expanded);\n    }\n    if (this._intersector) {\n      this._observer.observe(this._intersector);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this.internals.states.delete('initialized');\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    if (!this._intersector) {\n      this._intersector = this.shadowRoot!.querySelector('.sbb-sticky-bar__intersector')!;\n      this._observer.observe(this._intersector);\n    }\n    this._observer.observe(this);\n  }\n\n  private _isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-sticky-bar-slide-vertically-animation-duration');\n  }\n\n  private _detectStickyState(entry: IntersectionObserverEntry): void {\n    this.internals.states.add('initialized');\n\n    const isSticky = !entry.isIntersecting && entry.boundingClientRect.top > 0;\n\n    // To optimize the visual perception of the sticky bar, we have certain cases (e.g. on page load)\n    // where we want the sticky bar to slide in from the bottom.\n    // To decide whether to slide in from the bottom up,\n    // we check how far away the sticky bar is from the intersector element. When scrolling fast, the\n    // difference can vary slightly. To account for this we add a height tolerance.\n    // This value was found by trial and error.\n    const intersectorRect = this._intersector?.getBoundingClientRect();\n    const stickyBarRect = this.shadowRoot!.querySelector(\n      '.sbb-sticky-bar__wrapper',\n    )!.getBoundingClientRect();\n    const HEIGHT_TOLERANCE = 30;\n\n    this.toggleState(\n      'slide-vertically',\n      isSticky &&\n        this._intersector &&\n        Math.abs(intersectorRect!.bottom - stickyBarRect.bottom) > HEIGHT_TOLERANCE,\n    );\n\n    // Toggling sticking has to be after slide-vertically (prevents background color transition)\n    this.toggleState('sticking', isSticky);\n\n    // Sticky bar needs to be hidden until first observer callback\n    this.completeUpdate();\n  }\n\n  /** Animates from normal content flow position to `position: sticky`. */\n  public stick(): void {\n    if (this._state !== 'unsticky' || !this._dispatchBeforeStickEvent()) {\n      return;\n    }\n\n    this._state = 'sticking';\n    if (!this.internals.states.has('sticking') || this._isZeroAnimationDuration()) {\n      this._stickyCallback();\n    }\n  }\n\n  /** Animates `position: sticky` to normal content flow position. */\n  public unstick(): void {\n    if (this._state !== 'sticky' || !this._dispatchBeforeUnStickEvent()) {\n      return;\n    }\n\n    this._state = 'unsticking';\n\n    if (!this.internals.states.has('sticking') || this._isZeroAnimationDuration()) {\n      this._unstickyCallback();\n    }\n  }\n\n  private _stickyCallback(): void {\n    this._state = 'sticky';\n\n    /** Emits when the animation from normal content flow to `position: sticky` ends. */\n    this.dispatchEvent(new Event('stick'));\n  }\n\n  private _unstickyCallback(): void {\n    /** Emits when the animation from `position: sticky` to normal content flow ends. */\n    this.dispatchEvent(new Event('unstick'));\n    this._state = 'unsticky';\n  }\n\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (\n      (this._state === 'sticking' || this._state === 'sticky') &&\n      event.animationName === 'slide-in'\n    ) {\n      this._stickyCallback();\n    } else if (this._state === 'unsticking' && event.animationName === 'slide-out') {\n      this._unstickyCallback();\n    }\n  }\n\n  private _dispatchBeforeStickEvent(): boolean {\n    /** Emits when the animation from normal content flow to `position: sticky` starts. Can be canceled. */\n    return this.dispatchEvent(new Event('beforestick', { cancelable: true }));\n  }\n\n  private _dispatchBeforeUnStickEvent(): boolean {\n    /** Emits when the animation from `position: sticky` to normal content flow starts. Can be canceled. */\n    return this.dispatchEvent(new Event('beforeunstick', { cancelable: true }));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-sticky-bar__wrapper\" @animationend=${this._onAnimationEnd}>\n        <div class=\"sbb-sticky-bar\">\n          <slot></slot>\n        </div>\n      </div>\n      <div class=\"sbb-sticky-bar__intersector\"></div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-sticky-bar': SbbStickyBarElement;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/container/sticky-bar.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @entrypoint
+ */
+export * from './sticky-bar/sticky-bar.component.ts';
+//# sourceMappingURL=sticky-bar.d.ts.map

package/development/container/sticky-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sticky-bar.d.ts","sourceRoot":"","sources":["../../../../src/elements/container/sticky-bar.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,sCAAsC,CAAC"}

package/development/container/sticky-bar.js

@@ -0,0 +1,5 @@
+import { SbbStickyBarElement } from "./sticky-bar/sticky-bar.component.js";
+export {
+  SbbStickyBarElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RpY2t5LWJhci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7In0=

package/development/container.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @entrypoint
+ */
+export * from './container/container.ts';
+export * from './container/sticky-bar.ts';
+//# sourceMappingURL=container.d.ts.map

package/development/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../../src/elements/container.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}

package/development/container.js

@@ -0,0 +1,7 @@
+import { SbbContainerElement } from "./container/container/container.component.js";
+import { SbbStickyBarElement } from "./container/sticky-bar/sticky-bar.component.js";
+export {
+  SbbContainerElement,
+  SbbStickyBarElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGFpbmVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=

package/development/core/a11y/arrow-navigation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Check if the key pressed is among those allowed for navigation.
+ * @param event The keyboard event to check.
+ */
+export declare function isArrowKeyPressed(event: KeyboardEvent): boolean;
+/**
+ * Check if the key pressed should move the navigation to the next element.
+ * @param event The keyboard event to check.
+ */
+export declare function isPreviousArrowKeyPressed(event: KeyboardEvent): boolean;
+/**
+ * Check if the key pressed should move the navigation to the next element.
+ * @param event The keyboard event to check.
+ */
+export declare function isNextArrowKeyPressed(event: KeyboardEvent): boolean;
+/**
+ * Check if the key pressed is among those allowed for navigation.
+ * @param event The keyboard event to check.
+ */
+export declare function isArrowKeyOrPageKeysPressed(event: KeyboardEvent): boolean;
+/**
+ * Gets the index of the element to move to, based on the keyboard input, the current element in the list and the list size.
+ * @param event The keyboard event to check. If null, will count as a 'next' step.
+ * @param current The index of the current element in the list.
+ * @param size The size of the list.
+ * @returns if it is a 'previous' event, returns the index of the previous element,
+ * or the index of the last one if the current element is the first in the list;
+ * if it is a 'next' event, returns the index of the next element,
+ * or the index of the first one, if the current is the last in the list.
+ */
+export declare function getNextElementIndex(event: KeyboardEvent | undefined, current: number, size: number): number;
+//# sourceMappingURL=arrow-navigation.d.ts.map

package/development/core/a11y/arrow-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-navigation.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/arrow-navigation.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAE/D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEvE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEnE;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEzE;AAkBD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,MAAM,CASR"}

package/development/core/a11y/arrow-navigation.js

@@ -0,0 +1,43 @@
+function getPrevAndNextKeys() {
+  if (document.documentElement.matches(":dir(rtl)")) {
+    return { prevKey: "ArrowRight", nextKey: "ArrowLeft" };
+  } else {
+    return { prevKey: "ArrowLeft", nextKey: "ArrowRight" };
+  }
+}
+function isArrowKeyPressed(event) {
+  return ["ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown"].includes(event.key);
+}
+function isPreviousArrowKeyPressed(event) {
+  return event.key === "ArrowUp" || event.key === getPrevAndNextKeys().prevKey;
+}
+function isNextArrowKeyPressed(event) {
+  return event.key === "ArrowDown" || event.key === getPrevAndNextKeys().nextKey;
+}
+function isArrowKeyOrPageKeysPressed(event) {
+  return isArrowKeyPressed(event) || ["PageUp", "PageDown", "Home", "End"].includes(event.key);
+}
+function calcNextIndexInRange(currentIndex, maxIndex, offset) {
+  return (currentIndex + offset + maxIndex) % maxIndex;
+}
+function getLastIndex(size) {
+  return size - 1;
+}
+const firstIndex = 0;
+function getNextElementIndex(event, current, size) {
+  const { prevKey, nextKey } = getPrevAndNextKeys();
+  if (!event || event.key === nextKey || event.key === "ArrowDown") {
+    return current >= size ? firstIndex : calcNextIndexInRange(current, size, 1);
+  } else if (event.key === prevKey || event.key === "ArrowUp") {
+    return current < firstIndex ? getLastIndex(size) : calcNextIndexInRange(current, size, -1);
+  }
+  return current;
+}
+export {
+  getNextElementIndex,
+  isArrowKeyOrPageKeysPressed,
+  isArrowKeyPressed,
+  isNextArrowKeyPressed,
+  isPreviousArrowKeyPressed
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/a11y/fake-event-detection.d.ts

@@ -0,0 +1,5 @@
+/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
+export declare function isFakeMousedownFromScreenReader(event: MouseEvent): boolean;
+/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
+export declare function isFakeTouchstartFromScreenReader(event: TouchEvent): boolean;
+//# sourceMappingURL=fake-event-detection.d.ts.map

package/development/core/a11y/fake-event-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-event-detection.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/fake-event-detection.ts"],"names":[],"mappings":"AAEA,8FAA8F;AAC9F,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAO1E;AAED,+FAA+F;AAC/F,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAc3E"}

package/development/core/a11y/fake-event-detection.js

@@ -0,0 +1,12 @@
+function isFakeMousedownFromScreenReader(event) {
+  return event.buttons === 0 || event.detail === 0;
+}
+function isFakeTouchstartFromScreenReader(event) {
+  const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0];
+  return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) && (touch.radiusY == null || touch.radiusY === 1);
+}
+export {
+  isFakeMousedownFromScreenReader,
+  isFakeTouchstartFromScreenReader
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/a11y/focus-trap-controller.d.ts

@@ -0,0 +1,35 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare class SbbFocusTrapController implements ReactiveController {
+    private _host;
+    /**
+     * Whether the focus is trap is enabled.
+     * @param enabled
+     */
+    set enabled(enabled: boolean);
+    get enabled(): boolean;
+    private _abortController;
+    constructor(_host: ReactiveControllerHost & HTMLElement);
+    hostDisconnected(): void;
+    /**
+     * Focuses the element that should be focused when the focus trap is initialized.
+     * @returns Whether focus was moved successfully.
+     */
+    focusInitialElement(options?: FocusOptions): boolean;
+    /**
+     * Focuses the first tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusFirstTabbableElement(options?: FocusOptions): boolean;
+    /**
+     * Focuses the last tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusLastTabbableElement(options?: FocusOptions): boolean;
+    private _trap;
+    /** Get the first tabbable element from a DOM subtree (inclusive). */
+    private _getFirstTabbableElement;
+    /** Get the last tabbable element from a DOM subtree (inclusive). */
+    private _getLastTabbableElement;
+    private _untrap;
+}
+//# sourceMappingURL=focus-trap-controller.d.ts.map

package/development/core/a11y/focus-trap-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-trap-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/focus-trap-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAItE,qBAAa,sBAAuB,YAAW,kBAAkB;IAkB5C,OAAO,CAAC,KAAK;IAjBhC;;;OAGG;IACH,IAAW,OAAO,CAAC,OAAO,EAAE,OAAO,EAMlC;IACD,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED,OAAO,CAAC,gBAAgB,CAAgC;gBAE7B,KAAK,EAAE,sBAAsB,GAAG,WAAW;IAI/D,gBAAgB,IAAI,IAAI;IAI/B;;;OAGG;IACI,mBAAmB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO;IAuB3D;;;OAGG;IACI,yBAAyB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO;IAUjE;;;OAGG;IACI,wBAAwB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO;IAUhE,OAAO,CAAC,KAAK;IA2Bb,qEAAqE;IACrE,OAAO,CAAC,wBAAwB;IA6BhC,oEAAoE;IACpE,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,OAAO;CAIhB"}