@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/navigation/navigation.js

@@ -0,0 +1,598 @@
+import { css, html } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { ref } from "lit/directives/ref.js";
+import { SbbFocusHandler, setModalityOnNextFocus } from "../core/a11y.js";
+import { SbbOpenCloseBaseElement } from "../core/base-elements.js";
+import { SbbConnectedAbortController, SbbLanguageController } from "../core/controllers.js";
+import { hostAttributes } from "../core/decorators.js";
+import { SbbScrollHandler, findReferencedElement } from "../core/dom.js";
+import { i18nCloseNavigation } from "../core/i18n.js";
+import { SbbUpdateSchedulerMixin } from "../core/mixins.js";
+import { AgnosticMutationObserver, AgnosticResizeObserver } from "../core/observers.js";
+import { isEventOnElement, removeAriaOverlayTriggerAttributes, setAriaOverlayTriggerAttributes, applyInertMechanism, removeInertMechanism } from "../core/overlay.js";
+import "../button/transparent-button.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-navigation-grid-column: 1 / 5;
+  --sbb-navigation-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-3x)
+  );
+  --sbb-navigation-animation-easing: ease-in;
+  --sbb-navigation-padding-inline: var(--sbb-layout-base-offset-responsive);
+  --sbb-navigation-padding-block-start: var(--sbb-spacing-responsive-l);
+  --sbb-navigation-padding-block-end: var(--sbb-spacing-responsive-xl);
+  --sbb-navigation-backdrop-visibility: hidden;
+  --sbb-navigation-backdrop-pointer-events: none;
+  --sbb-navigation-backdrop-color: transparent;
+  --sbb-navigation-list-margin-block-start: var(--sbb-spacing-responsive-xxl);
+  --sbb-navigation-inline-start: 0;
+  --sbb-navigation-expanded-width: 100%;
+  --sbb-navigation-inset: 0 auto auto 0;
+  --sbb-navigation-transform: translateX(-100%);
+  --sbb-navigation-content-transform: translateX(0);
+  --sbb-navigation-width: 100%;
+  --sbb-navigation-height: 100vh;
+  display: block;
+  position: fixed;
+  inset: var(--sbb-navigation-inset);
+  z-index: var(--sbb-navigation-z-index, var(--sbb-overlay-default-z-index));
+  overflow: hidden;
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+}
+@supports (height: 100dvh) {
+  :host {
+    --sbb-navigation-height: 100dvh;
+  }
+}
+@media (min-width: calc(52.5rem)) {
+  :host {
+    --sbb-navigation-grid-column: 1 / 9;
+  }
+}
+@media (min-width: calc(64rem)) {
+  :host {
+    --sbb-navigation-grid-column: 1 / 5;
+    --sbb-navigation-animation-duration: var(
+      --sbb-disable-animation-zero-time,
+      var(--sbb-animation-duration-6x)
+    );
+    --sbb-navigation-padding-block-start: var(--sbb-spacing-responsive-xl);
+    --sbb-navigation-padding-inline: var(--sbb-layout-base-offset-responsive) 0;
+    --sbb-navigation-list-margin-block-start: var(--sbb-spacing-fixed-1x);
+    --sbb-navigation-inline-start: calc(var(--sbb-layout-base-offset-responsive) * -1);
+    --sbb-navigation-width: calc(100% + var(--sbb-layout-base-offset-responsive));
+  }
+}
+@media (min-width: calc(90rem)) {
+  :host {
+    --sbb-navigation-grid-column: 1 / 6;
+    --sbb-navigation-padding-block-start: var(--sbb-spacing-responsive-xxl);
+  }
+}
+
+:host([data-state=opened]) {
+  --sbb-navigation-animation-easing: ease-out;
+}
+
+:host(:is([data-state=opened], [data-state=opening])) {
+  --sbb-navigation-backdrop-visibility: visible;
+  --sbb-navigation-backdrop-pointer-events: all;
+  --sbb-navigation-backdrop-color: var(--sbb-color-black-alpha-70);
+}
+
+:host(:not([data-state=closed])) {
+  --sbb-navigation-inset: 0;
+  --sbb-navigation-transform: translateX(0);
+}
+
+:host([data-has-navigation-section]) {
+  --sbb-navigation-content-transform: translateX(-100%);
+}
+@media (min-width: calc(64rem)) {
+  :host([data-has-navigation-section]) {
+    --sbb-navigation-expanded-width: 100vw;
+    --sbb-navigation-content-transform: translateX(0%);
+  }
+  @supports (height: 100dvw) {
+    :host([data-has-navigation-section]) {
+      --sbb-navigation-expanded-width: 100dvw;
+    }
+  }
+}
+
+:host([data-resize-disable-animation]) {
+  --sbb-disable-animation-time: 0.1ms;
+  --sbb-disable-animation-zero-time: 0s;
+}
+
+.sbb-navigation__container {
+  display: grid;
+  gap: var(--sbb-grid-base-gutter-responsive);
+  grid-template-columns: repeat(var(--sbb-grid-base-columns), 1fr);
+  padding-inline: 0;
+  pointer-events: none;
+  transform: var(--sbb-navigation-transform);
+}
+@media (min-width: calc(64rem)) {
+  .sbb-navigation__container {
+    padding-inline: var(--sbb-layout-base-offset-responsive);
+  }
+  .sbb-navigation__container::before {
+    transition-duration: var(--sbb-navigation-animation-duration);
+    transition-timing-function: var(--sbb-navigation-animation-easing);
+    transition-property: background-color, visibility;
+    content: "";
+    visibility: var(--sbb-navigation-backdrop-visibility);
+    pointer-events: var(--sbb-navigation-backdrop-pointer-events);
+    position: fixed;
+    inset: var(--sbb-navigation-inset);
+    background-color: var(--sbb-navigation-backdrop-color);
+  }
+}
+
+.sbb-navigation {
+  transition-duration: var(--sbb-navigation-animation-duration);
+  transition-timing-function: var(--sbb-navigation-animation-easing);
+  transition-property: width;
+  display: none;
+  width: var(--sbb-navigation-width);
+  grid-column: var(--sbb-navigation-grid-column);
+  padding: 0;
+  margin: 0;
+  position: relative;
+  inset-inline-start: var(--sbb-navigation-inline-start);
+  inset-block-start: 0;
+  border: none;
+  pointer-events: none;
+  height: var(--sbb-navigation-height);
+  color: var(--sbb-color-white);
+  background-color: var(--sbb-color-midnight);
+}
+.sbb-navigation::before {
+  transition-duration: var(--sbb-navigation-animation-duration);
+  transition-timing-function: var(--sbb-navigation-animation-easing);
+  transition-property: width;
+  content: "";
+  position: absolute;
+  width: var(--sbb-navigation-expanded-width);
+  height: var(--sbb-navigation-height);
+  background: var(--sbb-color-midnight);
+}
+:host([data-state]:not([data-state=closed])) .sbb-navigation {
+  display: block;
+  pointer-events: all;
+  animation-name: open;
+  animation-duration: var(--sbb-navigation-animation-duration);
+  animation-timing-function: var(--sbb-navigation-animation-easing);
+}
+:host([data-state][data-state=closing]) .sbb-navigation {
+  pointer-events: none;
+  animation-name: close;
+}
+@media (forced-colors: active) {
+  .sbb-navigation {
+    outline: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+
+.sbb-navigation__wrapper {
+  outline: none;
+}
+
+.sbb-navigation__header {
+  transition-duration: var(--sbb-navigation-animation-duration);
+  transition-timing-function: var(--sbb-navigation-animation-easing);
+  transition-property: width;
+  display: flex;
+  justify-content: flex-end;
+  position: absolute;
+  width: var(--sbb-navigation-expanded-width);
+  pointer-events: none;
+  padding: var(--sbb-spacing-responsive-xs);
+  z-index: calc(var(--sbb-navigation-z-index, var(--sbb-overlay-default-z-index)) + 1);
+}
+
+.sbb-navigation__close {
+  pointer-events: all;
+}
+
+.sbb-navigation__content {
+  transition-duration: var(--sbb-navigation-animation-duration);
+  transition-timing-function: var(--sbb-navigation-animation-easing);
+  transition-property: transform;
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-white-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-white-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+  /* Scrollbar itself */
+  /* Hide button (top and bottom of the scrollbar) */
+  display: flex;
+  flex-direction: column;
+  gap: var(--sbb-spacing-responsive-xxl);
+  position: relative;
+  height: var(--sbb-navigation-height);
+  padding-inline: var(--sbb-navigation-padding-inline);
+  padding-block: var(--sbb-navigation-padding-block-start) var(--sbb-navigation-padding-block-end);
+  overflow-y: auto;
+  transform: var(--sbb-navigation-content-transform);
+}
+.sbb-navigation__content::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-navigation__content::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-navigation__content::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-navigation__content::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-navigation__content::-webkit-scrollbar-button, .sbb-navigation__content::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-navigation__content {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+
+::slotted(:first-child) {
+  margin-block-start: var(--sbb-navigation-list-margin-block-start);
+}
+
+@keyframes open {
+  from {
+    transform: translateX(-100%);
+  }
+  to {
+    transform: translateX(0%);
+  }
+}
+@keyframes close {
+  from {
+    transform: translateX(0%);
+  }
+  to {
+    transform: translateX(-100%);
+  }
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+const navigationObserverConfig = {
+  subtree: true,
+  attributeFilter: ["data-state"]
+};
+let nextId = 0;
+const DEBOUNCE_TIME = 150;
+let SbbNavigationElement = class extends SbbUpdateSchedulerMixin(SbbOpenCloseBaseElement) {
+  constructor() {
+    super(...arguments);
+    this._trigger = null;
+    this._activeNavigationSection = null;
+    this._triggerElement = null;
+    this._abort = new SbbConnectedAbortController(this);
+    this._language = new SbbLanguageController(this);
+    this._focusHandler = new SbbFocusHandler();
+    this._scrollHandler = new SbbScrollHandler();
+    this._isPointerDownEventOnNavigation = false;
+    this._resizeObserverTimeout = null;
+    this._navigationObserver = new AgnosticMutationObserver(
+      (mutationsList) => this._onNavigationSectionChange(mutationsList)
+    );
+    this._navigationResizeObserver = new AgnosticResizeObserver(() => this._onNavigationResize());
+    this._trapFocusFilter = (el) => {
+      return el.nodeName !== "SBB-NAVIGATION-SECTION" || el.getAttribute("data-state") === "opened";
+    };
+    this._pointerDownListener = (event) => {
+      var _a, _b;
+      this._isPointerDownEventOnNavigation = isEventOnElement(this._navigation, event) || isEventOnElement(
+        (_b = (_a = this.querySelector(
+          'sbb-navigation-section[data-state="opened"]'
+        )) == null ? void 0 : _a.shadowRoot) == null ? void 0 : _b.querySelector("nav.sbb-navigation-section"),
+        event
+      );
+    };
+    this._closeOnBackdropClick = (event) => {
+      if (!this._isPointerDownEventOnNavigation && !isEventOnElement(this._navigation, event)) {
+        this.close();
+      }
+    };
+  }
+  set trigger(value) {
+    const oldValue = this._trigger;
+    this._trigger = value;
+    this._removeTriggerClickListener(this._trigger, oldValue);
+  }
+  get trigger() {
+    return this._trigger;
+  }
+  get activeNavigationSection() {
+    return this._activeNavigationSection;
+  }
+  /**
+   * Opens the navigation.
+   */
+  open() {
+    var _a;
+    if (this.state !== "closed" || !this._navigation) {
+      return;
+    }
+    if (!this.willOpen.emit()) {
+      return;
+    }
+    this.state = "opening";
+    this._checkActiveActions();
+    this._checkActiveSection();
+    this.startUpdate();
+    this._scrollHandler.disableScroll();
+    (_a = this._triggerElement) == null ? void 0 : _a.setAttribute("aria-expanded", "true");
+  }
+  _checkActiveSection() {
+    var _a;
+    const activeAction = this.querySelector(
+      "sbb-navigation-button.sbb-active"
+    );
+    (_a = activeAction == null ? void 0 : activeAction.connectedSection) == null ? void 0 : _a.open();
+  }
+  _checkActiveActions() {
+    const activeActions = Array.from(
+      this.querySelectorAll(":is(sbb-navigation-button, sbb-navigation-link).sbb-active")
+    );
+    activeActions == null ? void 0 : activeActions.forEach((action) => {
+      var _a;
+      return (_a = action.marker) == null ? void 0 : _a.select(action);
+    });
+  }
+  /**
+   * Closes the navigation.
+   */
+  close() {
+    var _a;
+    if (this.state !== "opened") {
+      return;
+    }
+    if (!this.willClose.emit()) {
+      return;
+    }
+    this.state = "closing";
+    this.startUpdate();
+    (_a = this._triggerElement) == null ? void 0 : _a.setAttribute("aria-expanded", "false");
+  }
+  // Removes trigger click listener on trigger change.
+  _removeTriggerClickListener(newValue, oldValue) {
+    var _a, _b;
+    if (newValue !== oldValue) {
+      (_a = this._navigationController) == null ? void 0 : _a.abort();
+      (_b = this._windowEventsController) == null ? void 0 : _b.abort();
+      this._configure(this.trigger);
+    }
+  }
+  // Check if the trigger is valid and attach click event listeners.
+  _configure(trigger) {
+    var _a;
+    removeAriaOverlayTriggerAttributes(this._triggerElement);
+    if (!trigger) {
+      return;
+    }
+    this._triggerElement = findReferencedElement(trigger);
+    if (!this._triggerElement) {
+      return;
+    }
+    setAriaOverlayTriggerAttributes(this._triggerElement, "menu", this.id, this.state);
+    (_a = this._navigationController) == null ? void 0 : _a.abort();
+    this._navigationController = new AbortController();
+    this._triggerElement.addEventListener("click", () => this.open(), {
+      signal: this._navigationController.signal
+    });
+  }
+  // In rare cases it can be that the animationEnd event is triggered twice.
+  // To avoid entering a corrupt state, exit when state is not expected.
+  _onAnimationEnd(event) {
+    var _a, _b;
+    if (event.animationName === "open" && this.state === "opening") {
+      this.state = "opened";
+      this.didOpen.emit();
+      this._navigationResizeObserver.observe(this);
+      applyInertMechanism(this);
+      this._focusHandler.trap(this, { filter: this._trapFocusFilter });
+      this._attachWindowEvents();
+      this._setNavigationFocus();
+    } else if (event.animationName === "close" && this.state === "closing") {
+      this.state = "closed";
+      this._navigationContentElement.scrollTo(0, 0);
+      setModalityOnNextFocus(this._triggerElement);
+      removeInertMechanism();
+      (_a = this._triggerElement) == null ? void 0 : _a.focus();
+      this.didClose.emit();
+      this._navigationResizeObserver.unobserve(this);
+      this._resetMarkers();
+      (_b = this._windowEventsController) == null ? void 0 : _b.abort();
+      this._focusHandler.disconnect();
+      this._scrollHandler.enableScroll();
+    }
+    this.completeUpdate();
+  }
+  _resetMarkers() {
+    const activeActions = Array.from(
+      this.querySelectorAll(
+        ":is(sbb-navigation-button, sbb-navigation-link)[data-action-active]:not(.sbb-active)"
+      )
+    );
+    activeActions == null ? void 0 : activeActions.forEach((action) => {
+      var _a;
+      return (_a = action.marker) == null ? void 0 : _a.reset();
+    });
+  }
+  _attachWindowEvents() {
+    this._windowEventsController = new AbortController();
+    window.addEventListener("keydown", (event) => this._onKeydownEvent(event), {
+      signal: this._windowEventsController.signal
+    });
+  }
+  _handleNavigationClose(event) {
+    const composedPathElements = event.composedPath().filter((el) => el instanceof window.HTMLElement);
+    if (composedPathElements.some((el) => this._isCloseElement(el))) {
+      this.close();
+    }
+  }
+  _isCloseElement(element) {
+    return element.nodeName === "A" || element.hasAttribute("sbb-navigation-close") && !element.hasAttribute("disabled");
+  }
+  // Closes the navigation on "Esc" key pressed.
+  _onKeydownEvent(event) {
+    if (this.state === "opened" && event.key === "Escape") {
+      this.close();
+    }
+  }
+  // Set focus on the first focusable element.
+  _setNavigationFocus() {
+    const closeButton = this.shadowRoot.querySelector(
+      "#sbb-navigation-close-button"
+    );
+    setModalityOnNextFocus(closeButton);
+    closeButton.focus();
+  }
+  // Observe changes on navigation section data-state.
+  _onNavigationSectionChange(mutationsList) {
+    for (const mutation of mutationsList) {
+      if (mutation.target.nodeName === "SBB-NAVIGATION-SECTION") {
+        this._activeNavigationSection = this.querySelector(
+          'sbb-navigation-section[data-state="opening"], sbb-navigation-section[data-state="opened"]'
+        );
+        this.toggleAttribute("data-has-navigation-section", !!this._activeNavigationSection);
+      }
+    }
+  }
+  _onNavigationResize() {
+    if (this.state !== "opened") {
+      return;
+    }
+    if (this._resizeObserverTimeout) {
+      clearTimeout(this._resizeObserverTimeout);
+    }
+    this.toggleAttribute("data-resize-disable-animation", true);
+    this._resizeObserverTimeout = setTimeout(
+      () => this.removeAttribute("data-resize-disable-animation"),
+      DEBOUNCE_TIME
+    );
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.id || (this.id = `sbb-navigation-${nextId++}`);
+    const signal = this._abort.signal;
+    this.addEventListener("click", (e) => this._handleNavigationClose(e), { signal });
+    this._configure(this.trigger);
+    this._navigationObserver.observe(this, navigationObserverConfig);
+    this.addEventListener("pointerup", (event) => this._closeOnBackdropClick(event), { signal });
+    this.addEventListener("pointerdown", (event) => this._pointerDownListener(event), { signal });
+    if (this.state === "opened") {
+      applyInertMechanism(this);
+    }
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this._navigationController) == null ? void 0 : _a.abort();
+    (_b = this._windowEventsController) == null ? void 0 : _b.abort();
+    this._focusHandler.disconnect();
+    this._navigationObserver.disconnect();
+    this._navigationResizeObserver.disconnect();
+    removeInertMechanism();
+  }
+  render() {
+    const closeButton = html`
+      <sbb-transparent-button
+        id="sbb-navigation-close-button"
+        class="sbb-navigation__close"
+        aria-label=${this.accessibilityCloseLabel || i18nCloseNavigation[this._language.current]}
+        aria-controls="sbb-navigation-overlay"
+        negative
+        size="m"
+        type="button"
+        icon-name="cross-small"
+        sbb-navigation-close
+      ></sbb-transparent-button>
+    `;
+    return html`
+      <div class="sbb-navigation__container">
+        <div
+          id="sbb-navigation-overlay"
+          @animationend=${(event) => this._onAnimationEnd(event)}
+          class="sbb-navigation"
+          ${ref((navigationRef) => this._navigation = navigationRef)}
+        >
+          <div class="sbb-navigation__header">${closeButton}</div>
+          <div class="sbb-navigation__wrapper">
+            <div
+              class="sbb-navigation__content"
+              ${ref((el) => this._navigationContentElement = el)}
+            >
+              <slot></slot>
+            </div>
+          </div>
+        </div>
+        <slot name="navigation-section"></slot>
+      </div>
+    `;
+  }
+};
+SbbNavigationElement.styles = style;
+__decorateClass([
+  property()
+], SbbNavigationElement.prototype, "trigger", 1);
+__decorateClass([
+  property({ attribute: "accessibility-close-label" })
+], SbbNavigationElement.prototype, "accessibilityCloseLabel", 2);
+__decorateClass([
+  state()
+], SbbNavigationElement.prototype, "_activeNavigationSection", 2);
+SbbNavigationElement = __decorateClass([
+  customElement("sbb-navigation"),
+  hostAttributes({
+    role: "navigation"
+  })
+], SbbNavigationElement);
+export {
+  SbbNavigationElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"navigation.js","sources":["../../../../src/elements/navigation/navigation/navigation.ts"],"sourcesContent":["import type { CSSResultGroup, TemplateResult } from 'lit';\nimport { html } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport { SbbFocusHandler, setModalityOnNextFocus } from '../../core/a11y.js';\nimport { SbbOpenCloseBaseElement } from '../../core/base-elements.js';\nimport { SbbConnectedAbortController, SbbLanguageController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { findReferencedElement, SbbScrollHandler } from '../../core/dom.js';\nimport { i18nCloseNavigation } from '../../core/i18n.js';\nimport { SbbUpdateSchedulerMixin } from '../../core/mixins.js';\nimport { AgnosticMutationObserver, AgnosticResizeObserver } from '../../core/observers.js';\nimport {\n  applyInertMechanism,\n  isEventOnElement,\n  removeAriaOverlayTriggerAttributes,\n  removeInertMechanism,\n  setAriaOverlayTriggerAttributes,\n} from '../../core/overlay.js';\nimport type { SbbNavigationButtonElement } from '../navigation-button.js';\nimport type { SbbNavigationLinkElement } from '../navigation-link.js';\n\nimport style from './navigation.scss?lit&inline';\n\nimport '../../button/transparent-button.js';\n\n/** Configuration for the attribute to look at if a navigation section is displayed */\nconst navigationObserverConfig: MutationObserverInit = {\n  subtree: true,\n  attributeFilter: ['data-state'],\n};\n\nlet nextId = 0;\nconst DEBOUNCE_TIME = 150;\n\n/**\n * It displays a navigation menu, wrapping one or more `sbb-navigation-*` components.\n *\n * @slot - Use the unnamed slot to add `sbb-navigation-button`/`sbb-navigation-link` elements into the sbb-navigation menu.\n * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-navigation` begins the opening transition. Can be canceled.\n * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-navigation` is opened.\n * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-navigation` begins the closing transition. Can be canceled.\n * @event {CustomEvent<void>} didClose - Emits whenever the `sbb-navigation` is closed.\n * @cssprop [--sbb-navigation-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n */\n@customElement('sbb-navigation')\n@hostAttributes({\n  role: 'navigation',\n})\nexport class SbbNavigationElement extends SbbUpdateSchedulerMixin(SbbOpenCloseBaseElement) {\n  public static override styles: CSSResultGroup = style;\n\n  /**\n   * The element that will trigger the navigation.\n   * Accepts both a string (id of an element) or an HTML element.\n   */\n  @property()\n  public set trigger(value: string | HTMLElement | null) {\n    const oldValue = this._trigger;\n    this._trigger = value;\n    this._removeTriggerClickListener(this._trigger, oldValue);\n  }\n  public get trigger(): string | HTMLElement | null {\n    return this._trigger;\n  }\n  private _trigger: string | HTMLElement | null = null;\n\n  /**\n   * This will be forwarded as aria-label to the close button element.\n   */\n  @property({ attribute: 'accessibility-close-label' }) public accessibilityCloseLabel:\n    | string\n    | undefined;\n\n  /**\n   * Whether a navigation section is displayed.\n   */\n  @state() private _activeNavigationSection: HTMLElement | null = null;\n\n  public get activeNavigationSection(): HTMLElement | null {\n    return this._activeNavigationSection;\n  }\n\n  private _navigation!: HTMLDivElement;\n  private _navigationContentElement!: HTMLElement;\n  private _triggerElement: HTMLElement | null = null;\n  private _navigationController!: AbortController;\n  private _windowEventsController!: AbortController;\n  private _abort = new SbbConnectedAbortController(this);\n  private _language = new SbbLanguageController(this);\n  private _focusHandler = new SbbFocusHandler();\n  private _scrollHandler = new SbbScrollHandler();\n  private _isPointerDownEventOnNavigation: boolean = false;\n  private _resizeObserverTimeout: ReturnType<typeof setTimeout> | null = null;\n  private _navigationObserver = new AgnosticMutationObserver((mutationsList: MutationRecord[]) =>\n    this._onNavigationSectionChange(mutationsList),\n  );\n  private _navigationResizeObserver = new AgnosticResizeObserver(() => this._onNavigationResize());\n\n  /**\n   * Opens the navigation.\n   */\n  public open(): void {\n    if (this.state !== 'closed' || !this._navigation) {\n      return;\n    }\n\n    if (!this.willOpen.emit()) {\n      return;\n    }\n    this.state = 'opening';\n    this._checkActiveActions();\n    this._checkActiveSection();\n    this.startUpdate();\n\n    // Disable scrolling for content below the navigation\n    this._scrollHandler.disableScroll();\n    this._triggerElement?.setAttribute('aria-expanded', 'true');\n  }\n\n  private _checkActiveSection(): void {\n    const activeAction = this.querySelector(\n      'sbb-navigation-button.sbb-active',\n    ) as SbbNavigationButtonElement;\n    activeAction?.connectedSection?.open();\n  }\n\n  private _checkActiveActions(): void {\n    const activeActions = Array.from(\n      this.querySelectorAll(':is(sbb-navigation-button, sbb-navigation-link).sbb-active'),\n    ) as (SbbNavigationButtonElement | SbbNavigationLinkElement)[];\n    activeActions?.forEach((action) => action.marker?.select(action));\n  }\n\n  /**\n   * Closes the navigation.\n   */\n  public close(): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    if (!this.willClose.emit()) {\n      return;\n    }\n    this.state = 'closing';\n    this.startUpdate();\n    this._triggerElement?.setAttribute('aria-expanded', 'false');\n  }\n\n  // Removes trigger click listener on trigger change.\n  private _removeTriggerClickListener(\n    newValue: string | HTMLElement | null,\n    oldValue: string | HTMLElement | null,\n  ): void {\n    if (newValue !== oldValue) {\n      this._navigationController?.abort();\n      this._windowEventsController?.abort();\n      this._configure(this.trigger);\n    }\n  }\n\n  // Check if the trigger is valid and attach click event listeners.\n  private _configure(trigger: string | HTMLElement | null): void {\n    removeAriaOverlayTriggerAttributes(this._triggerElement);\n\n    if (!trigger) {\n      return;\n    }\n\n    this._triggerElement = findReferencedElement(trigger);\n\n    if (!this._triggerElement) {\n      return;\n    }\n\n    setAriaOverlayTriggerAttributes(this._triggerElement, 'menu', this.id, this.state);\n    this._navigationController?.abort();\n    this._navigationController = new AbortController();\n    this._triggerElement.addEventListener('click', () => this.open(), {\n      signal: this._navigationController.signal,\n    });\n  }\n\n  private _trapFocusFilter = (el: HTMLElement): boolean => {\n    return el.nodeName !== 'SBB-NAVIGATION-SECTION' || el.getAttribute('data-state') === 'opened';\n  };\n\n  // In rare cases it can be that the animationEnd event is triggered twice.\n  // To avoid entering a corrupt state, exit when state is not expected.\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this.state = 'opened';\n      this.didOpen.emit();\n      this._navigationResizeObserver.observe(this);\n      applyInertMechanism(this);\n      this._focusHandler.trap(this, { filter: this._trapFocusFilter });\n      this._attachWindowEvents();\n      this._setNavigationFocus();\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this.state = 'closed';\n      this._navigationContentElement.scrollTo(0, 0);\n      setModalityOnNextFocus(this._triggerElement);\n      removeInertMechanism();\n      // To enable focusing other element than the trigger, we need to call focus() a second time.\n      this._triggerElement?.focus();\n      this.didClose.emit();\n      this._navigationResizeObserver.unobserve(this);\n      this._resetMarkers();\n      this._windowEventsController?.abort();\n      this._focusHandler.disconnect();\n\n      // Enable scrolling for content below the navigation\n      this._scrollHandler.enableScroll();\n    }\n    this.completeUpdate();\n  }\n\n  private _resetMarkers(): void {\n    const activeActions = Array.from(\n      this.querySelectorAll(\n        ':is(sbb-navigation-button, sbb-navigation-link)[data-action-active]:not(.sbb-active)',\n      ),\n    ) as (SbbNavigationButtonElement | SbbNavigationLinkElement)[];\n    activeActions?.forEach((action) => action.marker?.reset());\n  }\n\n  private _attachWindowEvents(): void {\n    this._windowEventsController = new AbortController();\n    window.addEventListener('keydown', (event: KeyboardEvent) => this._onKeydownEvent(event), {\n      signal: this._windowEventsController.signal,\n    });\n  }\n\n  private _handleNavigationClose(event: Event): void {\n    const composedPathElements = event\n      .composedPath()\n      .filter((el) => el instanceof window.HTMLElement);\n    if (composedPathElements.some((el) => this._isCloseElement(el as HTMLElement))) {\n      this.close();\n    }\n  }\n\n  private _isCloseElement(element: HTMLElement): boolean {\n    return (\n      element.nodeName === 'A' ||\n      (element.hasAttribute('sbb-navigation-close') && !element.hasAttribute('disabled'))\n    );\n  }\n\n  // Closes the navigation on \"Esc\" key pressed.\n  private _onKeydownEvent(event: KeyboardEvent): void {\n    if (this.state === 'opened' && event.key === 'Escape') {\n      this.close();\n    }\n  }\n\n  // Set focus on the first focusable element.\n  private _setNavigationFocus(): void {\n    const closeButton = this.shadowRoot!.querySelector(\n      '#sbb-navigation-close-button',\n    ) as HTMLElement;\n    setModalityOnNextFocus(closeButton);\n    closeButton.focus();\n  }\n\n  // Check if the pointerdown event target is triggered on the navigation.\n  private _pointerDownListener = (event: PointerEvent): void => {\n    this._isPointerDownEventOnNavigation =\n      isEventOnElement(this._navigation, event) ||\n      isEventOnElement(\n        this.querySelector(\n          'sbb-navigation-section[data-state=\"opened\"]',\n        )?.shadowRoot?.querySelector('nav.sbb-navigation-section') as HTMLElement,\n        event,\n      );\n  };\n\n  // Close navigation on backdrop click.\n  private _closeOnBackdropClick = (event: PointerEvent): void => {\n    if (!this._isPointerDownEventOnNavigation && !isEventOnElement(this._navigation, event)) {\n      this.close();\n    }\n  };\n\n  // Observe changes on navigation section data-state.\n  private _onNavigationSectionChange(mutationsList: MutationRecord[]): void {\n    for (const mutation of mutationsList) {\n      if ((mutation.target as HTMLElement).nodeName === 'SBB-NAVIGATION-SECTION') {\n        this._activeNavigationSection = this.querySelector(\n          'sbb-navigation-section[data-state=\"opening\"], sbb-navigation-section[data-state=\"opened\"]',\n        );\n        this.toggleAttribute('data-has-navigation-section', !!this._activeNavigationSection);\n      }\n    }\n  }\n\n  private _onNavigationResize(): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    if (this._resizeObserverTimeout) {\n      clearTimeout(this._resizeObserverTimeout);\n    }\n\n    this.toggleAttribute('data-resize-disable-animation', true);\n\n    // Disable the animation when resizing the navigation to avoid strange height transition effects.\n    this._resizeObserverTimeout = setTimeout(\n      () => this.removeAttribute('data-resize-disable-animation'),\n      DEBOUNCE_TIME,\n    );\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.id ||= `sbb-navigation-${nextId++}`;\n    const signal = this._abort.signal;\n    this.addEventListener('click', (e) => this._handleNavigationClose(e), { signal });\n    // Validate trigger element and attach event listeners\n    this._configure(this.trigger);\n    this._navigationObserver.observe(this, navigationObserverConfig);\n    this.addEventListener('pointerup', (event) => this._closeOnBackdropClick(event), { signal });\n    this.addEventListener('pointerdown', (event) => this._pointerDownListener(event), { signal });\n\n    if (this.state === 'opened') {\n      applyInertMechanism(this);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._navigationController?.abort();\n    this._windowEventsController?.abort();\n    this._focusHandler.disconnect();\n    this._navigationObserver.disconnect();\n    this._navigationResizeObserver.disconnect();\n    removeInertMechanism();\n  }\n\n  protected override render(): TemplateResult {\n    const closeButton = html`\n      <sbb-transparent-button\n        id=\"sbb-navigation-close-button\"\n        class=\"sbb-navigation__close\"\n        aria-label=${this.accessibilityCloseLabel || i18nCloseNavigation[this._language.current]}\n        aria-controls=\"sbb-navigation-overlay\"\n        negative\n        size=\"m\"\n        type=\"button\"\n        icon-name=\"cross-small\"\n        sbb-navigation-close\n      ></sbb-transparent-button>\n    `;\n\n    return html`\n      <div class=\"sbb-navigation__container\">\n        <div\n          id=\"sbb-navigation-overlay\"\n          @animationend=${(event: AnimationEvent) => this._onAnimationEnd(event)}\n          class=\"sbb-navigation\"\n          ${ref((navigationRef?: Element) => (this._navigation = navigationRef as HTMLDivElement))}\n        >\n          <div class=\"sbb-navigation__header\">${closeButton}</div>\n          <div class=\"sbb-navigation__wrapper\">\n            <div\n              class=\"sbb-navigation__content\"\n              ${ref((el?: Element) => (this._navigationContentElement = el as HTMLElement))}\n            >\n              <slot></slot>\n            </div>\n          </div>\n        </div>\n        <slot name=\"navigation-section\"></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-navigation': SbbNavigationElement;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/navigation.d.ts

@@ -0,0 +1,8 @@
+export * from './navigation/navigation.js';
+export * from './navigation/navigation-list.js';
+export * from './navigation/navigation-marker.js';
+export * from './navigation/navigation-section.js';
+export * from './navigation/navigation-button.js';
+export * from './navigation/navigation-link.js';
+export * from './navigation/common.js';
+//# sourceMappingURL=navigation.d.ts.map

package/development/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/elements/navigation.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC"}

package/development/navigation.js

@@ -0,0 +1,8 @@
+export * from "./navigation/navigation.js";
+export * from "./navigation/navigation-list.js";
+export * from "./navigation/navigation-marker.js";
+export * from "./navigation/navigation-section.js";
+export * from "./navigation/navigation-button.js";
+export * from "./navigation/navigation-link.js";
+export * from "./navigation/common.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7In0=