@nasa-terra/components 0.0.197 → 0.0.199

package/cdn/chunks/chunk.573DB434.js

@@ -0,0 +1,39 @@
+import {
+  TerraDataGrid
+} from "./chunk.ZS67HYGB.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/data-grid/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-data-grid";
+TerraDataGrid.define("terra-data-grid");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraDataGrid,
+  react: React,
+  events: {
+    onTerraGridReady: "terra-grid-ready",
+    onTerraSelectionChanged: "terra-selection-changed",
+    onTerraSortChanged: "terra-sort-changed",
+    onTerraFilterChanged: "terra-filter-changed",
+    onTerraRowClicked: "terra-row-clicked",
+    onTerraRowDoubleClicked: "terra-row-double-clicked",
+    onTerraCellClicked: "terra-cell-clicked",
+    onTerraCellValueChanged: "terra-cell-value-changed"
+  },
+  displayName: "TerraDataGrid"
+});
+var data_grid_default = reactWrapper;
+
+export {
+  data_grid_default
+};

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

@@ -0,0 +1,19 @@
+import {
+  TerraTooltip
+} from "./chunk.4KHGJTYG.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/tooltip/tooltip.ts
+init_dirname();
+init_buffer();
+init_process();
+var tooltip_default = TerraTooltip;
+TerraTooltip.define("terra-tooltip");
+
+export {
+  tooltip_default
+};

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

@@ -0,0 +1,19 @@
+import {
+  TerraDataSubsetterHistory
+} from "./chunk.NH4YMQJT.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/data-subsetter-history/data-subsetter-history.ts
+init_dirname();
+init_buffer();
+init_process();
+var data_subsetter_history_default = TerraDataSubsetterHistory;
+TerraDataSubsetterHistory.define("terra-data-subsetter-history");
+
+export {
+  data_subsetter_history_default
+};

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

@@ -0,0 +1,19 @@
+import {
+  TerraMenu
+} from "./chunk.SYUADFIF.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/menu/menu.ts
+init_dirname();
+init_buffer();
+init_process();
+var menu_default = TerraMenu;
+TerraMenu.define("terra-menu");
+
+export {
+  menu_default
+};

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

@@ -0,0 +1,416 @@
+import {
+  isResizeObserverSupported
+} from "./chunk.RHAJW5JW.js";
+import {
+  DrawToolbarControl
+} from "./chunk.PF6HHPHM.js";
+import {
+  BaseLayer
+} from "./chunk.SE55TMVG.js";
+import {
+  BordersLayer
+} from "./chunk.HT4VXYXY.js";
+import {
+  LabelsLayer
+} from "./chunk.LIPFUNWP.js";
+import {
+  GeoJSON_default,
+  Graticule_default,
+  Map_default
+} from "./chunk.H6KRH5P2.js";
+import {
+  Circle_default,
+  Stroke_default,
+  Vector_default,
+  Vector_default2
+} from "./chunk.M6QQY2ST.js";
+import {
+  Point_default,
+  Polygon_default,
+  View_default
+} from "./chunk.IK2SGPIW.js";
+import {
+  get,
+  toLonLat,
+  transform,
+  transformExtent
+} from "./chunk.RCPXD7AS.js";
+import {
+  LatLngBounds
+} from "./chunk.B2HOZPO6.js";
+import {
+  LatLng
+} from "./chunk.Y3EV6C6T.js";
+import {
+  BadRequestException
+} from "./chunk.SYQOGYTQ.js";
+import {
+  __objRest,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/map/map.service.ts
+init_dirname();
+init_buffer();
+init_process();
+var _el, _map, _drawToolbarControl, _options, _shapeLayer, _onDraw, _onShapeLoading, _createMap, createMap_fn, _createGraticuleLayer, createGraticuleLayer_fn, _createDrawLayer, createDrawLayer_fn, _createShapeLayer, createShapeLayer_fn, _updateMapSizeOnResize, updateMapSizeOnResize_fn, _getLayerByName, getLayerByName_fn;
+var MapService = class {
+  constructor(el, options) {
+    __privateAdd(this, _createMap);
+    __privateAdd(this, _createGraticuleLayer);
+    __privateAdd(this, _createDrawLayer);
+    __privateAdd(this, _createShapeLayer);
+    __privateAdd(this, _updateMapSizeOnResize);
+    __privateAdd(this, _getLayerByName);
+    __privateAdd(this, _el, void 0);
+    // the map component's root element
+    __privateAdd(this, _map, void 0);
+    __privateAdd(this, _drawToolbarControl, void 0);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _shapeLayer, void 0);
+    __privateAdd(this, _onDraw, void 0);
+    __privateAdd(this, _onShapeLoading, void 0);
+    __privateSet(this, _el, el);
+    __privateSet(this, _options, options);
+    __privateSet(this, _map, __privateMethod(this, _createMap, createMap_fn).call(this, options));
+    __privateMethod(this, _updateMapSizeOnResize, updateMapSizeOnResize_fn).call(this);
+  }
+  toggleLayerVisibility(name, show) {
+    const layer = __privateMethod(this, _getLayerByName, getLayerByName_fn).call(this, name);
+    if (layer) {
+      layer.setVisible(show);
+    }
+  }
+  /**
+   * Adds a custom layer to the map.
+   *
+   * By default the layer is inserted directly above the base imagery layer
+   * and below the borders/labels layers, so borders/labels continue to
+   * render on top of any data layers. Use `position: 'top'` to instead
+   * place the layer above everything else (e.g. an interactive drawing
+   * layer).
+   */
+  addLayer(layer, options = {}) {
+    if (options.name) {
+      layer.set("name", options.name);
+    }
+    if (options.position === "top") {
+      __privateGet(this, _map).addLayer(layer);
+      return;
+    }
+    const bordersLayer = __privateMethod(this, _getLayerByName, getLayerByName_fn).call(this, "borders");
+    const layers = __privateGet(this, _map).getLayers();
+    const index = bordersLayer ? layers.getArray().indexOf(bordersLayer) : layers.getLength();
+    layers.insertAt(index, layer);
+  }
+  removeLayer(name) {
+    const layer = __privateMethod(this, _getLayerByName, getLayerByName_fn).call(this, name);
+    if (layer) {
+      __privateGet(this, _map).removeLayer(layer);
+    }
+  }
+  getLayer(name) {
+    return __privateMethod(this, _getLayerByName, getLayerByName_fn).call(this, name);
+  }
+  /**
+   * Fits the map's view to the given extent, reprojecting from
+   * `options.projection` to the map's view projection if provided.
+   */
+  fitToExtent(extent, options = {}) {
+    const _a = options, { projection } = _a, fitOptions = __objRest(_a, ["projection"]);
+    const targetExtent = projection ? transformExtent(extent, projection, __privateGet(this, _map).getView().getProjection()) : extent;
+    __privateGet(this, _map).getView().fit(targetExtent, fitOptions);
+  }
+  addInteraction(interaction) {
+    __privateGet(this, _map).addInteraction(interaction);
+  }
+  removeInteraction(interaction) {
+    __privateGet(this, _map).removeInteraction(interaction);
+  }
+  /**
+   * Returns the map's rendered canvas/svg elements, in z-order, for
+   * consumers that need to composite the rendered map (e.g. exporting an
+   * image or capturing a thumbnail) without reaching into the map's DOM.
+   */
+  getCanvasElements() {
+    const viewport = __privateGet(this, _map).getViewport();
+    return {
+      canvases: Array.from(
+        viewport.querySelectorAll("canvas")
+      ),
+      svgs: Array.from(viewport.querySelectorAll("svg"))
+    };
+  }
+  getSize() {
+    return __privateGet(this, _map).getSize();
+  }
+  /**
+   * Converts a map coordinate (in the view's projection) into a pixel
+   * position, for consumers that need to sample a layer's raster data at a
+   * given coordinate (e.g. reading GeoTIFF values along a drawn line).
+   */
+  getPixelFromCoordinate(coordinate) {
+    return __privateGet(this, _map).getPixelFromCoordinate(coordinate);
+  }
+  renderComplete() {
+    return new Promise((resolve) => {
+      __privateGet(this, _map).once("rendercomplete", () => resolve());
+      __privateGet(this, _map).render();
+    });
+  }
+  setZoom(zoom) {
+    __privateGet(this, _map).getView().setZoom(zoom);
+  }
+  setValue(value) {
+    if (!value) {
+      __privateGet(this, _drawToolbarControl).clearValue();
+      return;
+    }
+    const location = this.parseLocationString(value);
+    __privateGet(this, _drawToolbarControl).setValue(location, __privateGet(this, _options).fitToValue);
+  }
+  /**
+   * takes a string and parses it into a point, bounding box
+   * TODO: support parsing circle and polygon
+   */
+  parseLocationString(location) {
+    try {
+      const locationParts = location.split(",").map((part) => parseFloat(part.trim()));
+      if (locationParts.length === 2) {
+        return new LatLng(locationParts[0], locationParts[1]);
+      }
+      if (locationParts.length === 4) {
+        return new LatLngBounds([
+          locationParts[0],
+          locationParts[1],
+          locationParts[2],
+          locationParts[3]
+        ]);
+      }
+      throw new Error(
+        `Provided location had invalid length of ${locationParts.length}. Should have 2 or 4 items.`
+      );
+    } catch (e) {
+      throw new BadRequestException({
+        message: "Failed to parse location string. Location must be in format: `lat,lng` for a point or `west,south,east,north` for a bounding box",
+        cause: e
+      });
+    }
+  }
+  updateDrawToolbarVisibility(options) {
+    __privateGet(this, _drawToolbarControl).setOptions({
+      showBboxTool: options.showBoundingBoxSelection,
+      showPolygonTool: options.showPolygonSelection,
+      showPointTool: options.showPointSelection,
+      showCircleTool: options.showCircleSelection
+    });
+  }
+  async handleShapeSelect(event) {
+    var _a, _b, _c, _d, _e, _f;
+    const select = event.target;
+    const selectedShape = select.value;
+    if (!selectedShape)
+      return;
+    __privateGet(this, _shapeLayer).getSource().clear();
+    (_a = __privateGet(this, _onShapeLoading)) == null ? void 0 : _a.call(this, true);
+    try {
+      const shapeGeoJson = await ((_c = (_b = __privateGet(this, _options)).getGeoJson) == null ? void 0 : _c.call(_b, selectedShape));
+      if (!shapeGeoJson)
+        return;
+      const format = new GeoJSON_default();
+      const features = format.readFeatures(shapeGeoJson, {
+        featureProjection: "EPSG:3857"
+      });
+      const source = __privateGet(this, _shapeLayer).getSource();
+      source.addFeatures(features);
+      const extent = source.getExtent();
+      if (!extent) {
+        return;
+      }
+      __privateGet(this, _map).getView().fit(extent, {
+        padding: [20, 20, 20, 20],
+        duration: 250
+      });
+      (_e = __privateGet(this, _onDraw)) == null ? void 0 : _e.call(this, {
+        cause: "draw",
+        type: "polygon" /* POLYGON */,
+        latLngs: [],
+        geoJson: shapeGeoJson,
+        label: (_d = select.options[select.selectedIndex]) == null ? void 0 : _d.text
+      });
+    } finally {
+      (_f = __privateGet(this, _onShapeLoading)) == null ? void 0 : _f.call(this, false);
+    }
+  }
+};
+_el = new WeakMap();
+_map = new WeakMap();
+_drawToolbarControl = new WeakMap();
+_options = new WeakMap();
+_shapeLayer = new WeakMap();
+_onDraw = new WeakMap();
+_onShapeLoading = new WeakMap();
+_createMap = new WeakSet();
+createMap_fn = function(options) {
+  var _a;
+  __privateSet(this, _onDraw, options.onDraw);
+  __privateSet(this, _onShapeLoading, options.onShapeLoading);
+  const baseLayer = new BaseLayer(options);
+  baseLayer.set("name", "base");
+  const bordersLayer = new BordersLayer(options);
+  bordersLayer.set("name", "borders");
+  const labelsLayer = new LabelsLayer(options);
+  labelsLayer.set("name", "labels");
+  const graticuleLayer = __privateMethod(this, _createGraticuleLayer, createGraticuleLayer_fn).call(this, options);
+  const drawLayer = __privateMethod(this, _createDrawLayer, createDrawLayer_fn).call(this);
+  __privateSet(this, _shapeLayer, __privateMethod(this, _createShapeLayer, createShapeLayer_fn).call(this));
+  const projection = get("EPSG:3857");
+  const worldExtent = projection == null ? void 0 : projection.getExtent();
+  const map = new Map_default({
+    target: __privateGet(this, _el),
+    layers: [
+      baseLayer,
+      bordersLayer,
+      labelsLayer,
+      graticuleLayer,
+      __privateGet(this, _shapeLayer),
+      drawLayer
+    ],
+    view: new View_default(__spreadValues({
+      center: [0, 0],
+      zoom: options.zoom,
+      projection: (_a = options.projection) != null ? _a : "EPSG:3857",
+      minZoom: options.minZoom,
+      maxZoom: options.maxZoom
+    }, options.noWorldWrap ? { extent: worldExtent } : {}))
+  });
+  map.on("pointermove", (event) => {
+    var _a2;
+    const coordinate = toLonLat(event.coordinate);
+    (_a2 = options.onMouseMove) == null ? void 0 : _a2.call(
+      options,
+      coordinate,
+      event.pixel
+    );
+  });
+  __privateSet(this, _drawToolbarControl, new DrawToolbarControl(drawLayer, {
+    showBboxTool: options.showBoundingBoxSelection,
+    showPolygonTool: options.showPolygonSelection,
+    showPointTool: options.showPointSelection,
+    showCircleTool: options.showCircleSelection
+  }));
+  map.addControl(__privateGet(this, _drawToolbarControl));
+  if (options.value !== void 0) {
+    this.setValue(options.value);
+  }
+  drawLayer.getSource().on("addfeature", (event) => {
+    var _a2, _b, _c, _d, _e;
+    const drawtool = (_a2 = event.feature) == null ? void 0 : _a2.get("drawtool");
+    if (!drawtool) {
+      return;
+    }
+    const geometry = event.feature.getGeometry();
+    if (drawtool === "bbox") {
+      const extent = event.feature.getGeometry().getExtent();
+      const bbox4326 = transformExtent(extent, "EPSG:3857", "EPSG:4326");
+      (_b = options.onDraw) == null ? void 0 : _b.call(options, {
+        cause: "draw",
+        type: "bbox" /* BBOX */,
+        bounds: new LatLngBounds(bbox4326)
+      });
+    } else if (geometry instanceof Polygon_default) {
+      const coordinates = geometry.getCoordinates()[0].slice(0, -1);
+      const latLngs = coordinates.map(([x, y]) => {
+        const [lng, lat] = transform([x, y], "EPSG:3857", "EPSG:4326");
+        return new LatLng(lat, lng);
+      });
+      (_c = options.onDraw) == null ? void 0 : _c.call(options, {
+        cause: "draw",
+        type: "polygon" /* POLYGON */,
+        latLngs
+      });
+    } else if (geometry instanceof Point_default) {
+      const coords = geometry.getCoordinates();
+      const [lng, lat] = transform(coords, "EPSG:3857", "EPSG:4326");
+      (_d = options.onDraw) == null ? void 0 : _d.call(options, {
+        cause: "draw",
+        type: "point" /* POINT */,
+        latLng: new LatLng(lat, lng)
+      });
+    } else if (geometry instanceof Circle_default) {
+      const radius = geometry.getRadius();
+      const [lng, lat] = transform(
+        geometry.getCenter(),
+        "EPSG:3857",
+        "EPSG:4326"
+      );
+      (_e = options.onDraw) == null ? void 0 : _e.call(options, {
+        cause: "draw",
+        type: "circle" /* CIRCLE */,
+        center: new LatLng(lat, lng),
+        radius
+      });
+    } else {
+      console.warn("Unhandled draw type! ", event.feature);
+    }
+  });
+  return map;
+};
+_createGraticuleLayer = new WeakSet();
+createGraticuleLayer_fn = function(options) {
+  var _a;
+  const layer = new Graticule_default({
+    visible: (_a = options.showGraticule) != null ? _a : false,
+    strokeStyle: new Stroke_default({
+      color: "rgba(0,0,0,0.2)",
+      width: 2,
+      lineDash: [0.5, 4]
+    }),
+    showLabels: true,
+    wrapX: true
+  });
+  layer.set("name", "graticule");
+  return layer;
+};
+_createDrawLayer = new WeakSet();
+createDrawLayer_fn = function() {
+  const source = new Vector_default({
+    wrapX: false
+  });
+  return new Vector_default2({
+    source
+  });
+};
+_createShapeLayer = new WeakSet();
+createShapeLayer_fn = function() {
+  const source = new Vector_default();
+  const layer = new Vector_default2({
+    source
+  });
+  layer.set("name", "shapes");
+  return layer;
+};
+_updateMapSizeOnResize = new WeakSet();
+updateMapSizeOnResize_fn = function() {
+  if (isResizeObserverSupported()) {
+    const resizeObserver = new ResizeObserver(() => {
+      __privateGet(this, _map).updateSize();
+    });
+    resizeObserver.observe(__privateGet(this, _el));
+  }
+};
+_getLayerByName = new WeakSet();
+getLayerByName_fn = function(name) {
+  return __privateGet(this, _map).getLayers().getArray().find((layer) => layer.get("name") === name);
+};
+
+export {
+  MapService
+};

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

@@ -0,0 +1,19 @@
+import {
+  TerraTimeSeries
+} from "./chunk.PIEJ3UF6.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/time-series/time-series.ts
+init_dirname();
+init_buffer();
+init_process();
+var time_series_default = TerraTimeSeries;
+TerraTimeSeries.define("terra-time-series");
+
+export {
+  time_series_default
+};

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

@@ -0,0 +1,60 @@
+import {
+  card_styles_default
+} from "./chunk.D5XPPO66.js";
+import {
+  HasSlotController
+} from "./chunk.PACUQ7ID.js";
+import {
+  e
+} from "./chunk.KGXAA5I2.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.TG3YYWRJ.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/card/card.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var TerraCard = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(
+      this,
+      "footer",
+      "header",
+      "image"
+    );
+  }
+  render() {
+    return b`
+            <div
+                part="base"
+                class=${e({
+      card: true,
+      "card--has-footer": this.hasSlotController.test("footer"),
+      "card--has-image": this.hasSlotController.test("image"),
+      "card--has-header": this.hasSlotController.test("header")
+    })}
+            >
+                <slot name="image" part="image" class="card__image"></slot>
+                <slot name="header" part="header" class="card__header"></slot>
+                <slot part="body" class="card__body"></slot>
+                <slot name="footer" part="footer" class="card__footer"></slot>
+            </div>
+        `;
+  }
+};
+TerraCard.styles = [component_styles_default, card_styles_default];
+
+export {
+  TerraCard
+};