@nasa-terra/components 0.0.195 → 0.0.197

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

@@ -0,0 +1,195 @@
+import {
+  scroll_hint_styles_default
+} from "./chunk.BDLK2MCA.js";
+import {
+  e
+} from "./chunk.KGXAA5I2.js";
+import {
+  TerraIcon
+} from "./chunk.UD7NUYVG.js";
+import {
+  watch
+} from "./chunk.MPVZOQYA.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n,
+  r
+} from "./chunk.W56KFXW3.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/scroll-hint/scroll-hint.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraScrollHint = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.inline = false;
+    this.inverse = false;
+    this.inactivityDelay = 3e3;
+    this.visible = false;
+    this.handleScroll = () => {
+      if (this.inline) {
+        return;
+      }
+      const isAtBottom = this.isAtBottomOfPage();
+      if (isAtBottom) {
+        if (this.visible) {
+          this.hide();
+        }
+        this.clearTimers();
+      } else {
+        if (this.visible) {
+          this.hide();
+          this.startInactivityTimer();
+        }
+      }
+    };
+    this.handleDocumentClick = (e2) => {
+      if (this.contains(e2.target)) {
+        return;
+      }
+      if (!this.inline && this.visible) {
+        this.hide();
+        this.startInactivityTimer();
+      }
+    };
+    this.handleClick = () => {
+      this.emit("terra-scroll");
+      if (!this.inline) {
+        this.hide();
+        setTimeout(() => {
+          this.startInactivityTimer();
+        }, 100);
+      }
+      this.scrollDown();
+    };
+  }
+  handleInlineChange() {
+    if (this.inline) {
+      this.visible = true;
+      this.clearTimers();
+    } else {
+      this.visible = false;
+      this.clearTimers();
+      this.startInactivityTimer();
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.setupEventListeners();
+    if (this.inline) {
+      this.visible = true;
+    } else {
+      this.startInactivityTimer();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.cleanupEventListeners();
+    this.clearTimers();
+  }
+  setupEventListeners() {
+    window.addEventListener("scroll", this.handleScroll, { passive: true });
+    document.addEventListener("click", this.handleDocumentClick);
+  }
+  cleanupEventListeners() {
+    window.removeEventListener("scroll", this.handleScroll);
+    document.removeEventListener("click", this.handleDocumentClick);
+  }
+  isAtBottomOfPage() {
+    const windowHeight = window.innerHeight;
+    const documentHeight = document.documentElement.scrollHeight;
+    const scrollTop = window.scrollY || document.documentElement.scrollTop;
+    const threshold = 100;
+    return scrollTop + windowHeight >= documentHeight - threshold;
+  }
+  scrollDown() {
+    const viewportHeight = window.innerHeight;
+    window.scrollBy({
+      top: viewportHeight,
+      behavior: "smooth"
+    });
+  }
+  hide() {
+    this.visible = false;
+    this.clearTimers();
+  }
+  startInactivityTimer() {
+    if (this.inline) {
+      return;
+    }
+    if (this.isAtBottomOfPage()) {
+      return;
+    }
+    this.inactivityTimeout = window.setTimeout(() => {
+      if (!this.isAtBottomOfPage()) {
+        this.visible = true;
+      }
+    }, this.inactivityDelay);
+  }
+  clearTimers() {
+    clearTimeout(this.scrollTimeout);
+    clearTimeout(this.clickTimeout);
+    clearTimeout(this.inactivityTimeout);
+  }
+  render() {
+    if (!this.visible) {
+      return b``;
+    }
+    return b`
+            <button
+                part="button"
+                class=${e({
+      "scroll-hint": true,
+      inverse: this.inverse
+    })}
+                @click="${this.handleClick}"
+                aria-label="Scroll to continue"
+            >
+                <div part="icon-container" class="scroll-hint__icon-container">
+                    <div part="ring" class="scroll-hint__ring"></div>
+                    <div part="icon" class="scroll-hint__icon">
+                        <terra-icon
+                            name="chevron-down"
+                            library="default"
+                        ></terra-icon>
+                    </div>
+                </div>
+                <span part="text" class="scroll-hint__text">SCROLL TO CONTINUE</span>
+            </button>
+        `;
+  }
+};
+TerraScrollHint.styles = [component_styles_default, scroll_hint_styles_default];
+TerraScrollHint.dependencies = {
+  "terra-icon": TerraIcon
+};
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraScrollHint.prototype, "inline", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], TerraScrollHint.prototype, "inverse", 2);
+__decorateClass([
+  n({ type: Number })
+], TerraScrollHint.prototype, "inactivityDelay", 2);
+__decorateClass([
+  r()
+], TerraScrollHint.prototype, "visible", 2);
+__decorateClass([
+  watch("inline")
+], TerraScrollHint.prototype, "handleInlineChange", 1);
+
+export {
+  TerraScrollHint
+};

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

@@ -0,0 +1,32 @@
+import {
+  TerraVariableCombobox
+} from "./chunk.4GLQ2KWQ.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/variable-combobox/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-variable-combobox";
+TerraVariableCombobox.define("terra-variable-combobox");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraVariableCombobox,
+  react: React,
+  events: {
+    onTerraComboboxChange: "terra-combobox-change"
+  },
+  displayName: "TerraVariableCombobox"
+});
+var variable_combobox_default = reactWrapper;
+
+export {
+  variable_combobox_default
+};

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.632TYPZK.js

@@ -0,0 +1,19 @@
+import {
+  TerraDataGrid
+} from "./chunk.RIJPJNZ6.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/data-grid/data-grid.ts
+init_dirname();
+init_buffer();
+init_process();
+var data_grid_default = TerraDataGrid;
+TerraDataGrid.define("terra-data-grid");
+
+export {
+  data_grid_default
+};