@nasa-terra/components 0.0.146 → 0.0.148

package/cdn/chunks/chunk.PL2AO7PI.js

@@ -0,0 +1,286 @@
+import {
+  getDataByKey,
+  storeDataByKey
+} from "./chunk.OMTCS2GC.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.PUNY2RWF.js

@@ -0,0 +1,19 @@
+import {
+  TerraButton
+} from "./chunk.EKADLA4J.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/button/button.ts
+init_dirname();
+init_buffer();
+init_process();
+var button_default = TerraButton;
+TerraButton.define("terra-button");
+
+export {
+  button_default
+};

package/cdn/chunks/chunk.PV65AF4K.js

@@ -0,0 +1,302 @@
+import {
+  tooltip_styles_default
+} from "./chunk.27AZYXPZ.js";
+import {
+  TerraPopup
+} from "./chunk.KDBSESEK.js";
+import {
+  animateTo,
+  parseDuration,
+  stopAnimations
+} from "./chunk.MZBEU2IT.js";
+import {
+  getAnimation,
+  setDefaultAnimation
+} from "./chunk.VA7AQEP7.js";
+import {
+  waitForEvent
+} from "./chunk.DFBLDLFE.js";
+import {
+  e
+} from "./chunk.P3OLQVQM.js";
+import {
+  watch
+} from "./chunk.5WMSKURU.js";
+import {
+  TerraElement,
+  component_styles_default,
+  e as e2,
+  n
+} from "./chunk.YO4X3RWQ.js";
+import {
+  x
+} from "./chunk.3ZQGAH53.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.js";
+
+// src/components/tooltip/tooltip.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraTooltip = class extends TerraElement {
+  constructor() {
+    super();
+    this.content = "";
+    this.variant = "tooltip";
+    this.placement = "top";
+    this.disabled = false;
+    this.distance = 8;
+    this.open = false;
+    this.skidding = 0;
+    this.trigger = "hover focus";
+    this.hoist = false;
+    this.handleBlur = () => {
+      if (this.hasTrigger("focus")) {
+        this.hide();
+      }
+    };
+    this.handleClick = () => {
+      if (this.hasTrigger("click")) {
+        if (this.open) {
+          this.hide();
+        } else {
+          this.show();
+        }
+      }
+    };
+    this.handleFocus = () => {
+      if (this.hasTrigger("focus")) {
+        this.show();
+      }
+    };
+    this.handleDocumentKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.stopPropagation();
+        this.hide();
+      }
+    };
+    this.handleMouseOver = () => {
+      if (this.hasTrigger("hover")) {
+        const delay = parseDuration(
+          getComputedStyle(this).getPropertyValue("--show-delay")
+        );
+        clearTimeout(this.hoverTimeout);
+        this.hoverTimeout = window.setTimeout(() => this.show(), delay);
+      }
+    };
+    this.handleMouseOut = () => {
+      if (this.hasTrigger("hover")) {
+        const delay = parseDuration(
+          getComputedStyle(this).getPropertyValue("--hide-delay")
+        );
+        clearTimeout(this.hoverTimeout);
+        this.hoverTimeout = window.setTimeout(() => this.hide(), delay);
+      }
+    };
+    this.addEventListener("blur", this.handleBlur, true);
+    this.addEventListener("focus", this.handleFocus, true);
+    this.addEventListener("click", this.handleClick);
+    this.addEventListener("mouseover", this.handleMouseOver);
+    this.addEventListener("mouseout", this.handleMouseOut);
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this.closeWatcher) == null ? void 0 : _a.destroy();
+    document.removeEventListener("keydown", this.handleDocumentKeyDown);
+  }
+  firstUpdated() {
+    this.body.hidden = !this.open;
+    if (this.open) {
+      this.popup.active = true;
+      this.popup.reposition();
+    }
+  }
+  hasTrigger(triggerType) {
+    const triggers = this.trigger.split(" ");
+    return triggers.includes(triggerType);
+  }
+  async handleOpenChange() {
+    var _a, _b;
+    if (this.open) {
+      if (this.disabled) {
+        return;
+      }
+      this.emit("terra-show");
+      if ("CloseWatcher" in window) {
+        (_a = this.closeWatcher) == null ? void 0 : _a.destroy();
+        this.closeWatcher = new CloseWatcher();
+        this.closeWatcher.onclose = () => {
+          this.hide();
+        };
+      } else {
+        document.addEventListener("keydown", this.handleDocumentKeyDown);
+      }
+      await stopAnimations(this.body);
+      this.body.hidden = false;
+      this.popup.active = true;
+      const { keyframes, options } = getAnimation(this, "tooltip.show", {
+        dir: "ltr"
+      });
+      await animateTo(this.popup.popup, keyframes, options);
+      this.popup.reposition();
+      this.emit("terra-after-show");
+    } else {
+      this.emit("terra-hide");
+      (_b = this.closeWatcher) == null ? void 0 : _b.destroy();
+      document.removeEventListener("keydown", this.handleDocumentKeyDown);
+      await stopAnimations(this.body);
+      const { keyframes, options } = getAnimation(this, "tooltip.hide", {
+        dir: "ltr"
+      });
+      await animateTo(this.popup.popup, keyframes, options);
+      this.popup.active = false;
+      this.body.hidden = true;
+      this.emit("terra-after-hide");
+    }
+  }
+  async handleOptionsChange() {
+    if (this.hasUpdated) {
+      await this.updateComplete;
+      this.popup.reposition();
+    }
+  }
+  handleDisabledChange() {
+    if (this.disabled && this.open) {
+      this.hide();
+    }
+  }
+  /** Shows the tooltip or popover. */
+  async show() {
+    if (this.open) {
+      return void 0;
+    }
+    this.open = true;
+    return waitForEvent(this, "terra-after-show");
+  }
+  /** Hides the tooltip or popover. */
+  async hide() {
+    if (!this.open) {
+      return void 0;
+    }
+    this.open = false;
+    return waitForEvent(this, "terra-after-hide");
+  }
+  //
+  // NOTE: Tooltip is a bit unique in that we're using aria-live instead of aria-labelledby to trick screen readers into
+  // announcing the content. It works really well, but it violates an accessibility rule. We're also adding the
+  // aria-describedby attribute to a slot, which is required by <terra-popup> to correctly locate the first assigned
+  // element, otherwise positioning is incorrect.
+  //
+  render() {
+    const isPopover = this.variant === "popover";
+    return x`
+            <terra-popup
+                part="base"
+                exportparts="
+          popup:base__popup,
+          arrow:base__arrow
+        "
+                class=${e({
+      tooltip: true,
+      "tooltip--popover": isPopover,
+      "tooltip--open": this.open
+    })}
+                placement=${this.placement}
+                distance=${this.distance}
+                skidding=${this.skidding}
+                strategy=${this.hoist ? "fixed" : "absolute"}
+                flip
+                shift
+                arrow
+                hover-bridge
+            >
+                ${""}
+                <slot slot="anchor" aria-describedby="tooltip"></slot>
+
+                ${""}
+                <div
+                    part="body"
+                    id="tooltip"
+                    class="tooltip__body"
+                    role=${isPopover ? "dialog" : "tooltip"}
+                    aria-live=${this.open ? "polite" : "off"}
+                >
+                    <div class="tooltip__image">
+                        <slot name="image"></slot>
+                    </div>
+                    <slot name="content">${this.content}</slot>
+                </div>
+            </terra-popup>
+        `;
+  }
+};
+TerraTooltip.styles = [component_styles_default, tooltip_styles_default];
+TerraTooltip.dependencies = { "terra-popup": TerraPopup };
+__decorateClass([
+  e2("slot:not([name])")
+], TerraTooltip.prototype, "defaultSlot", 2);
+__decorateClass([
+  e2(".tooltip__body")
+], TerraTooltip.prototype, "body", 2);
+__decorateClass([
+  e2("terra-popup")
+], TerraTooltip.prototype, "popup", 2);
+__decorateClass([
+  n()
+], TerraTooltip.prototype, "content", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraTooltip.prototype, "variant", 2);
+__decorateClass([
+  n()
+], TerraTooltip.prototype, "placement", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraTooltip.prototype, "disabled", 2);
+__decorateClass([
+  n({ type: Number })
+], TerraTooltip.prototype, "distance", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraTooltip.prototype, "open", 2);
+__decorateClass([
+  n({ type: Number })
+], TerraTooltip.prototype, "skidding", 2);
+__decorateClass([
+  n()
+], TerraTooltip.prototype, "trigger", 2);
+__decorateClass([
+  n({ type: Boolean })
+], TerraTooltip.prototype, "hoist", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], TerraTooltip.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch(["content", "distance", "hoist", "placement", "skidding"])
+], TerraTooltip.prototype, "handleOptionsChange", 1);
+__decorateClass([
+  watch("disabled")
+], TerraTooltip.prototype, "handleDisabledChange", 1);
+setDefaultAnimation("tooltip.show", {
+  keyframes: [
+    { opacity: 0, scale: 0.8 },
+    { opacity: 1, scale: 1 }
+  ],
+  options: { duration: 150, easing: "ease" }
+});
+setDefaultAnimation("tooltip.hide", {
+  keyframes: [
+    { opacity: 1, scale: 1 },
+    { opacity: 0, scale: 0.8 }
+  ],
+  options: { duration: 150, easing: "ease" }
+});
+
+export {
+  TerraTooltip
+};