@nasa-terra/components 0.0.146 → 0.0.147

package/cdn/chunks/chunk.Q3HIYKVN.js

@@ -0,0 +1,286 @@
+import {
+  getDataByKey,
+  storeDataByKey
+} from "./chunk.C5XMJ6GC.js";
+import {
+  extractHarmonyError
+} from "./chunk.JDBB7GR4.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.Q46A4GMG.js

@@ -0,0 +1,74 @@
+import {
+  breadcrumb_styles_default
+} from "./chunk.XHVXO6NI.js";
+import {
+  e
+} from "./chunk.P3OLQVQM.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n
+} from "./chunk.VZRFHHI4.js";
+import {
+  x
+} from "./chunk.3ZQGAH53.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/breadcrumb/breadcrumb.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraBreadcrumb = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.current = false;
+  }
+  render() {
+    const isLink = !!this.href;
+    return x`
+            <span
+                part="base"
+                class=${e({
+      breadcrumb: true,
+      "breadcrumb--current": this.current,
+      "breadcrumb--link": isLink
+    })}
+            >
+                ${isLink ? x`
+                          <a
+                              part="link"
+                              class="breadcrumb__link"
+                              href=${this.href}
+                              aria-current=${this.current ? "page" : void 0}
+                          >
+                              <slot></slot>
+                          </a>
+                      ` : x`
+                          <span
+                              part="label"
+                              class="breadcrumb__label"
+                              aria-current=${this.current ? "page" : void 0}
+                          >
+                              <slot></slot>
+                          </span>
+                      `}
+            </span>
+        `;
+  }
+};
+TerraBreadcrumb.styles = [component_styles_default, breadcrumb_styles_default];
+__decorateClass([
+  n()
+], TerraBreadcrumb.prototype, "href", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraBreadcrumb.prototype, "current", 2);
+
+export {
+  TerraBreadcrumb
+};

package/cdn/chunks/chunk.QCQOKPOG.js

@@ -0,0 +1,33 @@
+import {
+  TerraTabs
+} from "./chunk.FLDZG3HL.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/react/tabs/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-tabs";
+TerraTabs.define("terra-tabs");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraTabs,
+  react: React,
+  events: {
+    onTerraTabShow: "terra-tab-show",
+    onTerraTabHide: "terra-tab-hide"
+  },
+  displayName: "TerraTabs"
+});
+var tabs_default = reactWrapper;
+
+export {
+  tabs_default
+};

package/cdn/chunks/chunk.QLSMP7MF.js

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

package/cdn/chunks/chunk.QQ7ZXO7Y.js

@@ -0,0 +1,230 @@
+import {
+  icon_styles_default
+} from "./chunk.L5Y4JVOE.js";
+import {
+  getIconLibrary,
+  unwatchIcon,
+  watchIcon
+} from "./chunk.QPEDBBDQ.js";
+import {
+  e
+} from "./chunk.YEINMQD6.js";
+import {
+  watch
+} from "./chunk.5WMSKURU.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n,
+  r
+} from "./chunk.VZRFHHI4.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/icon/icon.component.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/lit/directive-helpers.js
+init_dirname();
+init_buffer();
+init_process();
+
+// src/components/icon/icon.component.ts
+var CACHEABLE_ERROR = Symbol();
+var RETRYABLE_ERROR = Symbol();
+var parser;
+var iconCache = /* @__PURE__ */ new Map();
+var _initialRender, _resolveIcon, resolveIcon_fn, _getIconSource, getIconSource_fn, _styleFromAttributes, styleFromAttributes_fn;
+var TerraIcon = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    /** Given a URL, this function returns the resulting SVG element or an appropriate error symbol. */
+    __privateAdd(this, _resolveIcon);
+    __privateAdd(this, _getIconSource);
+    /**
+     * SVG takes a few presentation attributes. Since we're using a template for SVG and our host element isn't an SVG, we can pass those presentational attributes into a style attribute to affect the underlying SVG.
+     * Merge select attributes with existing inline style attribute to forward values to underlying SVG.
+     */
+    __privateAdd(this, _styleFromAttributes);
+    __privateAdd(this, _initialRender, false);
+    this.svg = null;
+    this.label = "";
+    this.library = "default";
+    this.color = null;
+    this.fontSize = null;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    watchIcon(this);
+  }
+  firstUpdated() {
+    __privateSet(this, _initialRender, true);
+    this.setIcon();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    unwatchIcon(this);
+  }
+  handleLabelChange() {
+    const hasLabel = typeof this.label === "string" && this.label.length > 0;
+    if (hasLabel) {
+      this.setAttribute("role", "img");
+      this.setAttribute("aria-label", this.label);
+      this.removeAttribute("aria-hidden");
+    } else {
+      this.removeAttribute("role");
+      this.removeAttribute("aria-label");
+      this.setAttribute("aria-hidden", "true");
+    }
+  }
+  async setIcon() {
+    var _a;
+    const { url, fromLibrary } = __privateMethod(this, _getIconSource, getIconSource_fn).call(this);
+    const library = fromLibrary ? getIconLibrary(this.library) : void 0;
+    if (!url) {
+      this.svg = null;
+      return;
+    }
+    let iconResolver = iconCache.get(url);
+    if (!iconResolver) {
+      iconResolver = __privateMethod(this, _resolveIcon, resolveIcon_fn).call(this, url);
+      iconCache.set(url, iconResolver);
+    }
+    if (!__privateGet(this, _initialRender)) {
+      return;
+    }
+    const svg = await iconResolver;
+    if (svg === RETRYABLE_ERROR) {
+      iconCache.delete(url);
+    }
+    if (url !== __privateMethod(this, _getIconSource, getIconSource_fn).call(this).url) {
+      return;
+    }
+    if (e(svg)) {
+      this.svg = svg;
+      return;
+    }
+    switch (svg) {
+      case RETRYABLE_ERROR:
+      case CACHEABLE_ERROR:
+        this.svg = null;
+        this.emit("terra-error");
+        break;
+      default:
+        this.svg = svg.cloneNode(true);
+        (_a = library == null ? void 0 : library.mutator) == null ? void 0 : _a.call(library, this.svg);
+        this.emit("terra-load");
+    }
+  }
+  render() {
+    __privateMethod(this, _styleFromAttributes, styleFromAttributes_fn).call(this);
+    return this.svg;
+  }
+};
+_initialRender = new WeakMap();
+_resolveIcon = new WeakSet();
+resolveIcon_fn = async function(url) {
+  var _a;
+  let fileData;
+  try {
+    fileData = await fetch(url, { mode: "cors" });
+    if (!fileData.ok) {
+      return fileData.status === 410 ? CACHEABLE_ERROR : RETRYABLE_ERROR;
+    }
+  } catch (e2) {
+    return RETRYABLE_ERROR;
+  }
+  try {
+    const div = document.createElement("div");
+    div.innerHTML = await fileData.text();
+    const svg = div.firstElementChild;
+    if (((_a = svg == null ? void 0 : svg.tagName) == null ? void 0 : _a.toLowerCase()) !== "svg") {
+      return CACHEABLE_ERROR;
+    }
+    if (!parser) {
+      parser = new DOMParser();
+    }
+    const doc = parser.parseFromString(svg.outerHTML, "text/html");
+    const svgEl = doc.body.querySelector("svg");
+    if (!svgEl) {
+      return CACHEABLE_ERROR;
+    }
+    svgEl.part.add("svg");
+    return document.adoptNode(svgEl);
+  } catch (e2) {
+    return CACHEABLE_ERROR;
+  }
+};
+_getIconSource = new WeakSet();
+getIconSource_fn = function() {
+  const library = getIconLibrary(this.library);
+  if (this.name && library) {
+    return {
+      url: library.resolver(this.name),
+      fromLibrary: true
+    };
+  }
+  return {
+    url: this.src,
+    fromLibrary: false
+  };
+};
+_styleFromAttributes = new WeakSet();
+styleFromAttributes_fn = function() {
+  const svgAttributes = [
+    { attribute: "color", property: this.color },
+    { attribute: "font-size", property: this.fontSize }
+  ];
+  const style = svgAttributes.reduce((accumulator, { attribute, property }) => {
+    if (typeof property === "string" && property.length > 0) {
+      accumulator += ` ${attribute}: ${property};`;
+    }
+    this.removeAttribute(attribute);
+    return accumulator;
+  }, `${this.style.cssText}`);
+  if (style.length > 0) {
+    this.setAttribute("style", style);
+  }
+};
+TerraIcon.styles = [component_styles_default, icon_styles_default];
+__decorateClass([
+  r()
+], TerraIcon.prototype, "svg", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraIcon.prototype, "name", 2);
+__decorateClass([
+  n()
+], TerraIcon.prototype, "src", 2);
+__decorateClass([
+  n()
+], TerraIcon.prototype, "label", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraIcon.prototype, "library", 2);
+__decorateClass([
+  n()
+], TerraIcon.prototype, "color", 2);
+__decorateClass([
+  n({ attribute: "font-size" })
+], TerraIcon.prototype, "fontSize", 2);
+__decorateClass([
+  watch("label")
+], TerraIcon.prototype, "handleLabelChange", 1);
+__decorateClass([
+  watch(["name", "src", "library"])
+], TerraIcon.prototype, "setIcon", 1);
+
+export {
+  TerraIcon
+};

package/cdn/chunks/chunk.QRITY6YZ.js

@@ -0,0 +1,19 @@
+import {
+  TerraIcon
+} from "./chunk.QQ7ZXO7Y.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/icon/icon.ts
+init_dirname();
+init_buffer();
+init_process();
+var icon_default = TerraIcon;
+TerraIcon.define("terra-icon");
+
+export {
+  icon_default
+};

package/cdn/chunks/chunk.RE2PBMSK.js

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