@nasa-terra/components 0.0.194 → 0.0.196

package/cdn/chunks/chunk.5YAN7WHN.js

@@ -0,0 +1,394 @@
+import {
+  simplifyToPointLimit
+} from "./chunk.USKVG5GU.js";
+import {
+  Environments,
+  HARMONY_URLS
+} from "./chunk.I7HUTXHU.js";
+import {
+  LatLngBounds
+} from "./chunk.B2HOZPO6.js";
+import {
+  LatLng
+} from "./chunk.Y3EV6C6T.js";
+import {
+  MutationObserver
+} from "./chunk.YY3ZUPZV.js";
+import {
+  BadRequestException
+} from "./chunk.SYQOGYTQ.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/controllers/mutation.controller.ts
+init_dirname();
+init_buffer();
+init_process();
+var _observer, _unsubscribe;
+var MutationController = class {
+  constructor(host, options) {
+    this.host = host;
+    __privateAdd(this, _observer, void 0);
+    __privateAdd(this, _unsubscribe, void 0);
+    this.host.addController(this);
+    __privateSet(this, _observer, new MutationObserver(host.queryClient, options));
+  }
+  /**
+   * Trigger the mutation with the given variables.
+   * Returns a promise that resolves with the mutation result data.
+   */
+  mutate(variables) {
+    return __privateGet(this, _observer).mutate(variables);
+  }
+  /**
+   * Reset the mutation back to its idle state.
+   */
+  reset() {
+    __privateGet(this, _observer).reset();
+    this.host.requestUpdate();
+  }
+  hostConnected() {
+    __privateSet(this, _unsubscribe, __privateGet(this, _observer).subscribe((result) => {
+      this.result = result;
+      this.host.requestUpdate();
+    }));
+  }
+  hostDisconnected() {
+    var _a;
+    (_a = __privateGet(this, _unsubscribe)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _unsubscribe, void 0);
+  }
+};
+_observer = new WeakMap();
+_unsubscribe = new WeakMap();
+
+// src/lib/harmony/harmony.request.ts
+init_dirname();
+init_buffer();
+init_process();
+var _options;
+var _HarmonyRequest = class _HarmonyRequest {
+  constructor(options) {
+    __privateAdd(this, _options, void 0);
+    var _a;
+    __privateSet(this, _options, __spreadValues({}, options));
+    __privateGet(this, _options).variables = void 0;
+    (_a = options == null ? void 0 : options.variables) == null ? void 0 : _a.forEach((v) => {
+      this.variable(v);
+    });
+    if (options == null ? void 0 : options.environment) {
+      this.environment(options.environment.toUpperCase());
+    }
+  }
+  get requestUrl() {
+    return `${this.baseUrl}?${this.params}`;
+  }
+  get hasShape() {
+    return !!__privateGet(this, _options).shape;
+  }
+  /**
+   * Builds a multipart FormData body for shape (polygon) subsetting.
+   * All request params are appended as form fields (no query string).
+   * The GeoJSON shape is appended as a `shapefile` file field.
+   * Per HARMONY-290, Harmony cannot accept both files and query params simultaneously.
+   */
+  buildFormData() {
+    const formData = new FormData();
+    const searchParams = new URLSearchParams(this.params);
+    searchParams.forEach((value, key) => {
+      formData.append(key, value);
+    });
+    const geoJson = __privateGet(this, _options).shape;
+    if (!geoJson) {
+      throw new BadRequestException({
+        message: "shape is required to build form data"
+      });
+    }
+    const simplifiedGeoJson = simplifyToPointLimit(geoJson, 5e3);
+    const blob = new Blob([JSON.stringify(simplifiedGeoJson)], {
+      type: "application/geo+json"
+    });
+    formData.append("shapefile", blob, "shape.geojson");
+    return formData;
+  }
+  get baseUrl() {
+    const { environment, collectionConceptId, variableConceptIds, variables } = __privateGet(this, _options);
+    if (!collectionConceptId) {
+      throw new BadRequestException({
+        message: "Collection concept id is required"
+      });
+    }
+    const harmonyUrl = HARMONY_URLS[environment != null ? environment : Environments.PROD];
+    const joinedVariables = (variables == null ? void 0 : variables.length) ? (
+      // If variables are present, use parameter_vars in the URL
+      // and the variables will be added as ?variable= params instead
+      "parameter_vars"
+    ) : (
+      // otherwise we'll include the variable concept ids in the OGC API url
+      Array.isArray(variableConceptIds) ? variableConceptIds.join(",") : variableConceptIds
+    );
+    return `${harmonyUrl}/${collectionConceptId}/ogc-api-coverages/1.0.0/collections/${joinedVariables || "all"}/coverage/rangeset`;
+  }
+  get params() {
+    const params = new URLSearchParams();
+    const {
+      location,
+      startDate,
+      endDate,
+      format,
+      labels,
+      variables,
+      average,
+      anonymous,
+      dimensions,
+      skipPreview
+    } = __privateGet(this, _options);
+    if (location instanceof LatLng) {
+      params.append("point", `${location.lng},${location.lat}`);
+    } else if (location instanceof LatLngBounds) {
+      params.append(
+        "subset",
+        `lat(${location.getSouth()}:${location.getNorth()})`
+      );
+      params.append(
+        "subset",
+        `lon(${location.getWest()}:${location.getEast()})`
+      );
+    }
+    if (startDate) {
+      params.append("subset", `time("${startDate}":"${endDate != null ? endDate : startDate}")`);
+    }
+    if (dimensions && dimensions.length > 0) {
+      dimensions.forEach((dim) => {
+        params.append("subset", `${dim.name}(${dim.min}:${dim.max})`);
+      });
+    }
+    if (format) {
+      params.append("format", format);
+    }
+    labels == null ? void 0 : labels.forEach((label) => {
+      params.append("label", label);
+    });
+    variables == null ? void 0 : variables.forEach((v) => {
+      params.append("variable", v);
+    });
+    if (average) {
+      params.append("average", average);
+    }
+    if (anonymous) {
+      params.append("maxResults", "10");
+    }
+    if (typeof skipPreview === "boolean" && !skipPreview) {
+      params.append("skipPreview", "false");
+    } else {
+      params.append("skipPreview", "true");
+    }
+    params.append("forceAsync", "true");
+    return params.toString();
+  }
+  get options() {
+    return __privateGet(this, _options);
+  }
+  set(patch) {
+    __privateSet(this, _options, __spreadValues(__spreadValues({}, __privateGet(this, _options)), patch));
+    return this;
+  }
+  /**
+   * Helper method to get a label value by prefix, e.g. getLabelByPrefix('instrument-short-name') will return the value of the label that starts with 'instrument-short-name:'
+   */
+  getLabelByPrefix(prefix) {
+    var _a;
+    const label = (_a = __privateGet(this, _options).labels) == null ? void 0 : _a.find((l) => l.startsWith(`${prefix}:`));
+    const value = label ? label.split(":")[1].trim() : void 0;
+    return value !== "NOT APPLICABLE" ? value : void 0;
+  }
+  environment(environment) {
+    return this.set({ environment });
+  }
+  collection(collectionConceptId) {
+    return this.set({ collectionConceptId });
+  }
+  variable(variable) {
+    var _a, _b;
+    if (this.isVariableConceptId(variable)) {
+      return this.set({
+        variableConceptIds: [
+          ...(_a = __privateGet(this, _options).variableConceptIds) != null ? _a : [],
+          variable
+        ]
+      });
+    }
+    return this.set({
+      variables: [...(_b = __privateGet(this, _options).variables) != null ? _b : [], variable]
+    });
+  }
+  location(location) {
+    return this.set({ location });
+  }
+  shape(shape) {
+    return this.set({ shape });
+  }
+  dateRange(startDate, endDate) {
+    return this.set({
+      startDate,
+      endDate
+    });
+  }
+  startDate(startDate) {
+    return this.set({ startDate });
+  }
+  endDate(endDate) {
+    return this.set({ endDate });
+  }
+  format(format) {
+    return this.set({ format });
+  }
+  label(label) {
+    var _a;
+    return this.set({
+      labels: [...(_a = __privateGet(this, _options).labels) != null ? _a : [], label]
+    });
+  }
+  addLabelsFromVariable(variable) {
+    this.label(
+      `collection: ${variable.dataProductShortName}_${variable.dataProductVersion}`
+    );
+    this.label(
+      `variable-display-name: ${variable.dataFieldLongName || variable.dataFieldId}`
+    );
+    this.label(
+      `instrument-short-name: ${variable.dataProductInstrumentShortName}`
+    );
+    this.label(`time-interval: ${variable.dataProductTimeInterval}`);
+    this.label(`units: ${variable.dataFieldUnits}`);
+    return this;
+  }
+  average(average) {
+    return this.set({ average });
+  }
+  dimension(dimension) {
+    var _a;
+    return this.set({
+      dimensions: [...(_a = __privateGet(this, _options).dimensions) != null ? _a : [], dimension]
+    });
+  }
+  skipPreview(skipPreview) {
+    return this.set({ skipPreview });
+  }
+  isVariableConceptId(value) {
+    return /^V\d+-.+$/.test(value);
+  }
+  /**
+   * given a Harmony request, determines the most appropriate Terra icon to represent it.
+   */
+  getTerraIcon() {
+    var _a;
+    if ((_a = this.options.labels) == null ? void 0 : _a.includes("terra-time-average-map")) {
+      return "outline-map";
+    }
+    return "outline-chart-bar";
+  }
+  /**
+   * Parses a Harmony OGC request URL and returns a HarmonyRequest instance
+   * with the corresponding options populated.
+   *
+   * @example
+   * const request = HarmonyRequest.fromUrl(
+   *   'https://harmony.earthdata.nasa.gov/C2723754847-GES_DISC/ogc-api-coverages/1.0.0/collections/parameter_vars/coverage/rangeset?subset=lat(5:40)&subset=lon(62:95)&format=text%2Fcsv'
+   * )
+   */
+  static fromUrl(url) {
+    var _a, _b, _c;
+    if (!url) {
+      return new _HarmonyRequest();
+    }
+    const parsed = new URL(url);
+    let environment;
+    if (parsed.origin === HARMONY_URLS[Environments.PROD]) {
+      environment = Environments.PROD;
+    } else if (parsed.origin === HARMONY_URLS[Environments.UAT]) {
+      environment = Environments.UAT;
+    }
+    const pathParts = parsed.pathname.split("/");
+    const collectionConceptId = pathParts[1] || void 0;
+    const collectionsValue = pathParts[5];
+    let variableConceptIds;
+    if (collectionsValue && collectionsValue !== "parameter_vars" && collectionsValue !== "all") {
+      variableConceptIds = collectionsValue.split(",");
+    }
+    const subsets = parsed.searchParams.getAll("subset");
+    let south;
+    let north;
+    let west;
+    let east;
+    let startDate;
+    let endDate;
+    const dimensions = [];
+    for (const subset of subsets) {
+      const latMatch = subset.match(/^lat\((.+):(.+)\)$/);
+      const lonMatch = subset.match(/^lon\((.+):(.+)\)$/);
+      const timeMatch = subset.match(/^time\("(.+)":"(.+)"\)$/);
+      const dimMatch = subset.match(/^(\w+)\((.+):(.+)\)$/);
+      if (latMatch) {
+        south = parseFloat(latMatch[1]);
+        north = parseFloat(latMatch[2]);
+      } else if (lonMatch) {
+        west = parseFloat(lonMatch[1]);
+        east = parseFloat(lonMatch[2]);
+      } else if (timeMatch) {
+        startDate = timeMatch[1];
+        endDate = timeMatch[2];
+      } else if (dimMatch) {
+        dimensions.push({
+          name: dimMatch[1],
+          min: parseFloat(dimMatch[2]),
+          max: parseFloat(dimMatch[3])
+        });
+      }
+    }
+    let location;
+    if (south !== void 0 && north !== void 0 && west !== void 0 && east !== void 0) {
+      location = new LatLngBounds([west, south, east, north]);
+    }
+    const point = parsed.searchParams.get("point");
+    if (point) {
+      const [lng, lat] = point.split(",").map(Number);
+      location = new LatLng(lat, lng);
+    }
+    const format = (_a = parsed.searchParams.get("format")) != null ? _a : void 0;
+    const label = (_b = parsed.searchParams.getAll("label")) != null ? _b : void 0;
+    const labels = label && label.length > 0 ? label : void 0;
+    const variables = parsed.searchParams.getAll("variable");
+    const average = (_c = parsed.searchParams.get("average")) != null ? _c : void 0;
+    const anonymous = parsed.searchParams.get("maxResults") === "10" ? true : void 0;
+    return new _HarmonyRequest({
+      environment,
+      collectionConceptId,
+      variableConceptIds,
+      variables: variables.length > 0 ? variables : void 0,
+      location,
+      startDate,
+      endDate,
+      format,
+      labels,
+      average,
+      anonymous,
+      dimensions: dimensions.length > 0 ? dimensions : void 0
+    });
+  }
+};
+_options = new WeakMap();
+var HarmonyRequest = _HarmonyRequest;
+
+export {
+  MutationController,
+  HarmonyRequest
+};
+//! force async responses. We ALWAYS want a job returned, never a redirect

package/cdn/chunks/chunk.64ERL7PM.js

@@ -0,0 +1,47 @@
+import {
+  breadcrumbs_styles_default
+} from "./chunk.L3N5U2RI.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n
+} from "./chunk.S7PDZNJ7.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/breadcrumbs/breadcrumbs.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraBreadcrumbs = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.ariaLabel = "Breadcrumb";
+    this.theme = "light";
+  }
+  render() {
+    return b`
+            <nav part="base nav" class="breadcrumbs" aria-label=${this.ariaLabel}>
+                <slot></slot>
+            </nav>
+        `;
+  }
+};
+TerraBreadcrumbs.styles = [component_styles_default, breadcrumbs_styles_default];
+__decorateClass([
+  n({ attribute: "aria-label" })
+], TerraBreadcrumbs.prototype, "ariaLabel", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraBreadcrumbs.prototype, "theme", 2);
+
+export {
+  TerraBreadcrumbs
+};

package/cdn/chunks/chunk.6CYW3DVI.js

@@ -0,0 +1,32 @@
+import {
+  TerraPagination
+} from "./chunk.JB45ZCDW.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/pagination/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-pagination";
+TerraPagination.define("terra-pagination");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraPagination,
+  react: React,
+  events: {
+    onTerraPageChange: "terra-page-change"
+  },
+  displayName: "TerraPagination"
+});
+var pagination_default = reactWrapper;
+
+export {
+  pagination_default
+};

package/cdn/chunks/chunk.6F6HMPVP.js

@@ -0,0 +1,19 @@
+import {
+  TerraStatusIndicator
+} from "./chunk.YMF7GUWM.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/status-indicator/status-indicator.ts
+init_dirname();
+init_buffer();
+init_process();
+var status_indicator_default = TerraStatusIndicator;
+TerraStatusIndicator.define("terra-status-indicator");
+
+export {
+  status_indicator_default
+};

package/cdn/chunks/chunk.6KAFOY3C.js

@@ -0,0 +1,29 @@
+import {
+  TerraSiteHeader
+} from "./chunk.MQJHEK6X.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.6KPB7NHN.js

@@ -0,0 +1,19 @@
+import {
+  TerraButtonGroup
+} from "./chunk.NW5KR3BI.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/button-group/button-group.ts
+init_dirname();
+init_buffer();
+init_process();
+var button_group_default = TerraButtonGroup;
+TerraButtonGroup.define("terra-button-group");
+
+export {
+  button_group_default
+};