@nasa-terra/components 0.0.185 → 0.0.186

package/cdn/chunks/chunk.O3DIP4UG.js

@@ -0,0 +1,81 @@
+import {
+  cherryPickDocInfo
+} from "./chunk.CU6Y4S4O.js";
+import {
+  h,
+  s
+} from "./chunk.BQDEKCXK.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/variable-combobox/variable-combobox.controller.ts
+init_dirname();
+init_buffer();
+init_process();
+var apiError = new Error(
+  "Failed to fetch the data required to make a list of searchable items."
+);
+var _apiTask, _bearerToken;
+var FetchController = class {
+  constructor(host, bearerToken) {
+    __privateAdd(this, _apiTask, void 0);
+    __privateAdd(this, _bearerToken, null);
+    __privateSet(this, _bearerToken, bearerToken);
+    __privateSet(this, _apiTask, new h(host, {
+      task: async () => {
+        const response = await fetch(
+          "https://4nad4npjmf.execute-api.us-east-1.amazonaws.com/default/data-rods",
+          {
+            headers: __spreadValues({
+              Accept: "application/json"
+            }, __privateGet(this, _bearerToken) ? {
+              Authorization: `Bearer: ${__privateGet(this, _bearerToken)}`
+            } : {})
+          }
+        );
+        if (!response.ok) {
+          throw apiError;
+        }
+        const {
+          response: { docs }
+        } = await response.json();
+        return cherryPickDocInfo(docs).sort(
+          (a, b) => (
+            // sort by collection short name, then by long name if variables are in the same collection
+            a.collectionShortName.localeCompare(b.collectionShortName) || a.longName.localeCompare(b.longName)
+          )
+        );
+      },
+      args: () => []
+    }));
+  }
+  get taskComplete() {
+    return __privateGet(this, _apiTask).taskComplete;
+  }
+  get value() {
+    return __privateGet(this, _apiTask).value;
+  }
+  get taskStatus() {
+    const readableStatus = Object.entries(s).reduce((accumulator, [key, value]) => {
+      accumulator[value] = key;
+      return accumulator;
+    }, {});
+    return readableStatus[__privateGet(this, _apiTask).status];
+  }
+  render(renderFunctions) {
+    return __privateGet(this, _apiTask).render(renderFunctions);
+  }
+};
+_apiTask = new WeakMap();
+_bearerToken = new WeakMap();
+
+export {
+  FetchController
+};

package/cdn/chunks/chunk.OCTYDGLC.js

@@ -0,0 +1,168 @@
+import {
+  LatLngBounds
+} from "./chunk.EABQJ4NF.js";
+import {
+  LatLng
+} from "./chunk.SN3T4SQP.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/spatial-picker/spatial-picker.service.ts
+init_dirname();
+init_buffer();
+init_process();
+var SpatialPickerService = class _SpatialPickerService {
+  /**
+   * Parse a raw coordinate string into a typed LatLng or LatLngBounds.
+   *
+   * Accepted formats:
+   *   "lat, lng"                   → LatLng
+   *   "west, south, east, north"   → LatLngBounds
+   */
+  static parse(input) {
+    const parts = input.split(",").map((p) => p.trim());
+    const nums = parts.map(Number);
+    if (nums.some(isNaN)) {
+      throw new Error("All coordinate values must be valid numbers.");
+    }
+    if (nums.length === 2) {
+      return new LatLng(nums[0], nums[1]);
+    }
+    if (nums.length === 4) {
+      return new LatLngBounds(nums);
+    }
+    throw new Error(
+      "Input must contain exactly 2 values (point) or 4 values (bounding box)."
+    );
+  }
+  /**
+   * Validate that coordinates are within their legal ranges.
+   */
+  static validateRanges(value) {
+    if (!value)
+      return null;
+    if (typeof value === "string") {
+      value = _SpatialPickerService.parse(value);
+    }
+    if (value instanceof LatLng) {
+      if (value.lat < -90 || value.lat > 90) {
+        return `Latitude ${value.lat} is out of range (-90 to 90).`;
+      }
+      if (value.lng < -180 || value.lng > 180) {
+        return `Longitude ${value.lng} is out of range (-180 to 180).`;
+      }
+      return null;
+    }
+    const checks = [
+      ["South", value.getSouth(), -90, 90],
+      ["North", value.getNorth(), -90, 90],
+      ["West", value.getWest(), -180, 180],
+      ["East", value.getEast(), -180, 180]
+    ];
+    for (const [label, v, min, max] of checks) {
+      if (v < min || v > max) {
+        return `${label} value ${v} is out of range (${min} to ${max}).`;
+      }
+    }
+    return null;
+  }
+  /**
+   * Validate the parsed value against which input types are permitted.
+   */
+  static validateAllowedType(value, allowed) {
+    const isPoint = value instanceof LatLng;
+    const isBbox = value instanceof LatLngBounds;
+    if (isPoint && !allowed.allowPoint) {
+      return allowed.allowBbox ? "Point selection is disabled. Enter a bounding box (west, south, east, north)." : "Must be a valid bounding box (west, south, east, north).";
+    }
+    if (isBbox && !allowed.allowBbox) {
+      return allowed.allowPoint ? "Bounding box selection is disabled. Enter a point (lat, lng)." : "Must be a valid point (lat, lng).";
+    }
+    return null;
+  }
+  /**
+   * Validate the parsed value against a spatial constraints extent.
+   * Constraints are in "west, south, east, north" format.
+   */
+  static validateConstraints(value, constraintsStr) {
+    if (!constraintsStr)
+      return null;
+    const parts = constraintsStr.split(",").map((p) => parseFloat(p.trim()));
+    if (parts.length !== 4 || parts.some(isNaN))
+      return null;
+    const [west, south, east, north] = parts;
+    if (west === -180 && south === -90 && east === 180 && north === 90)
+      return null;
+    if (value instanceof LatLng) {
+      const inside = value.lat >= south && value.lat <= north && value.lng >= west && value.lng <= east;
+      return inside ? null : "Selected point is outside the allowed spatial extent.";
+    }
+    if (value instanceof LatLngBounds) {
+      const inside = value.getSouth() >= south && value.getNorth() <= north && value.getWest() >= west && value.getEast() <= east;
+      return inside ? null : "Selected area extends outside the allowed spatial extent.";
+    }
+    return null;
+  }
+  /**
+   * Serialize a parsed value back to canonical string form.
+   */
+  static serialize(value) {
+    if (!value)
+      return "";
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value instanceof LatLng) {
+      return `${value.lat.toFixed(2)}, ${value.lng.toFixed(2)}`;
+    }
+    return [value.getWest(), value.getSouth(), value.getEast(), value.getNorth()].map((n) => n.toFixed(2)).join(", ");
+  }
+  /**
+   * Full parse + validate pipeline. Returns a discriminated union result.
+   */
+  static validate(input, allowed, constraintsStr) {
+    let value;
+    try {
+      value = _SpatialPickerService.parse(input);
+    } catch (e) {
+      const formatHint = _SpatialPickerService.formatHint(allowed);
+      return { ok: false, error: `Invalid format. ${formatHint}` };
+    }
+    const rangeError = _SpatialPickerService.validateRanges(value);
+    if (rangeError)
+      return { ok: false, error: rangeError };
+    const typeError = _SpatialPickerService.validateAllowedType(value, allowed);
+    if (typeError)
+      return { ok: false, error: typeError };
+    if (constraintsStr) {
+      const constraintError = _SpatialPickerService.validateConstraints(
+        value,
+        constraintsStr
+      );
+      if (constraintError)
+        return { ok: false, error: constraintError };
+    }
+    return {
+      ok: true,
+      value,
+      serialized: _SpatialPickerService.serialize(value)
+    };
+  }
+  static formatHint(allowed) {
+    if (allowed.allowPoint && allowed.allowBbox) {
+      return "Enter a point (lat, lng) or bounding box (west, south, east, north).";
+    }
+    if (allowed.allowPoint)
+      return "Enter a point (lat, lng).";
+    if (allowed.allowBbox)
+      return "Enter a bounding box (west, south, east, north).";
+    return "";
+  }
+};
+
+export {
+  SpatialPickerService
+};

package/cdn/chunks/chunk.OHKWOZQS.js

@@ -0,0 +1,29 @@
+import {
+  TerraTimeAverageMap
+} from "./chunk.GHXMILVD.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
+};

package/cdn/chunks/chunk.OIXADKW2.js

@@ -0,0 +1,186 @@
+import {
+  apiClient
+} from "./chunk.ND3745YQ.js";
+import {
+  BadRequestException,
+  NotFoundException
+} from "./chunk.SYQOGYTQ.js";
+import {
+  __privateAdd,
+  __privateMethod,
+  __spreadProps,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/apis/cmr.api.ts
+init_dirname();
+init_buffer();
+init_process();
+var baseUrl = "https://cmr.earthdata.nasa.gov/search/";
+var _request, request_fn, _getGranuleSortKey, getGranuleSortKey_fn;
+var CmrApi = class {
+  constructor() {
+    __privateAdd(this, _request);
+    // TODO: replace references to these old columns with these names and remove this method (data access may be the only location)
+    __privateAdd(this, _getGranuleSortKey);
+  }
+  async getCollection(shortName, version, options) {
+    return this.getCollectionByEntryId(`${shortName}_${version}`, options);
+  }
+  async getCollectionByEntryId(collectionEntryId, options) {
+    if (!collectionEntryId) {
+      throw new BadRequestException({
+        message: "`collectionEntryId` is required"
+      });
+    }
+    const ummResponse = await __privateMethod(this, _request, request_fn).call(this, `collections.umm_json?entry_id=${collectionEntryId}&include_granule_counts=true`, options);
+    if (!ummResponse.items.length) {
+      throw new NotFoundException({
+        message: `Collection ${collectionEntryId} was not found`
+      });
+    }
+    return ummResponse.items[0];
+  }
+  async searchVariables(searchParams, options) {
+    var _a;
+    if (!searchParams.collectionConceptId) {
+      throw new BadRequestException({
+        message: "`collectionConceptId` is required"
+      });
+    }
+    return __privateMethod(this, _request, request_fn).call(this, `variables.umm_json?keyword=${searchParams.collectionConceptId}&page_size=${(_a = searchParams.pageSize) != null ? _a : 200}`, options);
+  }
+  async getSamplingOfGranules(collectionEntryId, options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const [first, last] = await Promise.all([
+      this.searchGranules(
+        {
+          collectionEntryId,
+          pageSize: 1,
+          sortBy: "umm.TemporalExtent.RangeDateTime.BeginningDateTime",
+          sortDirection: "asc"
+        },
+        options
+      ),
+      this.searchGranules(
+        {
+          collectionEntryId,
+          pageSize: 1,
+          sortBy: "umm.TemporalExtent.RangeDateTime.BeginningDateTime",
+          sortDirection: "desc"
+        },
+        options
+      )
+    ]);
+    const firstGranule = (_a = first.items[0]) == null ? void 0 : _a.umm;
+    const firstExtent = (_b = firstGranule == null ? void 0 : firstGranule.TemporalExtent) == null ? void 0 : _b.RangeDateTime;
+    const isSubDaily = (firstExtent == null ? void 0 : firstExtent.BeginningDateTime) != null && firstExtent.EndingDateTime != null ? (new Date(firstExtent.EndingDateTime).getTime() - new Date(firstExtent.BeginningDateTime).getTime()) / (1e3 * 60 * 60) < 24 : false;
+    return {
+      minDate: (_c = firstExtent == null ? void 0 : firstExtent.BeginningDateTime) == null ? void 0 : _c.toString(),
+      maxDate: (_g = (_f = (_e = (_d = last.items[0]) == null ? void 0 : _d.umm.TemporalExtent) == null ? void 0 : _e.RangeDateTime) == null ? void 0 : _f.BeginningDateTime) == null ? void 0 : _g.toString(),
+      isSubDaily,
+      hasGranules: first.hits > 0
+    };
+  }
+  async searchGranules(params, options) {
+    var _a, _b, _c, _d;
+    if (!params.collectionEntryId && !params.collectionConceptId) {
+      throw new BadRequestException({
+        message: "`collectionEntryId` or `collectionConceptId` is required to search granules"
+      });
+    }
+    const searchParams = new URLSearchParams(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, params.collectionEntryId && {
+      "entry_id[]": params.collectionEntryId
+    }), params.collectionConceptId && {
+      collection_concept_id: params.collectionConceptId
+    }), params.pageSize && { page_size: params.pageSize.toString() }), params.pageNum && { page_num: params.pageNum.toString() }), params.offset && { offset: params.offset.toString() }), params.sortBy && {
+      "sort_key[]": __privateMethod(this, _getGranuleSortKey, getGranuleSortKey_fn).call(this, params.sortBy, (_a = params.sortDirection) != null ? _a : "asc")
+    }), params.search && {
+      // TODO: support searchFields for searching other than granule_ur
+      "granule_ur[]": `*${params.search}*`,
+      "options[granule_ur][pattern]": "true"
+      // CMR supports wildcard searching via the pattern option
+    }), params.startDate && params.endDate && {
+      temporal: `${params.startDate},${params.endDate}`
+    }), ((_b = params.location) == null ? void 0 : _b.type) === "bbox" && {
+      // TODO: support other location types (e.g. circle, polygon, point, shapefile)
+      bounding_box: params.location.bounds.toBBoxString()
+    }), ((_c = params.cloudCover) == null ? void 0 : _c.min) !== void 0 && ((_d = params.cloudCover) == null ? void 0 : _d.max) !== void 0 && {
+      cloud_cover: `${params.cloudCover.min},${params.cloudCover.max}`
+    }));
+    return __privateMethod(this, _request, request_fn).call(this, `granules.umm_json?${searchParams.toString()}`, options);
+  }
+  async getCollectionCitation(collectionEntryId, options) {
+    var _a, _b, _c;
+    const collection = await this.getCollectionByEntryId(
+      collectionEntryId,
+      options
+    );
+    const umm = collection.umm;
+    if (!((_a = umm.CollectionCitations) == null ? void 0 : _a.length)) {
+      throw new Error(`No collection citations found for ${collectionEntryId}`);
+    }
+    return {
+      doi: {
+        doi: (_c = (_b = umm.DOI) == null ? void 0 : _b.DOI) != null ? _c : ""
+      },
+      collectionCitations: umm.CollectionCitations.map((citation) => {
+        var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j;
+        return {
+          creator: (_a2 = citation.Creator) != null ? _a2 : "",
+          editor: (_b2 = citation.Editor) != null ? _b2 : "",
+          dataPresentationForm: (_c2 = citation.DataPresentationForm) != null ? _c2 : "",
+          onlineResource: {
+            linkage: (_e = (_d = citation.OnlineResource) == null ? void 0 : _d.Linkage) != null ? _e : ""
+          },
+          publisher: (_f = citation.Publisher) != null ? _f : "",
+          title: (_g = citation.Title) != null ? _g : "",
+          seriesName: (_h = citation.SeriesName) != null ? _h : "",
+          releaseDate: citation.ReleaseDate ? String(citation.ReleaseDate) : "",
+          version: (_i = citation.Version) != null ? _i : "",
+          releasePlace: (_j = citation.ReleasePlace) != null ? _j : ""
+        };
+      })
+    };
+  }
+};
+_request = new WeakSet();
+request_fn = function(path, requestOptions) {
+  return apiClient.get(`${baseUrl}${path}`, __spreadProps(__spreadValues({}, requestOptions), {
+    headers: __spreadValues(__spreadValues({}, requestOptions == null ? void 0 : requestOptions.headers), (requestOptions == null ? void 0 : requestOptions.bearerToken) && {
+      Authorization: `Bearer ${requestOptions.bearerToken}`
+    })
+  }));
+};
+_getGranuleSortKey = new WeakSet();
+getGranuleSortKey_fn = function(sortBy, sortDirection) {
+  let sortKey = sortBy;
+  switch (sortBy) {
+    case "title":
+    case "umm.GranuleUR":
+      sortKey = "granuleUr";
+      break;
+    case "size":
+    case "umm.DataGranule.Size":
+      sortKey = "dataSize";
+      break;
+    case "timeStart":
+    case "umm.TemporalExtent.RangeDateTime.BeginningDateTime":
+      sortKey = "startDate";
+      break;
+    case "timeEnd":
+    case "umm.TemporalExtent.RangeDateTime.EndingDateTime":
+      sortKey = "endDate";
+      break;
+  }
+  return `${sortDirection === "asc" ? "+" : "-"}${sortKey}`;
+};
+var cmrApi = new CmrApi();
+var cmr_api_default = cmrApi;
+
+export {
+  cmr_api_default
+};

package/cdn/chunks/chunk.OVQNKLCQ.js

@@ -0,0 +1,19 @@
+import {
+  TerraCard
+} from "./chunk.RNZEHUAB.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/card/card.ts
+init_dirname();
+init_buffer();
+init_process();
+var card_default = TerraCard;
+TerraCard.define("terra-card");
+
+export {
+  card_default
+};

package/cdn/chunks/chunk.P27SQ2YZ.js

@@ -0,0 +1,36 @@
+import {
+  TerraToggle
+} from "./chunk.7ARV23YA.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/toggle/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-toggle";
+TerraToggle.define("terra-toggle");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraToggle,
+  react: React,
+  events: {
+    onTerraBlur: "terra-blur",
+    onTerraChange: "terra-change",
+    onTerraInput: "terra-input",
+    onTerraFocus: "terra-focus",
+    onTerraInvalid: "terra-invalid"
+  },
+  displayName: "TerraToggle"
+});
+var toggle_default = reactWrapper;
+
+export {
+  toggle_default
+};

package/cdn/chunks/chunk.P34Y4ETY.js

@@ -0,0 +1,84 @@
+import {
+  h
+} from "./chunk.BQDEKCXK.js";
+import {
+  authService
+} from "./chunk.EYYVMPBZ.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/auth/auth.controller.ts
+init_dirname();
+init_buffer();
+init_process();
+var _host, _loginWithCredentials, loginWithCredentials_fn;
+var AuthController = class {
+  constructor(host) {
+    __privateAdd(this, _loginWithCredentials);
+    __privateAdd(this, _host, void 0);
+    __privateSet(this, _host, host);
+    this.task = new h(host, {
+      task: async ([]) => {
+        this.unsubscribe = authService.subscribe(
+          (state) => {
+            if (state.token) {
+              __privateGet(this, _host).bearerToken = state.token;
+            }
+            __privateGet(this, _host).emit("terra-login", {
+              detail: state
+            });
+            __privateGet(this, _host).requestUpdate();
+          },
+          // @ts-expect-error - we can't guarantee the host has a bearerToken property
+          __privateGet(this, _host).bearerToken
+        );
+        __privateGet(this, _host).emit("terra-login", {
+          detail: authService.getState()
+        });
+        return authService.getState();
+      },
+      args: () => [],
+      autoRun: true
+    });
+    this.loginTask = new h(__privateGet(this, _host), {
+      task: async ([username, password]) => {
+        return await __privateMethod(this, _loginWithCredentials, loginWithCredentials_fn).call(this, username, password);
+      },
+      args: () => [],
+      autoRun: false
+    });
+  }
+  get state() {
+    return authService.getState();
+  }
+  login() {
+    authService.login();
+  }
+  logout() {
+    authService.logout();
+  }
+  render(renderFunctions) {
+    return this.task.render(renderFunctions);
+  }
+  disconnectedCallback() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+    }
+  }
+};
+_host = new WeakMap();
+_loginWithCredentials = new WeakSet();
+loginWithCredentials_fn = function(username, password) {
+  return authService.loginWithCredentials(username, password);
+};
+
+export {
+  AuthController
+};

package/cdn/chunks/chunk.PETC7KGW.js

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

package/cdn/chunks/chunk.PEYZV6JO.js

@@ -0,0 +1,29 @@
+import {
+  TerraSkeleton
+} from "./chunk.FZW3K6J4.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
+};