@nasa-terra/components 0.0.193 → 0.0.195

package/cdn/chunks/chunk.Y2QU6FAL.js

@@ -0,0 +1,392 @@
+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");
+    }
+    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
+};

package/cdn/chunks/chunk.Y3EV6C6T.js

@@ -0,0 +1,27 @@
+import {
+  formatCoord
+} from "./chunk.YY6HKJ7L.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/map/models/LatLng.ts
+init_dirname();
+init_buffer();
+init_process();
+var LatLng = class {
+  constructor(lat, lng, alt) {
+    this.lat = lat;
+    this.lng = lng;
+    this.alt = alt;
+  }
+  toString() {
+    return `${formatCoord(this.lat)}, ${formatCoord(this.lng)}`;
+  }
+};
+
+export {
+  LatLng
+};

package/cdn/chunks/chunk.YFQAWKK2.js

@@ -0,0 +1,19 @@
+import {
+  TerraBreadcrumb
+} from "./chunk.P2RGLH4G.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/breadcrumb/breadcrumb.ts
+init_dirname();
+init_buffer();
+init_process();
+var breadcrumb_default = TerraBreadcrumb;
+TerraBreadcrumb.define("terra-breadcrumb");
+
+export {
+  breadcrumb_default
+};

package/cdn/chunks/chunk.YL6WAIUW.js

@@ -0,0 +1,230 @@
+import {
+  icon_styles_default
+} from "./chunk.MBNHU6HG.js";
+import {
+  getIconLibrary,
+  unwatchIcon,
+  watchIcon
+} from "./chunk.WFSXAREE.js";
+import {
+  l
+} from "./chunk.RLW2L6QO.js";
+import {
+  watch
+} from "./chunk.MPVZOQYA.js";
+import {
+  TerraElement,
+  component_styles_default,
+  n,
+  r
+} from "./chunk.MUSV5WD7.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/icon/icon.component.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/lit/directive-helpers.js
+init_dirname();
+init_buffer();
+init_process();
+
+// src/components/icon/icon.component.ts
+var CACHEABLE_ERROR = Symbol();
+var RETRYABLE_ERROR = Symbol();
+var parser;
+var iconCache = /* @__PURE__ */ new Map();
+var _initialRender, _resolveIcon, resolveIcon_fn, _getIconSource, getIconSource_fn, _styleFromAttributes, styleFromAttributes_fn;
+var TerraIcon = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    /** Given a URL, this function returns the resulting SVG element or an appropriate error symbol. */
+    __privateAdd(this, _resolveIcon);
+    __privateAdd(this, _getIconSource);
+    /**
+     * SVG takes a few presentation attributes. Since we're using a template for SVG and our host element isn't an SVG, we can pass those presentational attributes into a style attribute to affect the underlying SVG.
+     * Merge select attributes with existing inline style attribute to forward values to underlying SVG.
+     */
+    __privateAdd(this, _styleFromAttributes);
+    __privateAdd(this, _initialRender, false);
+    this.svg = null;
+    this.label = "";
+    this.library = "default";
+    this.color = null;
+    this.fontSize = null;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    watchIcon(this);
+  }
+  firstUpdated() {
+    __privateSet(this, _initialRender, true);
+    this.setIcon();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    unwatchIcon(this);
+  }
+  handleLabelChange() {
+    const hasLabel = typeof this.label === "string" && this.label.length > 0;
+    if (hasLabel) {
+      this.setAttribute("role", "img");
+      this.setAttribute("aria-label", this.label);
+      this.removeAttribute("aria-hidden");
+    } else {
+      this.removeAttribute("role");
+      this.removeAttribute("aria-label");
+      this.setAttribute("aria-hidden", "true");
+    }
+  }
+  async setIcon() {
+    var _a;
+    const { url, fromLibrary } = __privateMethod(this, _getIconSource, getIconSource_fn).call(this);
+    const library = fromLibrary ? getIconLibrary(this.library) : void 0;
+    if (!url) {
+      this.svg = null;
+      return;
+    }
+    let iconResolver = iconCache.get(url);
+    if (!iconResolver) {
+      iconResolver = __privateMethod(this, _resolveIcon, resolveIcon_fn).call(this, url);
+      iconCache.set(url, iconResolver);
+    }
+    if (!__privateGet(this, _initialRender)) {
+      return;
+    }
+    const svg = await iconResolver;
+    if (svg === RETRYABLE_ERROR) {
+      iconCache.delete(url);
+    }
+    if (url !== __privateMethod(this, _getIconSource, getIconSource_fn).call(this).url) {
+      return;
+    }
+    if (l(svg)) {
+      this.svg = svg;
+      return;
+    }
+    switch (svg) {
+      case RETRYABLE_ERROR:
+      case CACHEABLE_ERROR:
+        this.svg = null;
+        this.emit("terra-error");
+        break;
+      default:
+        this.svg = svg.cloneNode(true);
+        (_a = library == null ? void 0 : library.mutator) == null ? void 0 : _a.call(library, this.svg);
+        this.emit("terra-load");
+    }
+  }
+  render() {
+    __privateMethod(this, _styleFromAttributes, styleFromAttributes_fn).call(this);
+    return this.svg;
+  }
+};
+_initialRender = new WeakMap();
+_resolveIcon = new WeakSet();
+resolveIcon_fn = async function(url) {
+  var _a;
+  let fileData;
+  try {
+    fileData = await fetch(url, { mode: "cors" });
+    if (!fileData.ok) {
+      return fileData.status === 410 ? CACHEABLE_ERROR : RETRYABLE_ERROR;
+    }
+  } catch (e) {
+    return RETRYABLE_ERROR;
+  }
+  try {
+    const div = document.createElement("div");
+    div.innerHTML = await fileData.text();
+    const svg = div.firstElementChild;
+    if (((_a = svg == null ? void 0 : svg.tagName) == null ? void 0 : _a.toLowerCase()) !== "svg") {
+      return CACHEABLE_ERROR;
+    }
+    if (!parser) {
+      parser = new DOMParser();
+    }
+    const doc = parser.parseFromString(svg.outerHTML, "text/html");
+    const svgEl = doc.body.querySelector("svg");
+    if (!svgEl) {
+      return CACHEABLE_ERROR;
+    }
+    svgEl.part.add("svg");
+    return document.adoptNode(svgEl);
+  } catch (e) {
+    return CACHEABLE_ERROR;
+  }
+};
+_getIconSource = new WeakSet();
+getIconSource_fn = function() {
+  const library = getIconLibrary(this.library);
+  if (this.name && library) {
+    return {
+      url: library.resolver(this.name),
+      fromLibrary: true
+    };
+  }
+  return {
+    url: this.src,
+    fromLibrary: false
+  };
+};
+_styleFromAttributes = new WeakSet();
+styleFromAttributes_fn = function() {
+  const svgAttributes = [
+    { attribute: "color", property: this.color },
+    { attribute: "font-size", property: this.fontSize }
+  ];
+  const style = svgAttributes.reduce((accumulator, { attribute, property }) => {
+    if (typeof property === "string" && property.length > 0) {
+      accumulator += ` ${attribute}: ${property};`;
+    }
+    this.removeAttribute(attribute);
+    return accumulator;
+  }, `${this.style.cssText}`);
+  if (style.length > 0) {
+    this.setAttribute("style", style);
+  }
+};
+TerraIcon.styles = [component_styles_default, icon_styles_default];
+__decorateClass([
+  r()
+], TerraIcon.prototype, "svg", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraIcon.prototype, "name", 2);
+__decorateClass([
+  n()
+], TerraIcon.prototype, "src", 2);
+__decorateClass([
+  n()
+], TerraIcon.prototype, "label", 2);
+__decorateClass([
+  n({ reflect: true })
+], TerraIcon.prototype, "library", 2);
+__decorateClass([
+  n()
+], TerraIcon.prototype, "color", 2);
+__decorateClass([
+  n({ attribute: "font-size" })
+], TerraIcon.prototype, "fontSize", 2);
+__decorateClass([
+  watch("label")
+], TerraIcon.prototype, "handleLabelChange", 1);
+__decorateClass([
+  watch(["name", "src", "library"])
+], TerraIcon.prototype, "setIcon", 1);
+
+export {
+  TerraIcon
+};