@nasa-terra/components 0.0.167 → 0.0.169

package/dist/chunks/chunk.2IFSOO3E.js

@@ -0,0 +1,252 @@
+import {
+  waitForEvent
+} from "./chunk.N5ZOPEYQ.js";
+import {
+  HasSlotController
+} from "./chunk.7YRJKZ6R.js";
+import {
+  watch
+} from "./chunk.NWXJOH5T.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.JEAP7TNI.js";
+import {
+  alert_styles_default
+} from "./chunk.D74V2Y4N.js";
+import {
+  __decorateClass
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/alert/alert.component.ts
+import { classMap } from "lit/directives/class-map.js";
+import { html } from "lit";
+import { property, query, state } from "lit/decorators.js";
+var _TerraAlert = class _TerraAlert extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(this, "icon", "suffix");
+    this.open = false;
+    this.closable = false;
+    this.variant = "primary";
+    this.appearance = "filled";
+    this.duration = Infinity;
+    this.remainingTime = this.duration;
+  }
+  static get toastStack() {
+    if (!this.currentToastStack) {
+      this.currentToastStack = Object.assign(document.createElement("div"), {
+        className: "terra-toast-stack"
+      });
+    }
+    return this.currentToastStack;
+  }
+  firstUpdated() {
+    this.base.hidden = !this.open;
+  }
+  restartAutoHide() {
+    this.handleCountdownChange();
+    clearTimeout(this.autoHideTimeout);
+    clearInterval(this.remainingTimeInterval);
+    if (this.open && this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(() => this.hide(), this.duration);
+      this.remainingTime = this.duration;
+      this.remainingTimeInterval = window.setInterval(() => {
+        this.remainingTime -= 100;
+      }, 100);
+    }
+  }
+  pauseAutoHide() {
+    var _a;
+    (_a = this.countdownAnimation) == null ? void 0 : _a.pause();
+    clearTimeout(this.autoHideTimeout);
+    clearInterval(this.remainingTimeInterval);
+  }
+  resumeAutoHide() {
+    var _a;
+    if (this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(
+        () => this.hide(),
+        this.remainingTime
+      );
+      this.remainingTimeInterval = window.setInterval(() => {
+        this.remainingTime -= 100;
+      }, 100);
+      (_a = this.countdownAnimation) == null ? void 0 : _a.play();
+    }
+  }
+  handleCountdownChange() {
+    if (this.open && this.duration < Infinity && this.countdown) {
+      const { countdownElement } = this;
+      const start = "100%";
+      const end = "0";
+      this.countdownAnimation = countdownElement.animate(
+        [{ width: start }, { width: end }],
+        {
+          duration: this.duration,
+          easing: "linear"
+        }
+      );
+    }
+  }
+  handleCloseClick() {
+    this.hide();
+  }
+  async handleOpenChange() {
+    this.base.hidden = !this.open;
+    if (this.open) {
+      this.emit("terra-show");
+      if (this.duration < Infinity) {
+        this.restartAutoHide();
+      }
+      this.emit("terra-after-show");
+    } else {
+      this.emit("terra-hide");
+      clearTimeout(this.autoHideTimeout);
+      clearInterval(this.remainingTimeInterval);
+      this.emit("terra-after-hide");
+    }
+  }
+  handleDurationChange() {
+    this.restartAutoHide();
+  }
+  /** Shows the alert. */
+  async show() {
+    if (this.open) {
+      return void 0;
+    }
+    this.open = true;
+    return waitForEvent(this, "terra-after-show");
+  }
+  /** Hides the alert */
+  async hide() {
+    if (!this.open) {
+      return void 0;
+    }
+    this.open = false;
+    return waitForEvent(this, "terra-after-hide");
+  }
+  /**
+   * Displays the alert as a toast notification. This will move the alert out of its position in the DOM and, when
+   * dismissed, it will be removed from the DOM completely. By storing a reference to the alert, you can reuse it by
+   * calling this method again. The returned promise will resolve after the alert is hidden.
+   */
+  async toast() {
+    return new Promise((resolve) => {
+      this.handleCountdownChange();
+      if (_TerraAlert.toastStack.parentElement === null) {
+        document.body.append(_TerraAlert.toastStack);
+      }
+      _TerraAlert.toastStack.appendChild(this);
+      requestAnimationFrame(() => {
+        this.clientWidth;
+        this.show();
+      });
+      this.addEventListener(
+        "terra-after-hide",
+        () => {
+          _TerraAlert.toastStack.removeChild(this);
+          resolve();
+          if (_TerraAlert.toastStack.querySelector("terra-alert") === null) {
+            _TerraAlert.toastStack.remove();
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  render() {
+    return html`
+            <div
+                part="base"
+                class=${classMap({
+      alert: true,
+      "alert--open": this.open,
+      "alert--closable": this.closable,
+      "alert--has-countdown": !!this.countdown,
+      "alert--has-icon": this.hasSlotController.test("icon"),
+      "alert--primary": this.variant === "primary",
+      "alert--success": this.variant === "success",
+      "alert--neutral": this.variant === "neutral",
+      "alert--warning": this.variant === "warning",
+      "alert--danger": this.variant === "danger",
+      "alert--filled": this.appearance === "filled",
+      "alert--white": this.appearance === "white"
+    })}
+                role="alert"
+                aria-hidden=${this.open ? "false" : "true"}
+                @mouseenter=${this.pauseAutoHide}
+                @mouseleave=${this.resumeAutoHide}
+            >
+                <div part="icon" class="alert__icon">
+                    <slot name="icon"></slot>
+                </div>
+
+                <div part="message" class="alert__message" aria-live="polite">
+                    <slot></slot>
+                </div>
+
+                ${this.closable ? html`
+                          <terra-icon
+                              class="alert__close-button"
+                              name="solid-x-mark"
+                              library="heroicons"
+                              @click=${this.handleCloseClick}
+                          ></terra-icon>
+                      ` : ""}
+
+                <div role="timer" class="alert__timer">${this.remainingTime}</div>
+
+                ${this.countdown ? html`
+                          <div
+                              class=${classMap({
+      alert__countdown: true,
+      "alert__countdown--ltr": this.countdown === "ltr"
+    })}
+                          >
+                              <div class="alert__countdown-elapsed"></div>
+                          </div>
+                      ` : ""}
+            </div>
+        `;
+  }
+};
+_TerraAlert.styles = [component_styles_default, alert_styles_default];
+__decorateClass([
+  query('[part~="base"]')
+], _TerraAlert.prototype, "base", 2);
+__decorateClass([
+  query(".alert__countdown-elapsed")
+], _TerraAlert.prototype, "countdownElement", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], _TerraAlert.prototype, "open", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], _TerraAlert.prototype, "closable", 2);
+__decorateClass([
+  property({ reflect: true })
+], _TerraAlert.prototype, "variant", 2);
+__decorateClass([
+  property({ reflect: true })
+], _TerraAlert.prototype, "appearance", 2);
+__decorateClass([
+  property({ type: Number })
+], _TerraAlert.prototype, "duration", 2);
+__decorateClass([
+  property({ type: String, reflect: true })
+], _TerraAlert.prototype, "countdown", 2);
+__decorateClass([
+  state()
+], _TerraAlert.prototype, "remainingTime", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], _TerraAlert.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch("duration")
+], _TerraAlert.prototype, "handleDurationChange", 1);
+var TerraAlert = _TerraAlert;
+
+export {
+  TerraAlert
+};

package/dist/chunks/chunk.2JLEP7WV.js

@@ -0,0 +1,135 @@
+// src/components/dialog/dialog.styles.ts
+import { css } from "lit";
+var dialog_styles_default = css`
+    :host {
+        --width: fit-content;
+        --header-spacing: var(--terra-spacing-large);
+        --body-spacing: var(--terra-spacing-large);
+        --footer-spacing: var(--terra-spacing-large);
+
+        display: contents;
+    }
+
+    .dialog {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        position: fixed;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
+        z-index: var(--terra-z-index-dialog);
+    }
+
+    .dialog__panel {
+        display: flex;
+        flex-direction: column;
+        z-index: 2;
+        width: var(--width);
+        min-width: 20rem;
+        max-width: calc(100% - var(--terra-spacing-2x-large));
+        max-height: calc(100% - var(--terra-spacing-2x-large));
+        background-color: var(--terra-panel-background-color);
+        border-radius: var(--terra-border-radius-medium);
+        box-shadow: var(--terra-shadow-x-large);
+    }
+
+    .dialog__panel:focus {
+        outline: none;
+    }
+
+    /* Ensure there's enough vertical padding for phones that don't update vh when chrome appears (e.g. iPhone) */
+    @media screen and (max-width: 420px) {
+        .dialog__panel {
+            max-height: 80vh;
+        }
+    }
+
+    .dialog--open .dialog__panel {
+        display: flex;
+        opacity: 1;
+    }
+
+    .dialog__header {
+        border-color: var(--terra-dialog-header-border-color, #dee2e6);
+        border-style: var(--terra-dialog-header-border-style, solid none);
+        border-width: var(--terra-dialog-header-border-width, 0 0 1px 0);
+        flex: 0 0 auto;
+        display: flex;
+    }
+
+    .dialog__title {
+        flex: 1 1 auto;
+        font: inherit;
+        font-size: var(--terra-font-size-large);
+        line-height: var(--terra-line-height-dense);
+        padding: var(--header-spacing);
+        margin: 0;
+    }
+
+    .dialog__header-actions {
+        flex-shrink: 0;
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: end;
+        gap: var(--terra-spacing-2x-small);
+        padding: 0 var(--header-spacing);
+    }
+
+    .dialog__header-actions terra-button,
+    .dialog__header-actions ::slotted(terra-button) {
+        flex: 0 0 auto;
+        display: flex;
+        align-items: center;
+        font-size: var(--terra-font-size-medium);
+    }
+
+    .dialog__close {
+        --terra-button-text-text-color: black;
+    }
+
+    .dialog__body {
+        flex: 1 1 auto;
+        display: block;
+        padding: var(--body-spacing);
+        overflow: auto;
+        -webkit-overflow-scrolling: touch;
+    }
+
+    .dialog__footer {
+        border-color: var(--terra-dialog-footer-border-color, #dee2e6);
+        border-style: var(--terra-dialog-footer-border-style, solid none);
+        border-width: var(--terra-dialog-footer-border-width, 1px 0 0 0);
+        flex: 0 0 auto;
+        text-align: right;
+        padding: var(--footer-spacing);
+    }
+
+    .dialog__footer ::slotted(terra-button:not(:first-of-type)) {
+        margin-inline-start: var(--terra-spacing-x-small);
+    }
+
+    .dialog:not(.dialog--has-footer) .dialog__footer {
+        display: none;
+    }
+
+    .dialog__overlay {
+        position: fixed;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
+        background-color: var(--terra-overlay-background-color);
+    }
+
+    @media (forced-colors: active) {
+        .dialog__panel {
+            border: solid 1px var(--terra-color-spacesuit-white);
+        }
+    }
+`;
+
+export {
+  dialog_styles_default
+};