@nasa-terra/components 0.0.193 → 0.0.195

package/cdn/chunks/chunk.I7HUTXHU.js

@@ -0,0 +1,479 @@
+import {
+  withDb
+} from "./chunk.GPH5N6EA.js";
+import {
+  apiClient
+} from "./chunk.LXHT72SA.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 _HarmonyApi {
+  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);
+    capabilities.summary.subsetting.temporal = true;
+    capabilities.summary.subsetting.bbox = true;
+    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.
+   * When the request includes a shape, sends a multipart POST with all params in the
+   * form body alongside the shapefile (per HARMONY-290, query params + file upload
+   * cannot be combined).
+   */
+  async createJob(harmonyRequest, options) {
+    if (harmonyRequest.hasShape) {
+      return __privateMethod(this, _request, request_fn).call(this, harmonyRequest.baseUrl, options, harmonyRequest.buildFormData());
+    }
+    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) {
+    const status = await __privateMethod(this, _request, request_fn).call(this, `jobs/${jobId}`, options);
+    status.links = status.links.map((link) => _HarmonyApi.normalizeJobLink(link));
+    return status;
+  }
+  /**
+   * Normalizes a job link so that data links with a missing or generic title
+   * ("OPeNDAP Request URL") get a more informative title derived from the href.
+   * Everything after `/granules/` in the URL is used; if that segment is not
+   * present the full href is used as a fallback.
+   */
+  static normalizeJobLink(link) {
+    const isFallbackTitle = !link.title || link.title === "OPeNDAP Request URL" || link.title === "OPeNAP Request URL";
+    if (!isFallbackTitle || link.rel !== "data")
+      return link;
+    const granulesIdx = link.href.indexOf("/granules/");
+    const title = granulesIdx !== -1 ? link.href.slice(granulesIdx + "/granules/".length) : link.href;
+    return __spreadProps(__spreadValues({}, link), { title });
+  }
+  /**
+   * 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, body) {
+  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}`;
+  } else if (!(options == null ? void 0 : options.bearerToken)) {
+    url = url.replace(
+      HARMONY_URLS[Environments.PROD],
+      HARMONY_URLS.ANONYMOUS_ACCESS
+    ).replace(
+      HARMONY_URLS[Environments.UAT],
+      HARMONY_URLS.ANONYMOUS_ACCESS
+    );
+  }
+  const headers = __spreadValues({}, (options == null ? void 0 : options.bearerToken) && {
+    Authorization: `Bearer ${options.bearerToken}`
+  });
+  if (body) {
+    return apiClient.post(url, body, {
+      signal: options == null ? void 0 : options.signal,
+      headers
+    });
+  }
+  return apiClient.get(url, {
+    signal: options == null ? void 0 : options.signal,
+    headers
+  });
+};
+_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) => {
+      if (typeof format !== "string" && "mimeType" in format) {
+        formats.add(format.mimeType);
+      } else {
+        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 = _HarmonyApi;
+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
+};
+//! Requested 9/02/2026 to always show temporal selections in the subsetter.
+//! For services with no temporal subsetting, Harmony will fetch ALL granules.
+//! By setting temporal and bbox to true, Harmony will query CMR for a subset of granules instead, much more performant

package/cdn/chunks/chunk.I7NMTC5Q.js

@@ -0,0 +1,34 @@
+import {
+  TerraRadioGroup
+} from "./chunk.CG3UKDID.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
+};

package/cdn/chunks/chunk.IBA4NRT7.js

@@ -0,0 +1,86 @@
+import {
+  accordion_styles_default
+} from "./chunk.ZMYIQBKE.js";
+import {
+  TerraIcon
+} from "./chunk.YL6WAIUW.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n
+} from "./chunk.MUSV5WD7.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/accordion/accordion.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraAccordion = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.open = false;
+    this.showArrow = true;
+  }
+  render() {
+    return b`
+            <details
+                class="accordion"
+                ?open=${this.open}
+                @toggle=${this.handleToggle}
+            >
+                <summary class="accordion-summary">
+                    <slot name="summary"> ${this.summary} </slot>
+
+                    <div class="accordion-summary-right">
+                        <slot name="summary-right"></slot>
+
+                        ${this.showArrow && b`
+                            <terra-icon
+                                name="chevron-down-circle"
+                                font-size="24px"
+                            ></terra-icon>
+                        `}
+                    </div>
+                </summary>
+
+                <div class="accordion-content">
+                    <slot></slot>
+                </div>
+            </details>
+        `;
+  }
+  handleToggle(e) {
+    const details = e.currentTarget;
+    this.open = details.open;
+    this.emit("terra-accordion-toggle", {
+      detail: {
+        open: this.open
+      }
+    });
+  }
+};
+TerraAccordion.styles = [component_styles_default, accordion_styles_default];
+TerraAccordion.dependencies = {
+  "terra-icon": TerraIcon
+};
+__decorateClass([
+  n()
+], TerraAccordion.prototype, "summary", 2);
+__decorateClass([
+  n({ reflect: true, type: Boolean })
+], TerraAccordion.prototype, "open", 2);
+__decorateClass([
+  n({ type: Boolean })
+], TerraAccordion.prototype, "showArrow", 2);
+
+export {
+  TerraAccordion
+};

package/cdn/chunks/chunk.JAMUELKA.js

@@ -0,0 +1,19 @@
+import {
+  TerraCaption
+} from "./chunk.ZDTHRWMK.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/caption/caption.ts
+init_dirname();
+init_buffer();
+init_process();
+var caption_default = TerraCaption;
+TerraCaption.define("terra-caption");
+
+export {
+  caption_default
+};

package/cdn/chunks/chunk.JIEFAMLF.js

@@ -0,0 +1,19 @@
+import {
+  TerraStepperStep
+} from "./chunk.24DUJHDK.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/stepper-step/stepper-step.ts
+init_dirname();
+init_buffer();
+init_process();
+var stepper_step_default = TerraStepperStep;
+TerraStepperStep.define("terra-stepper-step");
+
+export {
+  stepper_step_default
+};