@nasa-terra/components 0.0.182 → 0.0.184

package/cdn/chunks/chunk.CSHS47RP.js

@@ -0,0 +1,132 @@
+import {
+  tab_styles_default
+} from "./chunk.57ZIC75S.js";
+import {
+  TerraIcon
+} from "./chunk.UZMGM6H5.js";
+import {
+  e
+} from "./chunk.KGXAA5I2.js";
+import {
+  watch
+} from "./chunk.MPVZOQYA.js";
+import {
+  TerraElement,
+  component_styles_default,
+  e as e2,
+  n
+} from "./chunk.IFRWRZDM.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/tab/tab.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var id = 0;
+var TerraTab = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.attrId = ++id;
+    this.componentId = `terra-tab-${this.attrId}`;
+    this.panel = "";
+    this.active = false;
+    this.closable = false;
+    this.disabled = false;
+    this.size = "large";
+    this.tabIndex = 0;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.setAttribute("role", "tab");
+  }
+  handleCloseClick(event) {
+    event.stopPropagation();
+    this.emit("terra-close");
+  }
+  handleActiveChange() {
+    this.setAttribute("aria-selected", this.active ? "true" : "false");
+  }
+  handleDisabledChange() {
+    this.setAttribute("aria-disabled", this.disabled ? "true" : "false");
+    if (this.disabled && !this.active) {
+      this.tabIndex = -1;
+    } else {
+      this.tabIndex = 0;
+    }
+  }
+  render() {
+    this.id = this.id.length > 0 ? this.id : this.componentId;
+    return b`
+            <div
+                part="base"
+                class=${e({
+      tab: true,
+      "tab--active": this.active,
+      "tab--closable": this.closable,
+      "tab--disabled": this.disabled,
+      "tab--large": this.size === "large",
+      "tab--small": this.size === "small"
+    })}
+            >
+                <slot></slot>
+                ${this.closable ? b`
+                          <button
+                              part="close-button"
+                              class="tab__close-button"
+                              @click=${this.handleCloseClick}
+                              tabindex="-1"
+                              aria-label="Close tab"
+                              type="button"
+                          >
+                              <terra-icon
+                                  name="x-mark"
+                                  library="heroicons"
+                                  font-size="1rem"
+                              ></terra-icon>
+                          </button>
+                      ` : ""}
+            </div>
+        `;
+  }
+};
+TerraTab.styles = [component_styles_default, tab_styles_default];
+TerraTab.dependencies = { "terra-icon": TerraIcon };
+__decorateClass([
+  e2(".tab")
+], TerraTab.prototype, "tab", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraTab.prototype, "panel", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraTab.prototype, "active", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraTab.prototype, "closable", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraTab.prototype, "disabled", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraTab.prototype, "size", 2);
+__decorateClass([
+  n({ type: Number, reflect: true })
+], TerraTab.prototype, "tabIndex", 2);
+__decorateClass([
+  watch("active")
+], TerraTab.prototype, "handleActiveChange", 1);
+__decorateClass([
+  watch("disabled")
+], TerraTab.prototype, "handleDisabledChange", 1);
+
+export {
+  TerraTab
+};

package/cdn/chunks/chunk.CTSWDN2G.js

@@ -0,0 +1,29 @@
+import {
+  TerraBadge
+} from "./chunk.SOI2X32A.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/badge/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "terra-badge";
+TerraBadge.define("terra-badge");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraBadge,
+  react: React,
+  events: {},
+  displayName: "TerraBadge"
+});
+var badge_default = reactWrapper;
+
+export {
+  badge_default
+};

package/cdn/chunks/chunk.CUFMBAD2.js

@@ -0,0 +1,19 @@
+import {
+  TerraToggle
+} from "./chunk.ATXIS4CA.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/toggle/toggle.ts
+init_dirname();
+init_buffer();
+init_process();
+var toggle_default = TerraToggle;
+TerraToggle.define("terra-toggle");
+
+export {
+  toggle_default
+};

package/cdn/chunks/chunk.CZTP7RAP.js

@@ -0,0 +1,41 @@
+import {
+  TerraSelect
+} from "./chunk.O2NJI5V4.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/select/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-select";
+TerraSelect.define("terra-select");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraSelect,
+  react: React,
+  events: {
+    onTerraChange: "terra-change",
+    onTerraClear: "terra-clear",
+    onTerraInput: "terra-input",
+    onTerraFocus: "terra-focus",
+    onTerraBlur: "terra-blur",
+    onTerraShow: "terra-show",
+    onTerraAfterShow: "terra-after-show",
+    onTerraHide: "terra-hide",
+    onTerraAfterHide: "terra-after-hide",
+    onTerraInvalid: "terra-invalid"
+  },
+  displayName: "TerraSelect"
+});
+var select_default = reactWrapper;
+
+export {
+  select_default
+};

package/cdn/chunks/chunk.D5BXM7U5.js

@@ -0,0 +1,83 @@
+import {
+  site_header_styles_default
+} from "./chunk.PMD3UQTU.js";
+import {
+  TerraIcon
+} from "./chunk.UZMGM6H5.js";
+import {
+  HasSlotController
+} from "./chunk.PACUQ7ID.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n
+} from "./chunk.IFRWRZDM.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/site-header/site-header.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraSiteHeader = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(
+      this,
+      "title",
+      "center",
+      "right"
+    );
+    this.siteName = "";
+  }
+  render() {
+    const hasTitleSlot = this.hasSlotController.test("title");
+    const hasRightSlot = this.hasSlotController.test("right");
+    return b`
+            <header part="base" class="site-header">
+                <div class="site-header__left">
+                    <div part="logo" class="site-header__logo">
+                        <terra-icon name="nasa-logo" font-size="4rem"></terra-icon>
+                    </div>
+                    <div part="title" class="site-header__title">
+                        ${hasTitleSlot ? b`<slot name="title"></slot>` : b`<span>${this.siteName}</span>`}
+                    </div>
+                </div>
+                <div part="center" class="site-header__center">
+                    <slot name="center"></slot>
+                </div>
+                <div part="right" class="site-header__right">
+                    ${hasRightSlot ? b`<slot name="right"></slot>` : b`
+                              <button
+                                  class="site-header__search"
+                                  type="button"
+                                  title="Search"
+                                  aria-label="Search"
+                              >
+                                  <terra-icon
+                                      name="magnifying-glass"
+                                      library="heroicons"
+                                  ></terra-icon>
+                              </button>
+                          `}
+                </div>
+            </header>
+        `;
+  }
+};
+TerraSiteHeader.styles = [component_styles_default, site_header_styles_default];
+TerraSiteHeader.dependencies = { "terra-icon": TerraIcon };
+__decorateClass([
+  n({ attribute: "site-name" })
+], TerraSiteHeader.prototype, "siteName", 2);
+
+export {
+  TerraSiteHeader
+};

package/cdn/chunks/chunk.DIP23AEI.js

@@ -0,0 +1,37 @@
+import {
+  TerraInput
+} from "./chunk.6YQGTQFL.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/input/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-input";
+TerraInput.define("terra-input");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraInput,
+  react: React,
+  events: {
+    onTerraInput: "terra-input",
+    onTerraChange: "terra-change",
+    onTerraFocus: "terra-focus",
+    onTerraBlur: "terra-blur",
+    onTerraInvalid: "terra-invalid",
+    onTerraClear: "terra-clear"
+  },
+  displayName: "TerraInput"
+});
+var input_default = reactWrapper;
+
+export {
+  input_default
+};

package/cdn/chunks/chunk.DPIORTI4.js

@@ -0,0 +1,285 @@
+import {
+  MapController
+} from "./chunk.S3NVOH7F.js";
+import {
+  MapService
+} from "./chunk.MVC5FVKI.js";
+import {
+  map_styles_default
+} from "./chunk.XPZE3KH3.js";
+import {
+  h
+} from "./chunk.ASJLND3B.js";
+import {
+  o
+} from "./chunk.IL42CKDQ.js";
+import {
+  watch
+} from "./chunk.MPVZOQYA.js";
+import {
+  TerraElement,
+  component_styles_default,
+  e,
+  n,
+  r
+} from "./chunk.IFRWRZDM.js";
+import {
+  A,
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/map/map.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var _service;
+var TerraMap = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.minZoom = 0;
+    this.maxZoom = 23;
+    this.zoom = 1;
+    this.hasNavigation = false;
+    this.showMouseCoordinates = false;
+    this.hasShapeSelector = false;
+    this.showGraticule = false;
+    this.showBoundingBoxSelection = false;
+    this.showPointSelection = false;
+    this.showPolygonSelection = false;
+    this.showCircleSelection = false;
+    this.staticMode = false;
+    this.noWorldWrap = false;
+    this.spatialConstraints = "-180, -90, 180, 90";
+    this.fitToValue = false;
+    this.cursorCoordinates = [0, 0];
+    this.shapeLoading = false;
+    __privateAdd(this, _service, void 0);
+    this._mapController = new MapController(this);
+  }
+  zoomChanged() {
+    var _a;
+    (_a = __privateGet(this, _service)) == null ? void 0 : _a.setZoom(this.zoom);
+  }
+  set hasCoordTracker(value) {
+    console.warn(
+      'The "has-coord-tracker" property is deprecated. Please use "show-mouse-coordinates" instead.'
+    );
+    this.showMouseCoordinates = value;
+  }
+  get hasCoordTracker() {
+    return this.showMouseCoordinates;
+  }
+  showGraticuleChanged() {
+    var _a;
+    (_a = __privateGet(this, _service)) == null ? void 0 : _a.toggleLayerVisibility("graticule", this.showGraticule);
+  }
+  set hideBoundingBoxSelection(value) {
+    console.warn(
+      'The "hide-bounding-box-selection" property is deprecated. Please use "show-bounding-box-selection" instead.'
+    );
+    this.showBoundingBoxSelection = !value;
+  }
+  get hideBoundingBoxSelection() {
+    return !this.showBoundingBoxSelection;
+  }
+  set hidePointSelection(value) {
+    console.warn(
+      'The "hide-point-selection" property is deprecated. Please use "show-point-selection" instead.'
+    );
+    this.showPointSelection = !value;
+  }
+  get hidePointSelection() {
+    return !this.showPointSelection;
+  }
+  drawButtonSelectionChanged() {
+    var _a;
+    (_a = __privateGet(this, _service)) == null ? void 0 : _a.updateDrawToolbarVisibility({
+      showBoundingBoxSelection: this.showBoundingBoxSelection,
+      showPointSelection: this.showPointSelection,
+      showPolygonSelection: this.showPolygonSelection,
+      showCircleSelection: this.showCircleSelection
+    });
+  }
+  valueChanged(_oldValue, newValue) {
+    var _a;
+    (_a = __privateGet(this, _service)) == null ? void 0 : _a.setValue(newValue);
+  }
+  async firstUpdated() {
+    __privateSet(this, _service, new MapService(this.mapElement, {
+      zoom: this.zoom,
+      minZoom: this.minZoom,
+      maxZoom: this.maxZoom,
+      showGraticule: this.showGraticule,
+      showBoundingBoxSelection: this.showBoundingBoxSelection,
+      showPointSelection: this.showPointSelection,
+      showPolygonSelection: this.showPolygonSelection,
+      showCircleSelection: this.showCircleSelection,
+      noWorldWrap: this.noWorldWrap,
+      value: this.value,
+      fitToValue: this.fitToValue,
+      onMouseMove: (coordinate) => {
+        this.cursorCoordinates = coordinate;
+      },
+      onDraw: (detail) => {
+        this.emit("terra-map-change", { detail });
+      },
+      onShapeLoading: (loading) => {
+        this.shapeLoading = loading;
+      }
+    }));
+  }
+  selectTemplate() {
+    var _a;
+    return b`
+            <select
+                class="map__select form-control"
+                @change=${(e2) => {
+      var _a2;
+      return (_a2 = __privateGet(this, _service)) == null ? void 0 : _a2.handleShapeSelect(e2);
+    }}
+            >
+                <option value="">Select a Shape...</option>
+
+                ${h(
+      o((_a = this.shapes) == null ? void 0 : _a.categories, (category) => {
+        return b`<optgroup label="${category.title}">
+                            ${category.shapes.map((shape) => {
+          return b`
+                                    <option
+                                        value="shape=${shape.shapefileID}/${shape.shapeID}"
+                                    >
+                                        ${shape.name}
+                                    </option>
+                                `;
+        })}
+                        </optgroup> `;
+      })
+    )}
+            </select>
+        `;
+  }
+  render() {
+    return b`
+            ${this.hasShapeSelector ? this.selectTemplate() : A}
+            <div part="map" class=${`map ${this.staticMode ? "static" : ""}`}>
+                ${this.showMouseCoordinates ? b`
+                          <div id="mouse-info">
+                              <div>
+                                  <strong
+                                      >lat: ${this.cursorCoordinates[1].toFixed(2)},
+                                      lng:
+                                      ${this.cursorCoordinates[0].toFixed(2)}</strong
+                                  >
+                              </div>
+                          </div>
+                      ` : A}
+                ${this.shapeLoading ? b`
+                          <div class="map__loading-overlay">
+                              <div class="map__spinner"></div>
+                          </div>
+                      ` : A}
+            </div>
+        `;
+  }
+};
+_service = new WeakMap();
+TerraMap.styles = [component_styles_default, map_styles_default];
+__decorateClass([
+  n({ attribute: "min-zoom", type: Number })
+], TerraMap.prototype, "minZoom", 2);
+__decorateClass([
+  n({ attribute: "max-zoom", type: Number })
+], TerraMap.prototype, "maxZoom", 2);
+__decorateClass([
+  n({ type: Number })
+], TerraMap.prototype, "zoom", 2);
+__decorateClass([
+  watch("zoom")
+], TerraMap.prototype, "zoomChanged", 1);
+__decorateClass([
+  n({ attribute: "has-navigation", type: Boolean })
+], TerraMap.prototype, "hasNavigation", 2);
+__decorateClass([
+  n({ attribute: "show-mouse-coordinates", type: Boolean })
+], TerraMap.prototype, "showMouseCoordinates", 2);
+__decorateClass([
+  n({ attribute: "has-coord-tracker", type: Boolean })
+], TerraMap.prototype, "hasCoordTracker", 1);
+__decorateClass([
+  n({ attribute: "has-shape-selector", type: Boolean })
+], TerraMap.prototype, "hasShapeSelector", 2);
+__decorateClass([
+  n({ attribute: "show-graticule", type: Boolean })
+], TerraMap.prototype, "showGraticule", 2);
+__decorateClass([
+  watch("showGraticule")
+], TerraMap.prototype, "showGraticuleChanged", 1);
+__decorateClass([
+  n({ attribute: "show-bounding-box-selection", type: Boolean })
+], TerraMap.prototype, "showBoundingBoxSelection", 2);
+__decorateClass([
+  n({ attribute: "hide-bounding-box-selection", type: Boolean })
+], TerraMap.prototype, "hideBoundingBoxSelection", 1);
+__decorateClass([
+  n({ attribute: "show-point-selection", type: Boolean })
+], TerraMap.prototype, "showPointSelection", 2);
+__decorateClass([
+  n({ attribute: "hide-point-selection", type: Boolean })
+], TerraMap.prototype, "hidePointSelection", 1);
+__decorateClass([
+  n({ attribute: "show-polygon-selection", type: Boolean })
+], TerraMap.prototype, "showPolygonSelection", 2);
+__decorateClass([
+  n({ attribute: "show-circle-selection", type: Boolean })
+], TerraMap.prototype, "showCircleSelection", 2);
+__decorateClass([
+  n({ type: Boolean })
+], TerraMap.prototype, "staticMode", 2);
+__decorateClass([
+  n({ attribute: "no-world-wrap", type: Boolean })
+], TerraMap.prototype, "noWorldWrap", 2);
+__decorateClass([
+  n({ attribute: "spatial-constraints" })
+], TerraMap.prototype, "spatialConstraints", 2);
+__decorateClass([
+  n({ type: String })
+], TerraMap.prototype, "value", 2);
+__decorateClass([
+  n({ type: Boolean, attribute: "fit-to-feature" })
+], TerraMap.prototype, "fitToValue", 2);
+__decorateClass([
+  e('[part="map"]')
+], TerraMap.prototype, "mapElement", 2);
+__decorateClass([
+  r()
+], TerraMap.prototype, "cursorCoordinates", 2);
+__decorateClass([
+  r()
+], TerraMap.prototype, "shapeLoading", 2);
+__decorateClass([
+  watch([
+    "showBoundingBoxSelection",
+    "showPointSelection",
+    "showPolygonSelection",
+    "showCircleSelection"
+  ])
+], TerraMap.prototype, "drawButtonSelectionChanged", 1);
+__decorateClass([
+  watch("value")
+], TerraMap.prototype, "valueChanged", 1);
+__decorateClass([
+  r()
+], TerraMap.prototype, "shapes", 2);
+
+export {
+  TerraMap
+};