@nasa-terra/components 0.0.186 → 0.0.187

package/cdn/chunks/chunk.S7HWCBS4.js

@@ -0,0 +1,35 @@
+import {
+  TerraDropdown
+} from "./chunk.5YFLB32J.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/dropdown/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-dropdown";
+TerraDropdown.define("terra-dropdown");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraDropdown,
+  react: React,
+  events: {
+    onTerraShow: "terra-show",
+    onTerraAfterShow: "terra-after-show",
+    onTerraHide: "terra-hide",
+    onTerraAfterHide: "terra-after-hide"
+  },
+  displayName: "TerraDropdown"
+});
+var dropdown_default = reactWrapper;
+
+export {
+  dropdown_default
+};

package/cdn/chunks/chunk.SAPVRSGJ.js

@@ -0,0 +1,19 @@
+import {
+  TerraBadge
+} from "./chunk.QSPMY3AQ.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/badge/badge.ts
+init_dirname();
+init_buffer();
+init_process();
+var badge_default = TerraBadge;
+TerraBadge.define("terra-badge");
+
+export {
+  badge_default
+};

package/cdn/chunks/chunk.SDPXNKVX.js

@@ -0,0 +1,34 @@
+import {
+  TerraTimeSeries
+} from "./chunk.6HWWEPDA.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/time-series/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-time-series";
+TerraTimeSeries.define("terra-time-series");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraTimeSeries,
+  react: React,
+  events: {
+    onTerraDateRangeChange: "terra-date-range-change",
+    onTerraTimeSeriesDataChange: "terra-time-series-data-change",
+    onTerraHarmonyJobStatusUpdate: "terra-harmony-job-status-update"
+  },
+  displayName: "TerraTimeSeries"
+});
+var time_series_default = reactWrapper;
+
+export {
+  time_series_default
+};

package/cdn/chunks/chunk.SGPHCDAA.js

@@ -0,0 +1,123 @@
+import {
+  avatar_styles_default
+} from "./chunk.2KIRSUMB.js";
+import {
+  TerraIcon
+} from "./chunk.AW3SAWPB.js";
+import {
+  e
+} from "./chunk.KGXAA5I2.js";
+import {
+  watch
+} from "./chunk.MPVZOQYA.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n,
+  r
+} from "./chunk.UME44J4L.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/avatar/avatar.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraAvatar = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.hasError = false;
+    this.image = "";
+    this.label = "";
+    this.initials = "";
+    this.loading = "eager";
+    this.shape = "circle";
+  }
+  handleImageChange() {
+    this.hasError = false;
+  }
+  handleImageLoadError() {
+    this.hasError = true;
+    this.emit("terra-error");
+  }
+  render() {
+    const avatarWithImage = b`
+            <img
+                part="image"
+                class="avatar__image"
+                src="${this.image}"
+                loading="${this.loading}"
+                alt=""
+                @error="${this.handleImageLoadError}"
+            />
+        `;
+    let avatarWithoutImage = b``;
+    if (this.initials) {
+      avatarWithoutImage = b`<div part="initials" class="avatar__initials">
+                ${this.initials}
+            </div>`;
+    } else {
+      avatarWithoutImage = b`
+                <div part="icon" class="avatar__icon" aria-hidden="true">
+                    <slot name="icon">
+                        <terra-icon
+                            name="solid-user"
+                            library="heroicons"
+                        ></terra-icon>
+                    </slot>
+                </div>
+            `;
+    }
+    return b`
+            <div
+                part="base"
+                class=${e({
+      avatar: true,
+      "avatar--circle": this.shape === "circle",
+      "avatar--rounded": this.shape === "rounded",
+      "avatar--square": this.shape === "square"
+    })}
+                role="img"
+                aria-label=${this.label}
+            >
+                ${this.image && !this.hasError ? avatarWithImage : avatarWithoutImage}
+            </div>
+        `;
+  }
+};
+TerraAvatar.styles = [component_styles_default, avatar_styles_default];
+TerraAvatar.dependencies = {
+  "terra-icon": TerraIcon
+};
+__decorateClass([
+  r()
+], TerraAvatar.prototype, "hasError", 2);
+__decorateClass([
+  n()
+], TerraAvatar.prototype, "image", 2);
+__decorateClass([
+  n()
+], TerraAvatar.prototype, "label", 2);
+__decorateClass([
+  n()
+], TerraAvatar.prototype, "initials", 2);
+__decorateClass([
+  n()
+], TerraAvatar.prototype, "loading", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraAvatar.prototype, "shape", 2);
+__decorateClass([
+  watch("image")
+], TerraAvatar.prototype, "handleImageChange", 1);
+
+export {
+  TerraAvatar
+};

package/cdn/chunks/chunk.SP3MVXEA.js

@@ -0,0 +1,352 @@
+import {
+  Environments,
+  HARMONY_URLS
+} from "./chunk.36G5VRI3.js";
+import {
+  LatLngBounds
+} from "./chunk.EABQJ4NF.js";
+import {
+  LatLng
+} from "./chunk.SN3T4SQP.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 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
+    } = __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");
+    }
+    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 });
+  }
+  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
+};

package/cdn/chunks/chunk.SPLYKQYF.js

@@ -0,0 +1,19 @@
+import {
+  TerraInput
+} from "./chunk.2RJFUFJW.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/input/input.ts
+init_dirname();
+init_buffer();
+init_process();
+var input_default = TerraInput;
+TerraInput.define("terra-input");
+
+export {
+  input_default
+};

package/cdn/chunks/chunk.SQ6V5DXM.js

@@ -0,0 +1,19 @@
+import {
+  TerraDateRangeSlider
+} from "./chunk.WEUS3VPS.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/date-range-slider/date-range-slider.ts
+init_dirname();
+init_buffer();
+init_process();
+var date_range_slider_default = TerraDateRangeSlider;
+TerraDateRangeSlider.define("terra-date-range-slider");
+
+export {
+  date_range_slider_default
+};

package/cdn/chunks/chunk.SY2T7H3K.js

@@ -0,0 +1,32 @@
+import {
+  TerraEarthdataLogin
+} from "./chunk.NLF3KNQ5.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/earthdata-login/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-earthdata-login";
+TerraEarthdataLogin.define("terra-earthdata-login");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraEarthdataLogin,
+  react: React,
+  events: {
+    onTerraLogin: "terra-login"
+  },
+  displayName: "TerraEarthdataLogin"
+});
+var earthdata_login_default = reactWrapper;
+
+export {
+  earthdata_login_default
+};

package/cdn/chunks/chunk.SZHINXEE.js

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

package/cdn/chunks/chunk.SZOYHAOV.js

@@ -0,0 +1,29 @@
+import {
+  TerraTimeAverageMap
+} from "./chunk.DGEJWFS7.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/time-average-map/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "terra-time-average-map";
+TerraTimeAverageMap.define("terra-time-average-map");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraTimeAverageMap,
+  react: React,
+  events: {},
+  displayName: "TerraTimeAverageMap"
+});
+var time_average_map_default = reactWrapper;
+
+export {
+  time_average_map_default
+};