@nasa-terra/components 0.0.137 → 0.0.139

package/cdn/chunks/chunk.G5YHIN6F.js

@@ -0,0 +1,104 @@
+import {
+  chip_styles_default
+} from "./chunk.GALT5XHF.js";
+import {
+  e
+} from "./chunk.P3OLQVQM.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n
+} from "./chunk.FU6DSPVY.js";
+import {
+  E,
+  x
+} from "./chunk.3ZQGAH53.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/chip/chip.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var _handleRemoveClick;
+var TerraChip = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.size = "medium";
+    this.closeable = false;
+    this.stack = false;
+    __privateAdd(this, _handleRemoveClick, () => {
+      this.emit("terra-remove");
+      this.remove();
+    });
+  }
+  render() {
+    return x`
+            <div
+                class="${e({
+      "chip--small": this.size === "small",
+      "chip--medium": this.size === "medium",
+      "chip--large": this.size === "large"
+    })}
+                chip"
+            >
+                <div
+                    class="${e({
+      "chip-content--small": this.size === "small",
+      "chip-content--medium": this.size === "medium",
+      "chip-content--large": this.size === "large"
+    })}
+                    chip-content"
+                >
+                    <slot part="content" class="tag__content"></slot>
+                </div>
+                ${this.closeable ? x`
+                          <button
+                              class="chip-close"
+                              @click="${__privateGet(this, _handleRemoveClick)}"
+                          >
+                              <svg
+                                  class="${e({
+      // Sizes
+      "chip-svg--small": this.size === "small",
+      "chip-svg--medium": this.size === "medium",
+      "chip-svg--large": this.size === "large"
+    })}
+                        chip-svg"
+                                  focusable="false"
+                                  viewBox="0 0 500 500"
+                                  aria-hidden="true"
+                              >
+                                  <path
+                                      d="M 227 56.036 H 265 V 227.037 H 436 V 265.036 H 265 V 436.036 H 227 V 265.036 H 56 V 227.037 H 227 Z"
+                                      style="paint-order: fill; fill-rule: nonzero; stroke-width: 0px; transform-origin: 246px 246.036px;"
+                                      transform="matrix(0.707107007504, 0.707107007504, -0.707107007504, 0.707107007504, -9.98393e-7, -0.000026419743)"
+                                  ></path>
+                              </svg>
+                          </button>
+                      ` : E}
+            </div>
+        `;
+  }
+};
+_handleRemoveClick = new WeakMap();
+TerraChip.styles = [component_styles_default, chip_styles_default];
+__decorateClass([
+  n({ reflect: true })
+], TerraChip.prototype, "size", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraChip.prototype, "closeable", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraChip.prototype, "stack", 2);
+
+export {
+  TerraChip
+};

package/cdn/chunks/chunk.GDJPXXU2.js

@@ -0,0 +1,286 @@
+import {
+  extractHarmonyError
+} from "./chunk.JDBB7GR4.js";
+import {
+  getDataByKey,
+  storeDataByKey
+} from "./chunk.C5XMJ6GC.js";
+import {
+  FINAL_STATUSES,
+  HarmonyDataService
+} from "./chunk.SCR3ZWIR.js";
+import {
+  format,
+  formatDate
+} from "./chunk.WE52YORO.js";
+import {
+  h
+} from "./chunk.WQPCK3PB.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/time-average-map/time-average-map.controller.ts
+init_dirname();
+init_buffer();
+init_process();
+var REFRESH_HARMONY_DATA_INTERVAL = 2e3;
+var _host, _dataService, _updateGeoTIFFLayer, updateGeoTIFFLayer_fn, _waitForHarmonyJob, waitForHarmonyJob_fn, _getDataService, getDataService_fn, _getEmptyJob, getEmptyJob_fn, _handleHarmonyError, handleHarmonyError_fn;
+var TimeAvgMapController = class {
+  constructor(host) {
+    __privateAdd(this, _updateGeoTIFFLayer);
+    __privateAdd(this, _waitForHarmonyJob);
+    __privateAdd(this, _getDataService);
+    __privateAdd(this, _getEmptyJob);
+    /**
+     * Handles errors from Harmony GraphQL operations and dispatches them as events
+     */
+    __privateAdd(this, _handleHarmonyError);
+    __privateAdd(this, _host, void 0);
+    __privateAdd(this, _dataService, void 0);
+    __privateSet(this, _host, host);
+    __privateSet(this, _dataService, __privateMethod(this, _getDataService, getDataService_fn).call(this));
+    this.jobStatusTask = new h(host, {
+      task: async ([], { signal }) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let job;
+        const start_date = new Date((_b = (_a = __privateGet(this, _host)) == null ? void 0 : _a.startDate) != null ? _b : Date.now());
+        const end_date = new Date((_d = (_c = __privateGet(this, _host)) == null ? void 0 : _c.endDate) != null ? _d : Date.now());
+        const [w, s, e, n] = (_f = (_e = __privateGet(this, _host).location) == null ? void 0 : _e.split(",")) != null ? _f : [];
+        const collection = `${__privateGet(this, _host).catalogVariable.dataProductShortName}_${__privateGet(this, _host).catalogVariable.dataProductVersion}`;
+        let subsetOptions = {
+          collectionEntryId: `${collection}`,
+          variableConceptIds: ["parameter_vars"],
+          variableEntryIds: [
+            `${__privateGet(this, _host).collection}_${__privateGet(this, _host).variable}`
+          ],
+          startDate: format(start_date, "yyyy-MM-dd") + "T00%3A00%3A00",
+          endDate: format(end_date, "yyyy-MM-dd") + "T00%3A00%3A00",
+          format: "text/csv",
+          boundingBox: {
+            w: parseFloat(w),
+            s: parseFloat(s),
+            e: parseFloat(e),
+            n: parseFloat(n)
+          },
+          average: "time"
+        };
+        console.log(`Creating a job with options`, subsetOptions);
+        this.currentJob = __privateMethod(this, _getEmptyJob, getEmptyJob_fn).call(this);
+        __privateGet(this, _host).harmonyJobId = void 0;
+        try {
+          const cacheKey = this.getCacheKey();
+          const existing = await getDataByKey("time-average-map" /* TIME_AVERAGE_MAP */, cacheKey);
+          if (existing) {
+            console.log(
+              "Returning existing map blob from cache",
+              cacheKey
+            );
+            __privateGet(this, _host).harmonyJobId = existing.harmonyJobId;
+            __privateMethod(this, _updateGeoTIFFLayer, updateGeoTIFFLayer_fn).call(this, existing.blob);
+            return existing.blob;
+          }
+          console.log("Calling create subset job..");
+          try {
+            job = await __privateGet(this, _dataService).createSubsetJob(subsetOptions, {
+              signal,
+              bearerToken: __privateGet(this, _host).bearerToken,
+              environment: __privateGet(this, _host).environment
+            });
+          } catch (error) {
+            __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+            throw error;
+          }
+          if (!job) {
+            const error = new Error("Failed to create subset job");
+            __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+            throw error;
+          }
+          console.log("Waiting for harmony job..");
+          const jobStatus = await __privateMethod(this, _waitForHarmonyJob, waitForHarmonyJob_fn).call(this, job, signal);
+          if (jobStatus.status === "failed" /* FAILED */) {
+            const errorMessage = jobStatus.message || ((_h = (_g = jobStatus.errors) == null ? void 0 : _g[0]) == null ? void 0 : _h.message) || "The subset job failed";
+            const error = new Error(errorMessage);
+            __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+            throw error;
+          }
+          if (jobStatus.status === "complete_with_errors" /* COMPLETE_WITH_ERRORS */ && jobStatus.errors && jobStatus.errors.length > 0) {
+            const errorMessage = jobStatus.errors[0].message || "The subset job completed with errors";
+            const error = new Error(errorMessage);
+            __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+            throw error;
+          }
+          let blob;
+          try {
+            const result = await __privateGet(this, _dataService).getSubsetJobData(
+              jobStatus,
+              {
+                signal,
+                bearerToken: __privateGet(this, _host).bearerToken,
+                environment: __privateGet(this, _host).environment
+              }
+            );
+            blob = result.blob;
+          } catch (error) {
+            __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+            throw error;
+          }
+          await storeDataByKey("time-average-map" /* TIME_AVERAGE_MAP */, cacheKey, {
+            key: cacheKey,
+            cachedAt: (/* @__PURE__ */ new Date()).getTime(),
+            environment: __privateGet(this, _host).environment,
+            blob,
+            harmonyJobId: jobStatus.jobID
+          });
+          __privateMethod(this, _updateGeoTIFFLayer, updateGeoTIFFLayer_fn).call(this, blob);
+          return blob;
+        } catch (err) {
+          const error_msg = `Failed to create subset job: ${err}`;
+          console.error(error_msg);
+          throw new Error(error_msg);
+        }
+      },
+      args: () => [],
+      autoRun: false
+    });
+  }
+  render(renderFunctions) {
+    return this.jobStatusTask.render(renderFunctions);
+  }
+  fetchJobByID(jobID) {
+    this.currentJob = {
+      jobID,
+      status: "fetching" /* FETCHING */,
+      message: "Your job is being retrieved.",
+      progress: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dataExpiration: "",
+      request: "",
+      numInputGranules: 0,
+      links: []
+    };
+    this.jobStatusTask.run();
+  }
+  getCacheKey() {
+    var _a, _b, _c, _d, _e, _f;
+    const environment = (_a = __privateGet(this, _host).environment) != null ? _a : "prod";
+    const location = (_b = __privateGet(this, _host).location) != null ? _b : "";
+    const collection = (_c = __privateGet(this, _host).collection) != null ? _c : "";
+    const variable = (_d = __privateGet(this, _host).variable) != null ? _d : "";
+    const start = (_e = __privateGet(this, _host).startDate) != null ? _e : "";
+    const end = (_f = __privateGet(this, _host).endDate) != null ? _f : "";
+    return `map_${collection}_${variable}_${start}_${end}_${location}_${environment}`;
+  }
+};
+_host = new WeakMap();
+_dataService = new WeakMap();
+_updateGeoTIFFLayer = new WeakSet();
+updateGeoTIFFLayer_fn = function(blob) {
+  this.blobUrl = blob;
+  __privateGet(this, _host).emit("terra-time-average-map-data-change", {
+    detail: {
+      data: blob,
+      variable: __privateGet(this, _host).catalogVariable,
+      startDate: formatDate(__privateGet(this, _host).startDate),
+      endDate: formatDate(__privateGet(this, _host).endDate),
+      location: __privateGet(this, _host).location,
+      colorMap: __privateGet(this, _host).colorMapName,
+      harmonyJobId: __privateGet(this, _host).harmonyJobId
+    }
+  });
+  __privateGet(this, _host).updateGeoTIFFLayer(blob);
+};
+_waitForHarmonyJob = new WeakSet();
+waitForHarmonyJob_fn = function(job, signal) {
+  return new Promise(async (resolve, reject) => {
+    if (signal.aborted) {
+      reject(new Error("Job polling was aborted"));
+      return;
+    }
+    let jobStatus;
+    try {
+      jobStatus = await __privateGet(this, _dataService).getSubsetJobStatus(job.jobID, {
+        signal,
+        bearerToken: __privateGet(this, _host).bearerToken,
+        environment: __privateGet(this, _host).environment
+      });
+      console.log("Job status", jobStatus);
+      __privateGet(this, _host).harmonyJobId = jobStatus.jobID;
+    } catch (error) {
+      console.error("Error checking harmony job status", error);
+      if (signal.aborted || (error == null ? void 0 : error.name) === "AbortError") {
+        reject(error);
+        return;
+      }
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+      reject(error);
+      return;
+    }
+    if (jobStatus && FINAL_STATUSES.has(jobStatus.status)) {
+      console.log("Job is done", jobStatus);
+      resolve(jobStatus);
+    } else {
+      if (signal.aborted) {
+        reject(new Error("Job polling was aborted"));
+        return;
+      }
+      const abortHandler = () => {
+        reject(new Error("Job polling was aborted"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      setTimeout(async () => {
+        signal.removeEventListener("abort", abortHandler);
+        if (signal.aborted) {
+          reject(new Error("Job polling was aborted"));
+          return;
+        }
+        try {
+          resolve(await __privateMethod(this, _waitForHarmonyJob, waitForHarmonyJob_fn).call(this, job, signal));
+        } catch (error) {
+          reject(error);
+        }
+      }, REFRESH_HARMONY_DATA_INTERVAL);
+    }
+  });
+};
+_getDataService = new WeakSet();
+getDataService_fn = function() {
+  return new HarmonyDataService();
+};
+_getEmptyJob = new WeakSet();
+getEmptyJob_fn = function() {
+  return {
+    jobID: "",
+    status: "running" /* RUNNING */,
+    message: "Your job is being created and will start soon.",
+    progress: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dataExpiration: "",
+    request: "",
+    numInputGranules: 0,
+    links: []
+  };
+};
+_handleHarmonyError = new WeakSet();
+handleHarmonyError_fn = function(error, jobErrors) {
+  const errorDetails = extractHarmonyError(error, jobErrors);
+  __privateGet(this, _host).dispatchEvent(
+    new CustomEvent("terra-time-average-map-error", {
+      detail: errorDetails,
+      bubbles: true,
+      composed: true
+    })
+  );
+};
+
+export {
+  TimeAvgMapController
+};

package/cdn/chunks/chunk.GIFNSZH6.js

@@ -0,0 +1,39 @@
+import {
+  TerraDataGrid
+} from "./chunk.JNZU345Q.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/react/data-grid/index.ts
+init_dirname();
+init_buffer();
+init_process();
+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/cdn/chunks/chunk.GJLQFN2E.js

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

package/cdn/chunks/chunk.GKLZDT4V.js

@@ -0,0 +1,229 @@
+import {
+  Leaflet
+} from "./chunk.4UFYI2TK.js";
+import {
+  leaflet_styles_default
+} from "./chunk.WXP5OUQO.js";
+import {
+  MapController
+} from "./chunk.KS33TJQ3.js";
+import {
+  map_styles_default
+} from "./chunk.GNFKFHVB.js";
+import {
+  leaflet_draw_styles_default
+} from "./chunk.XCB7WJR3.js";
+import {
+  h
+} from "./chunk.AH6W6EGS.js";
+import {
+  o
+} from "./chunk.RRPJMP3C.js";
+import {
+  watch
+} from "./chunk.5WMSKURU.js";
+import {
+  TerraElement,
+  component_styles_default,
+  e,
+  n,
+  r
+} from "./chunk.FU6DSPVY.js";
+import {
+  E,
+  x
+} from "./chunk.3ZQGAH53.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateMethod,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/map/map.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var _markDynamicLeafletContent, markDynamicLeafletContent_fn;
+var TerraMap = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _markDynamicLeafletContent);
+    this.minZoom = 0;
+    this.maxZoom = 23;
+    this.zoom = 1;
+    this.hasNavigation = false;
+    this.hasCoordTracker = false;
+    this.hasShapeSelector = false;
+    this.staticMode = false;
+    this.noWorldWrap = false;
+    this.value = [];
+    this.map = new Leaflet();
+    this._mapController = new MapController(this);
+  }
+  valueChanged(_oldValue, newValue) {
+    var _a;
+    if (newValue.length > 0) {
+      (_a = this.map) == null ? void 0 : _a.setValue(this.value);
+    } else if (newValue.length === 0 && this.map.isMapReady) {
+      this.map.clearLayers();
+    }
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+  }
+  async firstUpdated() {
+    await this.map.initializeMap(this.mapElement, {
+      zoom: this.zoom,
+      minZoom: this.minZoom,
+      maxZoom: this.maxZoom,
+      hasCoordTracker: this.hasCoordTracker,
+      hasNavigation: this.hasNavigation,
+      initialValue: this.value,
+      hideBoundingBoxDrawTool: this.hideBoundingBoxSelection,
+      hidePointSelectionDrawTool: this.hidePointSelection,
+      staticMode: this.staticMode,
+      noWorldWrap: this.noWorldWrap
+    });
+    this.map.on("draw", (layer) => {
+      this.emit("terra-map-change", {
+        detail: __spreadValues({
+          cause: "draw",
+          type: "latLng" in layer ? "point" /* POINT */ : "bounds" in layer ? "bbox" /* BBOX */ : void 0
+        }, layer)
+      });
+    });
+    this.map.on(
+      "clear",
+      (_e) => this.emit("terra-map-change", {
+        detail: {
+          cause: "clear"
+        }
+      })
+    );
+    __privateMethod(this, _markDynamicLeafletContent, markDynamicLeafletContent_fn).call(this);
+  }
+  getDrawLayer() {
+    return this.map.editableLayers.getLayers()[0];
+  }
+  selectTemplate() {
+    var _a;
+    return x`
+            <select
+                class="map__select form-control"
+                @change=${this.map.handleShapeSelect}
+            >
+                <option value="">Select a Shape...</option>
+
+                ${h(
+      o((_a = this.shapes) == null ? void 0 : _a.categories, (category) => {
+        return x`<optgroup label="${category.title}">
+                            ${category.shapes.map((shape) => {
+          return x`
+                                    <option
+                                        value="shape=${shape.shapefileID}/${shape.shapeID}"
+                                    >
+                                        ${shape.name}
+                                    </option>
+                                `;
+        })}
+                        </optgroup> `;
+      })
+    )}
+            </select>
+        `;
+  }
+  render() {
+    return x`
+            ${this.hasShapeSelector ? this.selectTemplate() : E}
+            <div
+                part="map"
+                id="map"
+                class=${`map ${this.staticMode ? "static" : ""}`}
+            ></div>
+        `;
+  }
+  invalidateSize() {
+    this.map.map.invalidateSize();
+  }
+};
+_markDynamicLeafletContent = new WeakSet();
+markDynamicLeafletContent_fn = function() {
+  var _a, _b, _c, _d;
+  const parts = [
+    {
+      item: (_a = this.shadowRoot) == null ? void 0 : _a.querySelector(".leaflet-draw-draw-rectangle"),
+      name: "leaflet-bbox"
+    },
+    {
+      item: (_b = this.shadowRoot) == null ? void 0 : _b.querySelector(".leaflet-draw-draw-marker"),
+      name: "leaflet-point"
+    },
+    {
+      item: (_c = this.shadowRoot) == null ? void 0 : _c.querySelector(".leaflet-draw-edit-edit"),
+      name: "leaflet-edit"
+    },
+    {
+      item: (_d = this.shadowRoot) == null ? void 0 : _d.querySelector(".leaflet-draw-edit-remove"),
+      name: "leaflet-remove"
+    }
+  ];
+  parts.forEach(({ item, name }) => {
+    item == null ? void 0 : item.setAttribute("part", name);
+  });
+};
+TerraMap.styles = [
+  component_styles_default,
+  leaflet_styles_default,
+  leaflet_draw_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([
+  n({ attribute: "has-navigation", type: Boolean })
+], TerraMap.prototype, "hasNavigation", 2);
+__decorateClass([
+  n({ attribute: "has-coord-tracker", type: Boolean })
+], TerraMap.prototype, "hasCoordTracker", 2);
+__decorateClass([
+  n({ attribute: "has-shape-selector", type: Boolean })
+], TerraMap.prototype, "hasShapeSelector", 2);
+__decorateClass([
+  n({ attribute: "hide-bounding-box-selection", type: Boolean })
+], TerraMap.prototype, "hideBoundingBoxSelection", 2);
+__decorateClass([
+  n({ attribute: "hide-point-selection", type: Boolean })
+], TerraMap.prototype, "hidePointSelection", 2);
+__decorateClass([
+  n({ type: Boolean })
+], TerraMap.prototype, "staticMode", 2);
+__decorateClass([
+  n({ attribute: "no-world-wrap", type: Boolean })
+], TerraMap.prototype, "noWorldWrap", 2);
+__decorateClass([
+  n({ type: Array })
+], TerraMap.prototype, "value", 2);
+__decorateClass([
+  e("#map")
+], TerraMap.prototype, "mapElement", 2);
+__decorateClass([
+  watch("value")
+], TerraMap.prototype, "valueChanged", 1);
+__decorateClass([
+  r()
+], TerraMap.prototype, "shapes", 2);
+
+export {
+  TerraMap
+};