@nasa-terra/components 0.0.185 → 0.0.187

package/cdn/chunks/chunk.36G5VRI3.js

@@ -0,0 +1,433 @@
+import {
+  withDb
+} from "./chunk.GPH5N6EA.js";
+import {
+  apiClient
+} from "./chunk.ND3745YQ.js";
+import {
+  BadRequestException
+} from "./chunk.SYQOGYTQ.js";
+import {
+  __privateAdd,
+  __privateMethod,
+  __spreadProps,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/apis/harmony.api.ts
+init_dirname();
+init_buffer();
+init_process();
+var API_VERSION = "3";
+var Environments = {
+  PROD: "PROD",
+  UAT: "UAT"
+};
+var HARMONY_URLS = {
+  [Environments.PROD]: "https://harmony.earthdata.nasa.gov",
+  [Environments.UAT]: "https://harmony.uat.earthdata.nasa.gov",
+  // for anonymous access, we have to go through our proxy since Harmony doesn't support anonymous requests directly
+  // the proxy will add the necessary authentication to the request on the backend, so we can still use the same HarmonyRequest class to build the request URL with the appropriate parameters
+  // the proxy also adds restrictions on how much data can be requested
+  ANONYMOUS_ACCESS: "https://sjldutoe6c.execute-api.us-east-1.amazonaws.com/default/harmony-proxy"
+};
+var CLOUD_GIOVANNI_URLS = {
+  [Environments.PROD]: "https://api.giovanni.earthdata.nasa.gov",
+  [Environments.UAT]: "https://api.giovanni.uat.earthdata.nasa.gov"
+};
+var FINAL_STATUSES = /* @__PURE__ */ new Set([
+  "successful" /* SUCCESSFUL */,
+  "failed" /* FAILED */,
+  "canceled" /* CANCELED */,
+  "complete_with_errors" /* COMPLETE_WITH_ERRORS */
+]);
+var _request, request_fn, _hasGiovanniServices, hasGiovanniServices_fn, _hasNonGiovanniServices, hasNonGiovanniServices_fn, _getNonGiovanniFormats, getNonGiovanniFormats_fn, _getGiovanniFormats, getGiovanniFormats_fn;
+var HarmonyApi = class {
+  constructor() {
+    __privateAdd(this, _request);
+    __privateAdd(this, _hasGiovanniServices);
+    __privateAdd(this, _hasNonGiovanniServices);
+    __privateAdd(this, _getNonGiovanniFormats);
+    __privateAdd(this, _getGiovanniFormats);
+  }
+  /**
+   * Returns collection capabilities including available services, output formats, subsetting options, etc.
+   * from the Harmony /capabilities endpoint
+   */
+  async getCollectionCapabilities(conceptId, options) {
+    if (!conceptId) {
+      throw new BadRequestException({
+        message: "`collectionConceptId` is required"
+      });
+    }
+    const capabilities = await __privateMethod(this, _request, request_fn).call(this, `capabilities?collectionId=${conceptId}&version=${API_VERSION}`, options);
+    capabilities.variables = this.addConceptIdToVariables(capabilities.variables);
+    capabilities.configuredOutputFormats = this.getOutputFormatOptions(capabilities);
+    return capabilities;
+  }
+  /**
+   * Gets a user's Harmony jobs
+   */
+  async getJobs(params, options) {
+    const queryParams = new URLSearchParams();
+    if (params == null ? void 0 : params.page)
+      queryParams.append("page", params.page.toString());
+    if (params == null ? void 0 : params.limit)
+      queryParams.append("limit", params.limit.toString());
+    if (params == null ? void 0 : params.label)
+      queryParams.append("label", params.label);
+    return __privateMethod(this, _request, request_fn).call(this, `jobs?${queryParams.toString()}`, options);
+  }
+  /**
+   * Create a subset job by sending a GET request to the Harmony OGC API endpoint.
+   * The harmonyRequest.requestUrl contains the full URL with all subset parameters.
+   */
+  async createJob(harmonyRequest, options) {
+    return __privateMethod(this, _request, request_fn).call(this, harmonyRequest.requestUrl, options);
+  }
+  /**
+   * Get the current status of an existing subset job.
+   * Intended for polling until the job reaches a final state.
+   */
+  async getJobStatus(jobId, options) {
+    return __privateMethod(this, _request, request_fn).call(this, `jobs/${jobId}`, options);
+  }
+  /**
+   * Removes one or more labels from one or more Harmony jobs.
+   * After removal, the jobs will no longer match label-based filters.
+   *
+   * @example
+   * await harmonyApi.removeJobLabels({ jobIDs: ['abc', 'def'], labels: ['my-label'] }, { bearerToken })
+   */
+  async removeJobLabels(params, options) {
+    const url = `${HARMONY_URLS[Environments.PROD]}/labels`;
+    return apiClient.delete(url, {
+      body: { jobID: params.jobIDs, label: params.labels },
+      headers: __spreadValues({
+        "Content-Type": "application/json"
+      }, (options == null ? void 0 : options.bearerToken) && {
+        Authorization: `Bearer ${options.bearerToken}`
+      }),
+      signal: options == null ? void 0 : options.signal
+    });
+  }
+  /**
+   * Given a jobId for a running job, send a cancellation request to the Harmony API.
+   * Returns the updated job status after cancellation.
+   */
+  async cancelJob(jobId, options) {
+    return __privateMethod(this, _request, request_fn).call(this, `jobs/${jobId}/cancel`, options);
+  }
+  /**
+   * When a Harmony job finishes, it provides URLs for downloading the results. This method can be used to fetch the results from those URLs, which may require authentication if the data is not public.
+   */
+  async fetchUrl(url, options) {
+    const relativeUrl = url.replace(CLOUD_GIOVANNI_URLS.PROD, "").replace(CLOUD_GIOVANNI_URLS.UAT, "");
+    return __privateMethod(this, _request, request_fn).call(this, relativeUrl, options);
+  }
+  /**
+   * Extracts the variable concept ID from the variable's href and adds it as a property on the variable object.
+   */
+  addConceptIdToVariables(variables) {
+    return variables.map((v) => {
+      const match = v.href.match(/\/concepts\/(V\d+-\w+)$/);
+      if (match) {
+        v.conceptId = match[1];
+      }
+      return v;
+    });
+  }
+  /**
+   * Processes the Harmony capabilities response to generate a list of output format options with user-friendly labels and descriptions.
+   * If Giovanni is the only service available, only return Giovanni-specific formats.
+   * If Giovanni is present with other services, include both Giovanni and non-Giovanni formats, avoiding duplicates.
+   * If Giovanni is not present, return only non-Giovanni formats.
+   */
+  getOutputFormatOptions(capabilities) {
+    const hasNonGiovanniServices = __privateMethod(this, _hasNonGiovanniServices, hasNonGiovanniServices_fn).call(this, capabilities);
+    const hasGiovanniServices = __privateMethod(this, _hasGiovanniServices, hasGiovanniServices_fn).call(this, capabilities);
+    const giovanniFormats = hasGiovanniServices ? __privateMethod(this, _getGiovanniFormats, getGiovanniFormats_fn).call(this, capabilities) : [];
+    if (hasGiovanniServices && !hasNonGiovanniServices) {
+      return giovanniFormats;
+    }
+    const outputFormats = [];
+    const nonGiovanniFormats = __privateMethod(this, _getNonGiovanniFormats, getNonGiovanniFormats_fn).call(this, capabilities);
+    nonGiovanniFormats.forEach((format) => {
+      let label = format;
+      let description = `Download data in ${format} format`;
+      switch (format) {
+        case "application/x-hdf":
+        case "application/octet-stream":
+          label = "HDF-EOS5";
+          description = "Download data in HDF-EOS5 format";
+          break;
+        case "application/x-netcdf4":
+        case "application/netcdf":
+          label = "NetCDF";
+          description = "Download data in NetCDF format";
+          break;
+        case "application/x-netcdf4;profile=opendap_url":
+          label = "OPeNDAP URL (x-netcdf4)";
+          description = "Download data in OPeNDAP URL (x-netcdf4) format";
+          break;
+        case "text/csv":
+          label = "CSV";
+          description = "Download data in CSV format";
+          break;
+        case "image/tiff":
+        case "image/tif":
+          label = "TIFF";
+          description = "Download data in TIFF format";
+          break;
+        case "image/png":
+          label = "PNG";
+          description = "Download data in PNG format";
+          break;
+        case "image/jpg":
+        case "image/jpeg":
+          label = "JPEG";
+          description = "Download data in JPEG format";
+          break;
+        case "application/shapefile+zip":
+          label = "Shapefile+zip";
+          description = "Download data in Shapefile+zip format";
+          break;
+        case "application/x-zarr":
+          label = "ZARR";
+          description = "Download data in ZARR format";
+          break;
+        default:
+          label = format;
+          description = `Download data in ${format} format`;
+      }
+      outputFormats.push({
+        key: format,
+        label,
+        description
+      });
+    });
+    if (hasGiovanniServices && hasNonGiovanniServices) {
+      outputFormats.push(...giovanniFormats);
+    }
+    return outputFormats;
+  }
+};
+_request = new WeakSet();
+request_fn = function(url, options) {
+  let environmentUrl = HARMONY_URLS[Environments.PROD];
+  if (!(options == null ? void 0 : options.bearerToken)) {
+    environmentUrl = HARMONY_URLS.ANONYMOUS_ACCESS;
+  }
+  if (!url.startsWith("http")) {
+    url = `${environmentUrl}/${url}`;
+  }
+  return apiClient.get(url, {
+    signal: options == null ? void 0 : options.signal,
+    headers: __spreadValues({}, (options == null ? void 0 : options.bearerToken) && {
+      Authorization: `Bearer ${options.bearerToken}`
+    })
+  });
+};
+_hasGiovanniServices = new WeakSet();
+hasGiovanniServices_fn = function(capabilities) {
+  var _a, _b;
+  return (_b = (_a = capabilities == null ? void 0 : capabilities.services) == null ? void 0 : _a.some(
+    (service) => service.name.toLowerCase().includes("giovanni")
+  )) != null ? _b : false;
+};
+_hasNonGiovanniServices = new WeakSet();
+hasNonGiovanniServices_fn = function(capabilities) {
+  var _a, _b;
+  return (_b = (_a = capabilities == null ? void 0 : capabilities.services) == null ? void 0 : _a.some(
+    (service) => !service.name.toLowerCase().includes("giovanni")
+  )) != null ? _b : false;
+};
+_getNonGiovanniFormats = new WeakSet();
+getNonGiovanniFormats_fn = function(capabilities) {
+  if (!(capabilities == null ? void 0 : capabilities.services)) {
+    return [];
+  }
+  const nonGiovanniServices = capabilities.services.filter(
+    (service) => !service.name.toLowerCase().includes("giovanni")
+  );
+  const formats = /* @__PURE__ */ new Set();
+  nonGiovanniServices.forEach((service) => {
+    var _a;
+    (_a = service.capabilities.outputFormats) == null ? void 0 : _a.forEach((format) => {
+      formats.add(format);
+    });
+  });
+  const formatArray = Array.from(formats);
+  if (formatArray.includes("application/netcdf") && formatArray.includes("application/x-netcdf4")) {
+    return formatArray.filter((format) => format !== "application/netcdf");
+  }
+  return formatArray;
+};
+_getGiovanniFormats = new WeakSet();
+getGiovanniFormats_fn = function(capabilities) {
+  const giovanniFormats = [];
+  capabilities.services.forEach((service) => {
+    const serviceName = service.name.toLowerCase();
+    if (serviceName.includes("giovanni-time-series")) {
+      giovanniFormats.push({
+        key: "text/csv",
+        label: "CSV (point-based time series; one file)",
+        description: "Single variable plotted over time",
+        isGiovanniFormat: true
+      });
+    }
+    if (serviceName.includes("giovanni-averaging")) {
+      giovanniFormats.push(
+        {
+          key: "image/tiff",
+          label: "GeoTIFF (time-averaged map; one file)",
+          description: "Time averaged representation as map",
+          isGiovanniFormat: true
+        },
+        {
+          key: "text/csv",
+          label: "CSV (area-averaged time series; one file)",
+          description: "Area averaged data over time",
+          isGiovanniFormat: true
+        }
+      );
+    }
+  });
+  return giovanniFormats.filter(
+    (format, index, formats) => formats.findIndex((existing) => existing.label === format.label) === index
+  );
+};
+var harmonyApi = new HarmonyApi();
+
+// src/lib/thumbnails/thumbnail.service.ts
+init_dirname();
+init_buffer();
+init_process();
+var ThumbnailService = class {
+  async store(harmonyJobId, blob) {
+    await withDb(async (db) => {
+      const record = {
+        harmonyJobId,
+        blob,
+        createdAt: Date.now()
+      };
+      await db.put("thumbnails" /* THUMBNAILS */, record);
+    });
+  }
+  async get(harmonyJobId) {
+    return withDb(async (db) => {
+      const record = await db.get(
+        "thumbnails" /* THUMBNAILS */,
+        harmonyJobId
+      );
+      return record == null ? void 0 : record.blob;
+    });
+  }
+  async delete(harmonyJobId) {
+    await withDb(async (db) => {
+      await db.delete("thumbnails" /* THUMBNAILS */, harmonyJobId);
+    });
+  }
+};
+
+// src/queries/harmony.queries.ts
+init_dirname();
+init_buffer();
+init_process();
+var POLL_INTERVAL_MS = 3e3;
+var PAGE_1_POLL_INTERVAL_MS = 1e4;
+var thumbnailService = new ThumbnailService();
+function isFetchableHarmonyJobId(jobID) {
+  return Boolean(jobID && jobID !== "new");
+}
+function queryHarmonyCapabilities(collectionConceptId, options) {
+  return {
+    queryKey: ["harmony", "capabilities", collectionConceptId],
+    queryFn: async ({ signal }) => {
+      return harmonyApi.getCollectionCapabilities(collectionConceptId, __spreadProps(__spreadValues({}, options), {
+        signal
+      }));
+    },
+    enabled: !!collectionConceptId
+  };
+}
+function queryHarmonyJobs(params, options) {
+  return {
+    queryKey: ["harmony", "jobs", params],
+    queryFn: async ({ signal }) => {
+      const result = await harmonyApi.getJobs(params, __spreadProps(__spreadValues({}, options), {
+        signal
+      }));
+      const enrichedJobs = await Promise.all(
+        result.jobs.map(async (job) => {
+          const blob = await thumbnailService.get(job.jobID);
+          return blob ? __spreadProps(__spreadValues({}, job), { thumbnailBlob: blob }) : job;
+        })
+      );
+      return __spreadProps(__spreadValues({}, result), { jobs: enrichedJobs });
+    },
+    // require a bearer token to run
+    enabled: !!(options == null ? void 0 : options.bearerToken),
+    refetchInterval: () => {
+      if ((params == null ? void 0 : params.page) && params.page !== 1) {
+        return false;
+      }
+      return PAGE_1_POLL_INTERVAL_MS;
+    }
+  };
+}
+function queryHarmonyJobStatus(jobID, options) {
+  return {
+    queryKey: ["harmony", "jobs", jobID],
+    queryFn: async ({ signal }) => {
+      if (!isFetchableHarmonyJobId(jobID))
+        return null;
+      return harmonyApi.getJobStatus(jobID, __spreadProps(__spreadValues({}, options), { signal }));
+    },
+    enabled: isFetchableHarmonyJobId(jobID),
+    // Poll until the job reaches a final state
+    refetchInterval: (query) => {
+      var _a;
+      const status = (_a = query.state.data) == null ? void 0 : _a.status;
+      if (status && FINAL_STATUSES.has(status)) {
+        return false;
+      }
+      return POLL_INTERVAL_MS;
+    },
+    // Job status changes frequently while running; don't use stale data
+    staleTime: 0,
+    gcTime: 0
+  };
+}
+function queryCreateHarmonySubsetJob() {
+  return {
+    mutationFn: ({ harmonyRequest, options }) => harmonyApi.createJob(harmonyRequest, options)
+  };
+}
+function queryCancelHarmonySubsetJob() {
+  return {
+    mutationFn: ({ jobId, options }) => harmonyApi.cancelJob(jobId, options)
+  };
+}
+function mutationRemoveHarmonyJobLabels() {
+  return {
+    mutationFn: ({ jobIDs, labels, options }) => harmonyApi.removeJobLabels({ jobIDs, labels }, options)
+  };
+}
+
+export {
+  Environments,
+  HARMONY_URLS,
+  FINAL_STATUSES,
+  harmonyApi,
+  ThumbnailService,
+  queryHarmonyCapabilities,
+  queryHarmonyJobs,
+  queryHarmonyJobStatus,
+  queryCreateHarmonySubsetJob,
+  queryCancelHarmonySubsetJob,
+  mutationRemoveHarmonyJobLabels
+};

package/cdn/chunks/chunk.3JNJAOYG.js

@@ -0,0 +1,29 @@
+import {
+  TerraSiteHeader
+} from "./chunk.UPZ77TIQ.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/site-header/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "terra-site-header";
+TerraSiteHeader.define("terra-site-header");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraSiteHeader,
+  react: React,
+  events: {},
+  displayName: "TerraSiteHeader"
+});
+var site_header_default = reactWrapper;
+
+export {
+  site_header_default
+};

package/cdn/chunks/chunk.3JSWB4KI.js

@@ -0,0 +1,29 @@
+import {
+  TerraTabPanel
+} from "./chunk.AVVORU4X.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/tab-panel/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "terra-tab-panel";
+TerraTabPanel.define("terra-tab-panel");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraTabPanel,
+  react: React,
+  events: {},
+  displayName: "TerraTabPanel"
+});
+var tab_panel_default = reactWrapper;
+
+export {
+  tab_panel_default
+};

package/cdn/chunks/chunk.3QD75UYK.js

@@ -0,0 +1,19 @@
+import {
+  TerraDataRods
+} from "./chunk.4R6XKFRJ.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/data-rods/data-rods.ts
+init_dirname();
+init_buffer();
+init_process();
+var data_rods_default = TerraDataRods;
+TerraDataRods.define("terra-data-rods");
+
+export {
+  data_rods_default
+};

package/cdn/chunks/chunk.3ZXOZBXL.js

@@ -0,0 +1,99 @@
+import {
+  login_styles_default
+} from "./chunk.GWVXU5WI.js";
+import {
+  loader_default
+} from "./chunk.U4QWGOTS.js";
+import {
+  AuthController
+} from "./chunk.P34Y4ETY.js";
+import {
+  icon_default
+} from "./chunk.DNDC4SZO.js";
+import {
+  button_default
+} from "./chunk.EKPJRKBR.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n
+} from "./chunk.UME44J4L.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/login/login.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var _authController, _applyUserToMessage, applyUserToMessage_fn;
+var TerraLogin = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _applyUserToMessage);
+    this.buttonLabel = "Earthdata Login";
+    __privateAdd(this, _authController, new AuthController(this));
+  }
+  login() {
+    __privateGet(this, _authController).login();
+  }
+  logout() {
+    __privateGet(this, _authController).logout();
+  }
+  render() {
+    var _a;
+    if ((_a = __privateGet(this, _authController).state.user) == null ? void 0 : _a.uid) {
+      const template = this.querySelector(
+        'template[slot="logged-in"]'
+      );
+      return b`${template ? template.content.cloneNode(true) : b`<slot name="logged-in" .user=${__privateGet(this, _authController).state.user}
+                      >${__privateMethod(this, _applyUserToMessage, applyUserToMessage_fn).call(this, this.loggedInMessage)}</slot
+                  >`}`;
+    }
+    if (__privateGet(this, _authController).state.isLoading) {
+      return b`<slot name="loading">${this.loadingMessage}</slot>`;
+    }
+    return b` <slot name="logged-out">${this.loggedOutMessage}</slot
+            ><terra-button @click=${this.login}> ${this.buttonLabel}</terra-button>`;
+  }
+};
+_authController = new WeakMap();
+_applyUserToMessage = new WeakSet();
+applyUserToMessage_fn = function(message) {
+  var _a, _b, _c, _d, _e, _f;
+  return (message != null ? message : "").replace("{username}", (_b = (_a = __privateGet(this, _authController).state.user) == null ? void 0 : _a.uid) != null ? _b : "").replace(
+    "{first_name}",
+    (_d = (_c = __privateGet(this, _authController).state.user) == null ? void 0 : _c.first_name) != null ? _d : ""
+  ).replace("{last_name}", (_f = (_e = __privateGet(this, _authController).state.user) == null ? void 0 : _e.last_name) != null ? _f : "");
+};
+TerraLogin.dependencies = {
+  "terra-button": button_default,
+  "terra-icon": icon_default,
+  "terra-loader": loader_default
+};
+TerraLogin.styles = [component_styles_default, login_styles_default];
+__decorateClass([
+  n({ attribute: "button-label" })
+], TerraLogin.prototype, "buttonLabel", 2);
+__decorateClass([
+  n({ attribute: "logged-in-message" })
+], TerraLogin.prototype, "loggedInMessage", 2);
+__decorateClass([
+  n({ attribute: "logged-out-message" })
+], TerraLogin.prototype, "loggedOutMessage", 2);
+__decorateClass([
+  n({ attribute: "loading-message" })
+], TerraLogin.prototype, "loadingMessage", 2);
+
+export {
+  TerraLogin
+};

package/cdn/chunks/chunk.4AANKT2Q.js

@@ -0,0 +1,34 @@
+import {
+  TerraRadioGroup
+} from "./chunk.BKJ6ERUE.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/radio-group/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-radio-group";
+TerraRadioGroup.define("terra-radio-group");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraRadioGroup,
+  react: React,
+  events: {
+    onTerraChange: "terra-change",
+    onTerraInput: "terra-input",
+    onTerraInvalid: "terra-invalid"
+  },
+  displayName: "TerraRadioGroup"
+});
+var radio_group_default = reactWrapper;
+
+export {
+  radio_group_default
+};