@nasa-terra/components 0.0.171 → 0.0.172

package/dist/chunks/chunk.JSHDVZDN.js

@@ -0,0 +1,11 @@
+import {
+  TerraTimeAverageMap
+} from "./chunk.IIIMSS4Y.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.JXNXBQTI.js

@@ -0,0 +1,11 @@
+import {
+  TerraIcon
+} from "./chunk.TJXQEGVJ.js";
+
+// src/components/icon/icon.ts
+var icon_default = TerraIcon;
+TerraIcon.define("terra-icon");
+
+export {
+  icon_default
+};

package/dist/chunks/chunk.JYANJSE7.js

@@ -0,0 +1,97 @@
+import {
+  getVariableEntryIds
+} from "./chunk.4EAOYZ4Y.js";
+import {
+  GiovanniVariableCatalog
+} from "./chunk.MZ4FDVFI.js";
+
+// src/metadata-catalog/tasks.ts
+import { Task } from "@lit/task";
+var variableCache = /* @__PURE__ */ new Map();
+var pendingRequests = /* @__PURE__ */ new Map();
+function sameVariableIds(a, b) {
+  if (!a || a.length !== b.length) {
+    return false;
+  }
+  return a.every((variable, index) => variable.dataFieldId === b[index].dataFieldId);
+}
+function setHostPropertiesFromVariable(host, variables) {
+  var _a, _b, _c, _d;
+  const primaryVariable = variables[0];
+  if (!primaryVariable) {
+    return;
+  }
+  host.startDate = (_b = host.startDate) != null ? _b : (_a = primaryVariable.exampleInitialStartDate) == null ? void 0 : _a.toISOString();
+  host.endDate = (_d = host.endDate) != null ? _d : (_c = primaryVariable.exampleInitialEndDate) == null ? void 0 : _c.toISOString();
+  host.catalogVariable = primaryVariable;
+  if (!sameVariableIds(host.catalogVariables, variables)) {
+    host.catalogVariables = [...variables];
+  }
+  host.variableEntryId = primaryVariable.dataFieldId;
+}
+function getFetchVariableTask(host, autoRun = true) {
+  const catalog = new GiovanniVariableCatalog();
+  return new Task(host, {
+    task: async (_args) => {
+      const variableEntryIds = getVariableEntryIds(host);
+      console.debug("Fetch variables ", variableEntryIds);
+      if (!variableEntryIds.length) {
+        return;
+      }
+      const variables = (await Promise.all(
+        variableEntryIds.map(async (variableEntryId) => {
+          if (variableCache.has(variableEntryId)) {
+            console.debug("Using cached variable ", variableEntryId);
+            return variableCache.get(variableEntryId);
+          }
+          if (pendingRequests.has(variableEntryId)) {
+            console.debug(
+              "Waiting for pending request for variable ",
+              variableEntryId
+            );
+            const pendingVariable = await pendingRequests.get(variableEntryId);
+            return pendingVariable;
+          }
+          const requestPromise = catalog.getVariable(variableEntryId).catch((error) => {
+            console.warn(
+              "Failed to fetch variable",
+              variableEntryId,
+              error
+            );
+            return null;
+          });
+          pendingRequests.set(variableEntryId, requestPromise);
+          try {
+            const variable = await requestPromise;
+            console.debug("Found variable ", variable);
+            if (!variable) {
+              return null;
+            }
+            variableCache.set(variableEntryId, variable);
+            return variable;
+          } finally {
+            pendingRequests.delete(variableEntryId);
+          }
+        })
+      )).filter(Boolean);
+      if (!variables.length) {
+        return;
+      }
+      setHostPropertiesFromVariable(host, variables);
+    },
+    args: () => {
+      var _a;
+      return [
+        host.variableEntryId,
+        (_a = host.variableEntryIds) == null ? void 0 : _a.join("|"),
+        host.collection,
+        host.variable
+      ];
+    },
+    autoRun
+  });
+}
+
+export {
+  getFetchVariableTask
+};

package/dist/chunks/chunk.JYGQIFKK.js

@@ -0,0 +1,28 @@
+import {
+  TerraCheckbox
+} from "./chunk.VXC7RH5L.js";
+
+// src/react/checkbox/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-checkbox";
+TerraCheckbox.define("terra-checkbox");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraCheckbox,
+  react: React,
+  events: {
+    onTerraBlur: "terra-blur",
+    onTerraChange: "terra-change",
+    onTerraFocus: "terra-focus",
+    onTerraInput: "terra-input",
+    onTerraInvalid: "terra-invalid"
+  },
+  displayName: "TerraCheckbox"
+});
+var checkbox_default = reactWrapper;
+
+export {
+  checkbox_default
+};

package/dist/chunks/chunk.JZCDJ4LE.js

@@ -0,0 +1,21 @@
+import {
+  TerraPlotToolbar
+} from "./chunk.Q6LIQNS5.js";
+
+// src/react/plot-toolbar/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "terra-plot-toolbar";
+TerraPlotToolbar.define("terra-plot-toolbar");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraPlotToolbar,
+  react: React,
+  events: {},
+  displayName: "TerraPlotToolbar"
+});
+var plot_toolbar_default = reactWrapper;
+
+export {
+  plot_toolbar_default
+};

package/dist/chunks/chunk.KN46QEMU.js

@@ -0,0 +1,61 @@
+import {
+  tab_panel_styles_default
+} from "./chunk.GLYX6PG2.js";
+import {
+  watch
+} from "./chunk.NWXJOH5T.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.H7RPIHW6.js";
+import {
+  __decorateClass
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/tab-panel/tab-panel.component.ts
+import { classMap } from "lit/directives/class-map.js";
+import { html } from "lit";
+import { property } from "lit/decorators.js";
+var id = 0;
+var TerraTabPanel = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.attrId = ++id;
+    this.componentId = `terra-tab-panel-${this.attrId}`;
+    this.name = "";
+    this.active = false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.id = this.id.length > 0 ? this.id : this.componentId;
+    this.setAttribute("role", "tabpanel");
+  }
+  handleActiveChange() {
+    this.setAttribute("aria-hidden", this.active ? "false" : "true");
+  }
+  render() {
+    return html`
+            <slot
+                part="base"
+                class=${classMap({
+      "tab-panel": true,
+      "tab-panel--active": this.active
+    })}
+            ></slot>
+        `;
+  }
+};
+TerraTabPanel.styles = [component_styles_default, tab_panel_styles_default];
+__decorateClass([
+  property({ reflect: true })
+], TerraTabPanel.prototype, "name", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], TerraTabPanel.prototype, "active", 2);
+__decorateClass([
+  watch("active")
+], TerraTabPanel.prototype, "handleActiveChange", 1);
+
+export {
+  TerraTabPanel
+};

package/dist/chunks/chunk.KNYC3J2M.js

@@ -0,0 +1,11 @@
+import {
+  TerraSelect
+} from "./chunk.JLVOZ6YV.js";
+
+// src/components/select/select.ts
+var select_default = TerraSelect;
+TerraSelect.define("terra-select");
+
+export {
+  select_default
+};

package/dist/chunks/chunk.KUV4DHH5.js

@@ -0,0 +1,31 @@
+import {
+  TerraDataGrid
+} from "./chunk.YQG36G33.js";
+
+// src/react/data-grid/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-data-grid";
+TerraDataGrid.define("terra-data-grid");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraDataGrid,
+  react: React,
+  events: {
+    onTerraGridReady: "terra-grid-ready",
+    onTerraSelectionChanged: "terra-selection-changed",
+    onTerraSortChanged: "terra-sort-changed",
+    onTerraFilterChanged: "terra-filter-changed",
+    onTerraRowClicked: "terra-row-clicked",
+    onTerraRowDoubleClicked: "terra-row-double-clicked",
+    onTerraCellClicked: "terra-cell-clicked",
+    onTerraCellValueChanged: "terra-cell-value-changed"
+  },
+  displayName: "TerraDataGrid"
+});
+var data_grid_default = reactWrapper;
+
+export {
+  data_grid_default
+};

package/dist/chunks/chunk.KXUWKUKJ.js

@@ -0,0 +1,11 @@
+import {
+  TerraCheckbox
+} from "./chunk.VXC7RH5L.js";
+
+// src/components/checkbox/checkbox.ts
+var checkbox_default = TerraCheckbox;
+TerraCheckbox.define("terra-checkbox");
+
+export {
+  checkbox_default
+};

package/dist/chunks/chunk.L2OI4UX3.js

@@ -0,0 +1,11 @@
+import {
+  TerraStepperStep
+} from "./chunk.7B4RGASR.js";
+
+// src/components/stepper-step/stepper-step.ts
+var stepper_step_default = TerraStepperStep;
+TerraStepperStep.define("terra-stepper-step");
+
+export {
+  stepper_step_default
+};

package/dist/chunks/chunk.LH4IBUIP.js

@@ -0,0 +1,11 @@
+import {
+  TerraDataGrid
+} from "./chunk.YQG36G33.js";
+
+// src/components/data-grid/data-grid.ts
+var data_grid_default = TerraDataGrid;
+TerraDataGrid.define("terra-data-grid");
+
+export {
+  data_grid_default
+};

package/dist/chunks/chunk.LI6NBHLF.js

@@ -0,0 +1,277 @@
+import {
+  data_subsetter_history_styles_default
+} from "./chunk.XJRDI2TX.js";
+import {
+  TerraDataSubsetter
+} from "./chunk.FDZA4S2G.js";
+import {
+  TerraDialog
+} from "./chunk.HZWA5KX4.js";
+import {
+  DataSubsetterHistoryController
+} from "./chunk.WVJDTT7W.js";
+import {
+  AuthController
+} from "./chunk.DHM36JBP.js";
+import {
+  TerraIcon
+} from "./chunk.TJXQEGVJ.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.H7RPIHW6.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/data-subsetter-history/data-subsetter-history.component.ts
+import { property, query, state } from "lit/decorators.js";
+import { html, nothing } from "lit";
+var _controller, _renderHistoryItems, renderHistoryItems_fn, _renderSubsetterHistoryItem, renderSubsetterHistoryItem_fn, _handleHistoryItemClick, handleHistoryItemClick_fn, _parseLabelsAsJson, parseLabelsAsJson_fn;
+var TerraDataSubsetterHistory = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _renderHistoryItems);
+    __privateAdd(this, _renderSubsetterHistoryItem);
+    __privateAdd(this, _handleHistoryItemClick);
+    __privateAdd(this, _parseLabelsAsJson);
+    this.label = "History";
+    this.alwaysShow = true;
+    this.collapsed = true;
+    this.hideCancelled = true;
+    __privateAdd(this, _controller, new DataSubsetterHistoryController(this));
+    this._authController = new AuthController(this);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.addController(__privateGet(this, _controller));
+  }
+  toggleCollapsed() {
+    this.collapsed = !this.collapsed;
+  }
+  render() {
+    const jobs = __privateGet(this, _controller).jobs;
+    const hasJobs = jobs && jobs.jobs.length > 0;
+    if (!hasJobs) {
+      return nothing;
+    }
+    return html`
+            <div class="${this.collapsed ? "collapsed" : ""}">
+                <div class="history-header" @click=${this.toggleCollapsed}>
+                    <span>${this.label}</span>
+                </div>
+
+                <div class="history-panel">
+                    ${hasJobs ? html`
+                              <div class="history-link-row">
+                                  <label>
+                                      <input
+                                          type="checkbox"
+                                          .checked=${this.hideCancelled}
+                                          @change=${(e) => {
+      this.hideCancelled = e.target.checked;
+    }}
+                                      />
+                                      Hide Cancelled
+                                  </label>
+
+                                  <a
+                                      href="https://harmony.earthdata.nasa.gov/workflow-ui"
+                                      target="_blank"
+                                      rel="noopener noreferrer"
+                                      class="history-link"
+                                  >
+                                      View all
+                                      <terra-icon
+                                          name="outline-arrow-top-right-on-square"
+                                          library="heroicons"
+                                          size="32px"
+                                      ></terra-icon>
+                                  </a>
+                              </div>
+                          ` : nothing}
+
+                    <div class="history-list">
+                        ${jobs ? hasJobs ? __privateMethod(this, _renderHistoryItems, renderHistoryItems_fn).call(this, jobs) : html`<div class="history-alert-message">
+                                      You haven't made any requests yet.<br />
+                                      Get started by
+                                      <a
+                                          href="#"
+                                          class="history-alert-link"
+                                          @click=${(e) => {
+      var _a;
+      e.preventDefault();
+      this.selectedJob = void 0;
+      this.selectedCollectionEntryId = void 0;
+      (_a = this.dialog) == null ? void 0 : _a.show();
+    }}
+                                      >
+                                          creating your first request!</a
+                                      >.
+                                  </div>` : html`<div class="history-alert-message">
+                                  Retrieving your requests....
+                              </div>`}
+                    </div>
+                </div>
+            </div>
+
+            <terra-data-subsetter
+                .jobId=${this.selectedJob}
+                .collectionEntryId=${this.selectedCollectionEntryId}
+                .bearerToken=${this.bearerToken}
+                is-history-view
+                dialog="history-dialog"
+                part="subsetter"
+            ></terra-data-subsetter>
+        `;
+  }
+};
+_controller = new WeakMap();
+_renderHistoryItems = new WeakSet();
+renderHistoryItems_fn = function(subsetJobs) {
+  const filteredJobs = subsetJobs.jobs.slice().filter((job) => {
+    if (this.hideCancelled) {
+      return job.status !== "canceled" /* CANCELED */;
+    }
+    return true;
+  }).sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+  if (!filteredJobs.length) {
+    return html`
+                <div class="history-alert-message">
+                    There are no active requests to show.<br />
+                    If you'd like, you can
+                    <a
+                        href="#"
+                        class="history-alert-link"
+                        @click=${(e) => {
+      var _a;
+      e.preventDefault();
+      this.selectedJob = void 0;
+      this.selectedCollectionEntryId = void 0;
+      (_a = this.dialog) == null ? void 0 : _a.show();
+    }}
+                    >
+                        create a new request.</a
+                    >
+                </div>
+            `;
+  }
+  return filteredJobs.map((job) => {
+    let fillColor = "#0066cc";
+    if (job.status === "successful" /* SUCCESSFUL */ || job.status === "complete_with_errors" /* COMPLETE_WITH_ERRORS */ || job.status === "running_with_errors" /* RUNNING_WITH_ERRORS */) {
+      fillColor = "#28a745";
+    } else if (job.status === "failed" /* FAILED */) {
+      fillColor = "#dc3545";
+    } else if (job.status === "canceled" /* CANCELED */) {
+      fillColor = "#ffc107";
+    }
+    const progressLabel = job.status === "failed" /* FAILED */ || job.status === "canceled" /* CANCELED */ ? job.status : `${job.progress}%`;
+    const progress = job.status === "failed" /* FAILED */ || job.status === "canceled" /* CANCELED */ ? 100 : job.progress;
+    const parsedLabels = __privateMethod(this, _parseLabelsAsJson, parseLabelsAsJson_fn).call(this, job.labels || []);
+    return html`
+                <div
+                    class="history-item"
+                    @click=${__privateMethod(this, _handleHistoryItemClick, handleHistoryItemClick_fn).bind(this, job)}
+                >
+                    <div class="item-header">
+                        <div class="item-title">
+                            ${__privateMethod(this, _renderSubsetterHistoryItem, renderSubsetterHistoryItem_fn).call(this, job, parsedLabels)}
+                        </div>
+                    </div>
+
+                    <div class="progress-bar">
+                        <div
+                            class="progress-fill"
+                            style="width: ${progress}%; background-color: ${fillColor}"
+                        >
+                            ${progressLabel}
+                        </div>
+                    </div>
+                </div>
+            `;
+  });
+};
+_renderSubsetterHistoryItem = new WeakSet();
+renderSubsetterHistoryItem_fn = function(job, labels) {
+  var _a;
+  return html`
+            <div class="subsetter-history-item">
+                <div class="history-item-title">
+                    ${(_a = labels["collection-entry-id"]) != null ? _a : job.jobID}
+                </div>
+                <div>${new Date(job.createdAt).toLocaleString()}</div>
+            </div>
+        `;
+};
+_handleHistoryItemClick = new WeakSet();
+handleHistoryItemClick_fn = function(job) {
+  var _a;
+  const parsedLabels = __privateMethod(this, _parseLabelsAsJson, parseLabelsAsJson_fn).call(this, job.labels || []);
+  this.selectedJob = job.jobID;
+  this.selectedCollectionEntryId = parsedLabels["collection-entry-id"];
+  (_a = this.subsetter) == null ? void 0 : _a.showDialog();
+};
+_parseLabelsAsJson = new WeakSet();
+parseLabelsAsJson_fn = function(labels) {
+  try {
+    return Object.fromEntries(
+      labels.map((line) => {
+        const [key, ...rest] = line.split(":");
+        const valueRaw = rest.join(":").trim();
+        let value = valueRaw;
+        if (valueRaw.startsWith("{") || valueRaw.startsWith("[")) {
+          try {
+            value = JSON.parse(valueRaw);
+          } catch (e) {
+            value = valueRaw;
+          }
+        }
+        return [key.trim(), value];
+      })
+    );
+  } catch (e) {
+    return {};
+  }
+};
+TerraDataSubsetterHistory.dependencies = {
+  "terra-icon": TerraIcon,
+  "terra-data-subsetter": TerraDataSubsetter,
+  "terra-dialog": TerraDialog
+};
+TerraDataSubsetterHistory.styles = [component_styles_default, data_subsetter_history_styles_default];
+__decorateClass([
+  property()
+], TerraDataSubsetterHistory.prototype, "label", 2);
+__decorateClass([
+  property({ attribute: "bearer-token" })
+], TerraDataSubsetterHistory.prototype, "bearerToken", 2);
+__decorateClass([
+  property({ attribute: "always-show", type: Boolean })
+], TerraDataSubsetterHistory.prototype, "alwaysShow", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "collapsed", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "selectedJob", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "selectedCollectionEntryId", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "hideCancelled", 2);
+__decorateClass([
+  query('[part~="dialog"]')
+], TerraDataSubsetterHistory.prototype, "dialog", 2);
+__decorateClass([
+  query('[part~="subsetter"]')
+], TerraDataSubsetterHistory.prototype, "subsetter", 2);
+
+export {
+  TerraDataSubsetterHistory
+};

package/dist/chunks/chunk.LJVNFO4A.js

@@ -0,0 +1,86 @@
+import {
+  progress_bar_styles_default
+} from "./chunk.OVH5G3RJ.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.H7RPIHW6.js";
+import {
+  __decorateClass
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/progress-bar/progress-bar.component.ts
+import { classMap } from "lit/directives/class-map.js";
+import { html } from "lit";
+import { ifDefined } from "lit/directives/if-defined.js";
+import { property } from "lit/decorators.js";
+import { styleMap } from "lit/directives/style-map.js";
+var TerraProgressBar = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.value = 0;
+    this.indeterminate = false;
+    this.label = "";
+    this.variant = "primary";
+    this.title = "";
+  }
+  // make reactive to pass through
+  render() {
+    const isRtl = getComputedStyle(this).direction === "rtl";
+    return html`
+            <div
+                part="base"
+                class=${classMap({
+      "progress-bar": true,
+      "progress-bar--indeterminate": this.indeterminate,
+      "progress-bar--rtl": isRtl,
+      "progress-bar--default": this.variant === "default",
+      "progress-bar--primary": this.variant === "primary",
+      "progress-bar--success": this.variant === "success",
+      "progress-bar--warning": this.variant === "warning",
+      "progress-bar--danger": this.variant === "danger"
+    })}
+                role="progressbar"
+                title=${ifDefined(this.title || void 0)}
+                aria-label=${this.label || "Progress"}
+                aria-valuemin="0"
+                aria-valuemax="100"
+                aria-valuenow=${ifDefined(
+      this.indeterminate ? void 0 : this.value
+    )}
+            >
+                <div
+                    part="indicator"
+                    class="progress-bar__indicator"
+                    style=${styleMap({
+      width: this.indeterminate ? void 0 : `${this.value}%`
+    })}
+                >
+                    ${!this.indeterminate ? html`
+                              <slot part="label" class="progress-bar__label"></slot>
+                          ` : ""}
+                </div>
+            </div>
+        `;
+  }
+};
+TerraProgressBar.styles = [component_styles_default, progress_bar_styles_default];
+__decorateClass([
+  property({ type: Number, reflect: true })
+], TerraProgressBar.prototype, "value", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], TerraProgressBar.prototype, "indeterminate", 2);
+__decorateClass([
+  property()
+], TerraProgressBar.prototype, "label", 2);
+__decorateClass([
+  property({ reflect: true })
+], TerraProgressBar.prototype, "variant", 2);
+__decorateClass([
+  property()
+], TerraProgressBar.prototype, "title", 2);
+
+export {
+  TerraProgressBar
+};

package/dist/chunks/chunk.LUVB2N6O.js

@@ -0,0 +1,11 @@
+import {
+  TerraSkeleton
+} from "./chunk.Y3Y5JOA6.js";
+
+// src/components/skeleton/skeleton.ts
+var skeleton_default = TerraSkeleton;
+TerraSkeleton.define("terra-skeleton");
+
+export {
+  skeleton_default
+};