@nasa-terra/components 0.0.171 → 0.0.173

package/dist/chunks/chunk.K36I4ALN.js

@@ -0,0 +1,519 @@
+import {
+  TimeSeriesController
+} from "./chunk.37I6WAMP.js";
+import {
+  time_series_styles_default
+} from "./chunk.RQEPF7OZ.js";
+import {
+  getFetchVariableTask
+} from "./chunk.JYANJSE7.js";
+import {
+  TerraPlotToolbar
+} from "./chunk.YG577JJA.js";
+import {
+  TerraPlot
+} from "./chunk.QJ45BQFQ.js";
+import {
+  extractHarmonyError,
+  formatHarmonyErrorMessage
+} from "./chunk.ESNQNQUJ.js";
+import {
+  AuthController
+} from "./chunk.DHM36JBP.js";
+import {
+  TerraLoader
+} from "./chunk.76VSG6I2.js";
+import {
+  TerraButton
+} from "./chunk.JF7QMJJ3.js";
+import {
+  formatDate
+} from "./chunk.Y4QEHGFE.js";
+import {
+  TerraIcon
+} from "./chunk.DBJRHMP4.js";
+import {
+  TerraAlert
+} from "./chunk.AQSBCRI5.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.VT5KHE7G.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/time-series/time-series.component.ts
+import { html, nothing } from "lit";
+import { property, query, state } from "lit/decorators.js";
+import { TaskStatus } from "@lit/task";
+import { cache } from "lit/directives/cache.js";
+var variableEntryIdsConverter = {
+  fromAttribute: (value) => {
+    if (!value) {
+      return [];
+    }
+    try {
+      const parsedValue = JSON.parse(value);
+      if (Array.isArray(parsedValue)) {
+        return parsedValue.map((item) => String(item).trim()).filter(Boolean);
+      }
+    } catch (e) {
+    }
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+  },
+  toAttribute: (value) => {
+    if (!(value == null ? void 0 : value.length)) {
+      return null;
+    }
+    return JSON.stringify(value);
+  }
+};
+var _timeSeriesController, _handleQuotaError, _confirmDataPointWarning, confirmDataPointWarning_fn, _cancelDataPointWarning, cancelDataPointWarning_fn, _abortDataLoad, abortDataLoad_fn, _handleComponentLeave, handleComponentLeave_fn, _getYAxisLabel, getYAxisLabel_fn, _hasNoData, hasNoData_fn, _isVariableNotFound, isVariableNotFound_fn, _getErrorMessage, getErrorMessage_fn, _handlePlotRelayout, handlePlotRelayout_fn;
+var TerraTimeSeries = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _confirmDataPointWarning);
+    __privateAdd(this, _cancelDataPointWarning);
+    /**
+     * aborts the underlying data loading task, which cancels the network request
+     */
+    __privateAdd(this, _abortDataLoad);
+    __privateAdd(this, _handleComponentLeave);
+    __privateAdd(this, _getYAxisLabel);
+    __privateAdd(this, _hasNoData);
+    __privateAdd(this, _isVariableNotFound);
+    __privateAdd(this, _getErrorMessage);
+    __privateAdd(this, _handlePlotRelayout);
+    __privateAdd(this, _timeSeriesController, void 0);
+    this.variableEntryIds = [];
+    this.showCitation = false;
+    this.disableAutoFetch = false;
+    this.mobileView = false;
+    this.hideToolbar = false;
+    this.catalogVariables = [];
+    this.quotaExceededOpen = false;
+    this.timeSeriesError = null;
+    this.showDataPointWarning = false;
+    this.estimatedDataPoints = 0;
+    this._authController = new AuthController(this);
+    this._fetchVariableTask = getFetchVariableTask(this);
+    __privateAdd(this, _handleQuotaError, (event) => {
+      const { status, code, message, context } = event.detail;
+      this.timeSeriesError = {
+        code: code || String(status),
+        message,
+        context
+      };
+      if (status === 429) {
+        this.quotaExceededOpen = true;
+      }
+    });
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.addEventListener(
+      "terra-time-series-error",
+      __privateGet(this, _handleQuotaError)
+    );
+    __privateSet(this, _timeSeriesController, new TimeSeriesController(this));
+  }
+  updated(changedProps) {
+    super.updated(changedProps);
+    const taskStatus = __privateGet(this, _timeSeriesController).task.status;
+    if (taskStatus === TaskStatus.PENDING && this.timeSeriesError) {
+      this.timeSeriesError = null;
+    }
+    if (taskStatus === TaskStatus.ERROR && !this.timeSeriesError) {
+      const taskError = __privateGet(this, _timeSeriesController).task.error;
+      if (taskError) {
+        const errorDetails = extractHarmonyError(taskError);
+        if (errorDetails.isCancellation) {
+          return;
+        }
+        this.timeSeriesError = {
+          code: errorDetails.code,
+          message: errorDetails.message,
+          context: errorDetails.context
+        };
+      }
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.removeEventListener(
+      "terra-time-series-error",
+      __privateGet(this, _handleQuotaError)
+    );
+  }
+  render() {
+    var _a, _b, _c;
+    return html`
+            <div class="plot-container" @mouseleave=${__privateMethod(this, _handleComponentLeave, handleComponentLeave_fn)}>
+                ${this.quotaExceededOpen ? html`
+                          <terra-alert
+                              variant="warning"
+                              duration="10000"
+                              open=${this.quotaExceededOpen}
+                              closable
+                              @terra-after-hide=${() => this.quotaExceededOpen = false}
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-exclamation-triangle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              You've exceeded your request quota. Please
+                              <a
+                                  href="https://disc.gsfc.nasa.gov/information/documents?title=Contact%20Us"
+                                  >contact the help desk</a
+                              >
+                              for further assistance.
+                          </terra-alert>
+                      ` : ""}
+                ${!this.hideToolbar ? cache(
+      this.catalogVariable ? html`<terra-plot-toolbar
+                                    .catalogVariable=${this.catalogVariable}
+                                    .plot=${this.plot}
+                                    .timeSeriesData=${(_a = __privateGet(this, _timeSeriesController).lastTaskValue) != null ? _a : __privateGet(this, _timeSeriesController).emptyPlotData}
+                                    .location=${this.location}
+                                    .startDate=${this.startDate}
+                                    .endDate=${this.endDate}
+                                    .cacheKey=${__privateGet(this, _timeSeriesController).getCacheKey()}
+                                    .variableEntryId=${this.variableEntryId}
+                                    .showCitation=${this.showCitation}
+                                    .mobileView=${this.mobileView}
+                                    .productLabel=${this.productLabel}
+                                >
+                                    <slot name="help-links" slot="help-links"></slot>
+                                </terra-plot-toolbar>` : html`<div class="spacer"></div>`
+    ) : nothing}
+                ${__privateMethod(this, _hasNoData, hasNoData_fn).call(this) ? html`
+                          <terra-alert
+                              class="no-data-alert"
+                              variant="warning"
+                              open
+                              closable
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-information-circle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              We couldn't find available data for your selection. Try
+                              widening your area or changing the date range to find
+                              more results.
+                          </terra-alert>
+                      ` : ""}
+                ${__privateMethod(this, _isVariableNotFound, isVariableNotFound_fn).call(this) ? html`
+                          <terra-alert
+                              class="no-data-alert"
+                              variant="danger"
+                              open
+                              closable
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-exclamation-triangle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              The selected variable was not found in the catalog
+                          </terra-alert>
+                      ` : ""}
+                ${this.timeSeriesError ? html`
+                          <terra-alert
+                              class="error-alert"
+                              variant="danger"
+                              open
+                              closable
+                              @terra-after-hide=${() => this.timeSeriesError = null}
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-exclamation-triangle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              ${__privateMethod(this, _getErrorMessage, getErrorMessage_fn).call(this, this.timeSeriesError)}
+                          </terra-alert>
+                      ` : ""}
+
+                <terra-plot
+                    exportparts="base:plot__base, plot-title:plot__title"
+                    .data=${(_b = __privateGet(this, _timeSeriesController).lastTaskValue) != null ? _b : __privateGet(this, _timeSeriesController).emptyPlotData}
+                    .layout="${{
+      xaxis: {
+        title: "Time",
+        showgrid: false,
+        zeroline: false,
+        range: (
+          // manually set the range as we may adjust it when we fetch new data as a user pans/zooms the plot
+          this.startDate && this.endDate ? [this.startDate, this.endDate] : void 0
+        )
+      },
+      yaxis: {
+        title: __privateMethod(this, _getYAxisLabel, getYAxisLabel_fn).call(this),
+        showline: false
+      },
+      title: {
+        text: this.catalogVariable && this.location ? `${this.catalogVariable.dataProductShortName}${this.catalogVariables.length > 1 ? ` (${this.catalogVariables.length} variables)` : ""} @ ${this.location}` : null
+      }
+    }}"
+                    .config=${{
+      displayModeBar: true,
+      displaylogo: false,
+      modeBarButtonsToRemove: ["toImage", "zoom2d", "resetScale2d"],
+      responsive: true
+    }}
+                    @terra-plot-relayout=${__privateMethod(this, _handlePlotRelayout, handlePlotRelayout_fn)}
+                ></terra-plot>
+            </div>
+
+            <dialog
+                ?open=${__privateGet(this, _timeSeriesController).task.status === TaskStatus.PENDING || this._fetchVariableTask.status === TaskStatus.PENDING}
+            >
+                <terra-loader indeterminate></terra-loader>
+
+                ${__privateGet(this, _timeSeriesController).task.status === TaskStatus.PENDING ? html`<p>
+                          ${this.catalogVariables.length > 1 ? `Plotting ${this.catalogVariables.length} variables\u2026` : `Plotting ${(_c = this.catalogVariable) == null ? void 0 : _c.dataFieldId}\u2026`}
+                      </p>` : html`<p>Preparing plot&hellip;</p>`}
+
+                <terra-button @click=${__privateMethod(this, _abortDataLoad, abortDataLoad_fn)}>Cancel</terra-button>
+            </dialog>
+
+            <dialog ?open=${this.showDataPointWarning} class="quota-dialog">
+                <h2>This is a large request</h2>
+
+                <p>
+                    You are requesting approximately
+                    ${this.estimatedDataPoints.toLocaleString()} data points.
+                </p>
+
+                <p>
+                    Requesting large amounts of data may cause you to reach your
+                    monthly quota limit.
+                </p>
+
+                <p>Would you still like to proceed with this request?</p>
+
+                <div class="dialog-buttons">
+                    <terra-button
+                        @click=${__privateMethod(this, _cancelDataPointWarning, cancelDataPointWarning_fn)}
+                        variant="default"
+                    >
+                        Cancel
+                    </terra-button>
+
+                    <terra-button
+                        @click=${__privateMethod(this, _confirmDataPointWarning, confirmDataPointWarning_fn)}
+                        variant="primary"
+                    >
+                        Proceed
+                    </terra-button>
+                </div>
+            </dialog>
+        `;
+  }
+};
+_timeSeriesController = new WeakMap();
+_handleQuotaError = new WeakMap();
+_confirmDataPointWarning = new WeakSet();
+confirmDataPointWarning_fn = function() {
+  __privateGet(this, _timeSeriesController).confirmDataPointWarning();
+  __privateGet(this, _timeSeriesController).task.run();
+};
+_cancelDataPointWarning = new WeakSet();
+cancelDataPointWarning_fn = function() {
+  this.showDataPointWarning = false;
+};
+_abortDataLoad = new WeakSet();
+abortDataLoad_fn = function() {
+  var _a;
+  console.log("Aborting data load");
+  (_a = __privateGet(this, _timeSeriesController).task) == null ? void 0 : _a.abort("Cancelled time series request");
+};
+_handleComponentLeave = new WeakSet();
+handleComponentLeave_fn = function(event) {
+  var _a;
+  if (this.mobileView)
+    return;
+  const relatedTarget = event.relatedTarget;
+  if (!this.contains(relatedTarget)) {
+    (_a = this.plotToolbar) == null ? void 0 : _a.closeMenu();
+  }
+};
+_getYAxisLabel = new WeakSet();
+getYAxisLabel_fn = function() {
+  var _a;
+  const units = (this.catalogVariables.length ? this.catalogVariables.map((variable) => variable.dataFieldUnits) : [(_a = this.catalogVariable) == null ? void 0 : _a.dataFieldUnits]).filter(Boolean);
+  const uniqueUnits = [...new Set(units)];
+  if (!uniqueUnits.length) {
+    return;
+  }
+  return uniqueUnits.join(", ");
+};
+_hasNoData = new WeakSet();
+hasNoData_fn = function() {
+  var _a;
+  const taskStatus = __privateGet(this, _timeSeriesController).task.status;
+  if (taskStatus !== TaskStatus.COMPLETE) {
+    return false;
+  }
+  const plotData = (_a = __privateGet(this, _timeSeriesController).lastTaskValue) != null ? _a : __privateGet(this, _timeSeriesController).emptyPlotData;
+  if (plotData.length === 0) {
+    return true;
+  }
+  const firstSeries = plotData[0];
+  const x = "x" in firstSeries ? firstSeries.x : void 0;
+  const y = "y" in firstSeries ? firstSeries.y : void 0;
+  if (!x || !y || Array.isArray(x) && x.length === 0 || Array.isArray(y) && y.length === 0) {
+    return true;
+  }
+  return false;
+};
+_isVariableNotFound = new WeakSet();
+isVariableNotFound_fn = function() {
+  const variableTaskStatus = this._fetchVariableTask.status;
+  if (variableTaskStatus !== TaskStatus.COMPLETE) {
+    return false;
+  }
+  const hasVariableRequest = Boolean(
+    this.variableEntryId || this.variableEntryIds.length || this.collection && this.variable
+  );
+  return hasVariableRequest && !this.catalogVariable;
+};
+_getErrorMessage = new WeakSet();
+getErrorMessage_fn = function(error) {
+  return formatHarmonyErrorMessage(error);
+};
+_handlePlotRelayout = new WeakSet();
+handlePlotRelayout_fn = function(e) {
+  if (this.disableAutoFetch) {
+    return;
+  }
+  let changed = false;
+  if (e.detail.xAxisMin) {
+    this.startDate = formatDate(e.detail.xAxisMin);
+    changed = true;
+  }
+  if (e.detail.xAxisMax) {
+    this.endDate = formatDate(e.detail.xAxisMax);
+    changed = true;
+  }
+  if (changed) {
+    this.dispatchEvent(
+      new CustomEvent("terra-date-range-change", {
+        detail: {
+          startDate: this.startDate,
+          endDate: this.endDate
+        },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+};
+TerraTimeSeries.styles = [component_styles_default, time_series_styles_default];
+TerraTimeSeries.dependencies = {
+  "terra-plot": TerraPlot,
+  "terra-loader": TerraLoader,
+  "terra-icon": TerraIcon,
+  "terra-button": TerraButton,
+  "terra-alert": TerraAlert,
+  "terra-plot-toolbar": TerraPlotToolbar
+};
+__decorateClass([
+  property({ attribute: "variable-entry-id", reflect: true })
+], TerraTimeSeries.prototype, "variableEntryId", 2);
+__decorateClass([
+  property({
+    attribute: "variable-entry-ids",
+    converter: variableEntryIdsConverter
+  })
+], TerraTimeSeries.prototype, "variableEntryIds", 2);
+__decorateClass([
+  property({ reflect: true })
+], TerraTimeSeries.prototype, "collection", 2);
+__decorateClass([
+  property({ reflect: true })
+], TerraTimeSeries.prototype, "variable", 2);
+__decorateClass([
+  property({
+    attribute: "start-date",
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "startDate", 2);
+__decorateClass([
+  property({
+    attribute: "end-date",
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "endDate", 2);
+__decorateClass([
+  property({
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "location", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "show-citation" })
+], TerraTimeSeries.prototype, "showCitation", 2);
+__decorateClass([
+  property({ attribute: "application-citation" })
+], TerraTimeSeries.prototype, "applicationCitation", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "disable-auto-fetch" })
+], TerraTimeSeries.prototype, "disableAutoFetch", 2);
+__decorateClass([
+  property({ attribute: "bearer-token", reflect: false })
+], TerraTimeSeries.prototype, "bearerToken", 2);
+__decorateClass([
+  property({
+    attribute: "mobile-view",
+    type: Boolean,
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "mobileView", 2);
+__decorateClass([
+  property({
+    attribute: "hide-toolbar",
+    type: Boolean,
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "hideToolbar", 2);
+__decorateClass([
+  property({
+    attribute: "product-label",
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "productLabel", 2);
+__decorateClass([
+  query("terra-plot")
+], TerraTimeSeries.prototype, "plot", 2);
+__decorateClass([
+  query("terra-plot-toolbar")
+], TerraTimeSeries.prototype, "plotToolbar", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "catalogVariable", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "catalogVariables", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "quotaExceededOpen", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "timeSeriesError", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "showDataPointWarning", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "estimatedDataPoints", 2);
+
+export {
+  TerraTimeSeries
+};

package/dist/chunks/chunk.K4VRA66U.js

@@ -0,0 +1,11 @@
+import {
+  TerraTimeAverageMap
+} from "./chunk.SUOLYC4C.js";
+
+// src/components/time-average-map/time-average-map.ts
+var time_average_map_default = TerraTimeAverageMap;
+TerraTimeAverageMap.define("terra-time-average-map");
+
+export {
+  time_average_map_default
+};

package/dist/chunks/chunk.KI6OEH42.js

@@ -0,0 +1,26 @@
+import {
+  TerraFileUpload
+} from "./chunk.BZVSSKVU.js";
+
+// src/react/file-upload/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-file-upload";
+TerraFileUpload.define("terra-file-upload");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraFileUpload,
+  react: React,
+  events: {
+    onTerraChange: "terra-change",
+    onTerraFocus: "terra-focus",
+    onTerraBlur: "terra-blur"
+  },
+  displayName: "TerraFileUpload"
+});
+var file_upload_default = reactWrapper;
+
+export {
+  file_upload_default
+};

package/dist/chunks/chunk.KO3QHRQJ.js

@@ -0,0 +1,25 @@
+import {
+  TerraIcon
+} from "./chunk.DBJRHMP4.js";
+
+// src/react/icon/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-icon";
+TerraIcon.define("terra-icon");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraIcon,
+  react: React,
+  events: {
+    onTerraLoad: "terra-load",
+    onTerraError: "terra-error"
+  },
+  displayName: "TerraIcon"
+});
+var icon_default = reactWrapper;
+
+export {
+  icon_default
+};

package/dist/chunks/chunk.KPCSQEKP.js

@@ -0,0 +1,11 @@
+import {
+  TerraSpatialPicker
+} from "./chunk.II2UMQ6I.js";
+
+// src/components/spatial-picker/spatial-picker.ts
+var spatial_picker_default = TerraSpatialPicker;
+TerraSpatialPicker.define("terra-spatial-picker");
+
+export {
+  spatial_picker_default
+};

package/dist/chunks/chunk.L3NM2AUU.js

@@ -0,0 +1,29 @@
+import {
+  TerraInput
+} from "./chunk.IFX2N2F2.js";
+
+// src/react/input/index.ts
+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
+};