@nasa-terra/components 0.0.137 → 0.0.139

package/dist/chunks/chunk.YX54YA5F.js

@@ -0,0 +1,247 @@
+import {
+  data_grid_styles_default
+} from "./chunk.NP7CH4PH.js";
+import {
+  TerraLoader
+} from "./chunk.XE4T3WTA.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.R4VDG6AK.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/data-grid/data-grid.component.ts
+import { createRef, ref } from "lit/directives/ref.js";
+import { html, nothing } from "lit";
+import { property, state } from "lit/decorators.js";
+import {
+  createGrid,
+  AllCommunityModule,
+  ModuleRegistry
+} from "ag-grid-community";
+var _gridApi, _gridRef, _initializeGrid, initializeGrid_fn, _getDefaultGridOptions, getDefaultGridOptions_fn;
+var TerraDataGrid = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _initializeGrid);
+    __privateAdd(this, _getDefaultGridOptions);
+    this.height = "400px";
+    this.rowModelType = "clientSide";
+    this.theme = "alpine";
+    this.showLoading = false;
+    this.isLoading = false;
+    __privateAdd(this, _gridApi, void 0);
+    __privateAdd(this, _gridRef, createRef());
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    ModuleRegistry.registerModules([AllCommunityModule]);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    if (__privateGet(this, _gridApi)) {
+      __privateGet(this, _gridApi).destroy();
+      __privateSet(this, _gridApi, void 0);
+    }
+  }
+  firstVisible() {
+    __privateMethod(this, _initializeGrid, initializeGrid_fn).call(this);
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    if (changedProperties.has("gridOptions") || changedProperties.has("columnDefs") || changedProperties.has("rowData") || changedProperties.has("datasource") || changedProperties.has("rowModelType")) {
+      if (__privateGet(this, _gridApi) && __privateGet(this, _gridRef).value) {
+        __privateMethod(this, _initializeGrid, initializeGrid_fn).call(this);
+      }
+    }
+  }
+  /**
+   * Get the AG Grid API instance.
+   * Useful for programmatic control of the grid.
+   */
+  getGridApi() {
+    return __privateGet(this, _gridApi);
+  }
+  /**
+   * Refresh the grid data.
+   * For infinite scroll, purges cache and refetches.
+   */
+  refresh() {
+    if (__privateGet(this, _gridApi)) {
+      if (this.rowModelType === "infinite") {
+        __privateGet(this, _gridApi).purgeInfiniteCache();
+      } else {
+        __privateGet(this, _gridApi).refreshCells();
+      }
+    }
+  }
+  /**
+   * Export grid data to CSV.
+   */
+  exportToCsv(options) {
+    if (__privateGet(this, _gridApi)) {
+      __privateGet(this, _gridApi).exportDataAsCsv(options);
+    }
+  }
+  /**
+   * Export grid data to Excel.
+   * Note: Requires AG Grid Enterprise license.
+   */
+  exportToExcel(options) {
+    var _a, _b;
+    if (__privateGet(this, _gridApi)) {
+      (_b = (_a = __privateGet(this, _gridApi)).exportDataAsExcel) == null ? void 0 : _b.call(_a, options);
+    }
+  }
+  render() {
+    return html`
+            <div class="grid-container" part="base">
+                <div
+                    class="grid ag-theme-${this.theme}"
+                    part="grid"
+                    ${ref(__privateGet(this, _gridRef))}
+                    style="height: ${this.height};"
+                ></div>
+
+                ${this.isLoading && this.showLoading ? html`
+                          <div class="loading-overlay" part="loading">
+                              <terra-loader indeterminate></terra-loader>
+                          </div>
+                      ` : nothing}
+            </div>
+        `;
+  }
+};
+_gridApi = new WeakMap();
+_gridRef = new WeakMap();
+_initializeGrid = new WeakSet();
+initializeGrid_fn = function() {
+  var _a, _b, _c, _d, _e, _f;
+  if (!__privateGet(this, _gridRef).value) {
+    return;
+  }
+  if (__privateGet(this, _gridApi)) {
+    __privateGet(this, _gridApi).destroy();
+    __privateSet(this, _gridApi, void 0);
+  }
+  const options = __spreadProps(__spreadValues(__spreadValues({}, __privateMethod(this, _getDefaultGridOptions, getDefaultGridOptions_fn).call(this)), this.gridOptions), {
+    columnDefs: (_b = this.columnDefs) != null ? _b : (_a = this.gridOptions) == null ? void 0 : _a.columnDefs,
+    rowData: (_d = this.rowData) != null ? _d : (_c = this.gridOptions) == null ? void 0 : _c.rowData,
+    datasource: (_f = this.datasource) != null ? _f : (_e = this.gridOptions) == null ? void 0 : _e.datasource,
+    rowModelType: this.rowModelType
+  });
+  const originalOnGridReady = options.onGridReady;
+  options.onGridReady = (params) => {
+    __privateSet(this, _gridApi, params.api);
+    this.emit("terra-grid-ready", { detail: params });
+    if (originalOnGridReady) {
+      originalOnGridReady(params);
+    }
+  };
+  const originalOnSelectionChanged = options.onSelectionChanged;
+  options.onSelectionChanged = (params) => {
+    this.emit("terra-selection-changed", { detail: params });
+    if (originalOnSelectionChanged) {
+      originalOnSelectionChanged(params);
+    }
+  };
+  const originalOnSortChanged = options.onSortChanged;
+  options.onSortChanged = (params) => {
+    this.emit("terra-sort-changed", { detail: params });
+    if (originalOnSortChanged) {
+      originalOnSortChanged(params);
+    }
+  };
+  const originalOnFilterChanged = options.onFilterChanged;
+  options.onFilterChanged = (params) => {
+    this.emit("terra-filter-changed", { detail: params });
+    if (originalOnFilterChanged) {
+      originalOnFilterChanged(params);
+    }
+  };
+  const originalOnRowClicked = options.onRowClicked;
+  options.onRowClicked = (params) => {
+    this.emit("terra-row-clicked", { detail: params });
+    if (originalOnRowClicked) {
+      originalOnRowClicked(params);
+    }
+  };
+  const originalOnRowDoubleClicked = options.onRowDoubleClicked;
+  options.onRowDoubleClicked = (params) => {
+    this.emit("terra-row-double-clicked", { detail: params });
+    if (originalOnRowDoubleClicked) {
+      originalOnRowDoubleClicked(params);
+    }
+  };
+  const originalOnCellClicked = options.onCellClicked;
+  options.onCellClicked = (params) => {
+    this.emit("terra-cell-clicked", { detail: params });
+    if (originalOnCellClicked) {
+      originalOnCellClicked(params);
+    }
+  };
+  const originalOnCellValueChanged = options.onCellValueChanged;
+  options.onCellValueChanged = (params) => {
+    this.emit("terra-cell-value-changed", { detail: params });
+    if (originalOnCellValueChanged) {
+      originalOnCellValueChanged(params);
+    }
+  };
+  __privateSet(this, _gridApi, createGrid(__privateGet(this, _gridRef).value, options));
+};
+_getDefaultGridOptions = new WeakSet();
+getDefaultGridOptions_fn = function() {
+  return {
+    defaultColDef: {
+      sortable: true,
+      filter: true,
+      resizable: true
+    },
+    rowBuffer: 25,
+    cacheBlockSize: 50,
+    maxConcurrentDatasourceRequests: 2
+  };
+};
+TerraDataGrid.styles = [component_styles_default, data_grid_styles_default];
+TerraDataGrid.dependencies = {
+  "terra-loader": TerraLoader
+};
+__decorateClass([
+  property({ type: Object })
+], TerraDataGrid.prototype, "gridOptions", 2);
+__decorateClass([
+  property({ type: Array })
+], TerraDataGrid.prototype, "columnDefs", 2);
+__decorateClass([
+  property({ type: Array })
+], TerraDataGrid.prototype, "rowData", 2);
+__decorateClass([
+  property({ type: Object })
+], TerraDataGrid.prototype, "datasource", 2);
+__decorateClass([
+  property({ attribute: "height", type: String })
+], TerraDataGrid.prototype, "height", 2);
+__decorateClass([
+  property({ attribute: "row-model-type", type: String })
+], TerraDataGrid.prototype, "rowModelType", 2);
+__decorateClass([
+  property({ attribute: "theme", type: String })
+], TerraDataGrid.prototype, "theme", 2);
+__decorateClass([
+  property({ attribute: "show-loading", type: Boolean })
+], TerraDataGrid.prototype, "showLoading", 2);
+__decorateClass([
+  state()
+], TerraDataGrid.prototype, "isLoading", 2);
+
+export {
+  TerraDataGrid
+};

package/dist/chunks/chunk.Z2UUIIRV.js

@@ -0,0 +1,11 @@
+import {
+  TerraLoader
+} from "./chunk.XE4T3WTA.js";
+
+// src/components/loader/loader.ts
+var loader_default = TerraLoader;
+TerraLoader.define("terra-loader");
+
+export {
+  loader_default
+};

package/dist/chunks/chunk.Z35NQ7A7.js

@@ -0,0 +1,33 @@
+import {
+  TerraSelect
+} from "./chunk.5OE6LILN.js";
+
+// src/react/select/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-select";
+TerraSelect.define("terra-select");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraSelect,
+  react: React,
+  events: {
+    onTerraChange: "terra-change",
+    onTerraClear: "terra-clear",
+    onTerraInput: "terra-input",
+    onTerraFocus: "terra-focus",
+    onTerraBlur: "terra-blur",
+    onTerraShow: "terra-show",
+    onTerraAfterShow: "terra-after-show",
+    onTerraHide: "terra-hide",
+    onTerraAfterHide: "terra-after-hide",
+    onTerraInvalid: "terra-invalid"
+  },
+  displayName: "TerraSelect"
+});
+var select_default = reactWrapper;
+
+export {
+  select_default
+};

package/dist/chunks/chunk.Z4UDKTEF.js

@@ -0,0 +1,11 @@
+import {
+  TerraDropdown
+} from "./chunk.4JDUHDVS.js";
+
+// src/components/dropdown/dropdown.ts
+var dropdown_default = TerraDropdown;
+TerraDropdown.define("terra-dropdown");
+
+export {
+  dropdown_default
+};

package/dist/chunks/chunk.Z6G2TOJC.js

@@ -0,0 +1,241 @@
+import {
+  FINAL_STATUSES,
+  HarmonyDataService
+} from "./chunk.YLLE7U4B.js";
+import {
+  CmrCatalog
+} from "./chunk.3M5K2VRJ.js";
+import {
+  getUTCDate
+} from "./chunk.Y4QEHGFE.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/data-subsetter/data-subsetter.controller.ts
+import { Task } from "@lit/task";
+import Fuse from "fuse.js";
+var JOB_STATUS_POLL_MILLIS = 3e3;
+var _host, _dataService, _metadataCatalog, _getMetadataCatalog, getMetadataCatalog_fn, _getDataService, getDataService_fn, _getEmptyJob, getEmptyJob_fn, _buildJobLabels, buildJobLabels_fn;
+var DataSubsetterController = class {
+  constructor(host) {
+    __privateAdd(this, _getMetadataCatalog);
+    __privateAdd(this, _getDataService);
+    __privateAdd(this, _getEmptyJob);
+    __privateAdd(this, _buildJobLabels);
+    __privateAdd(this, _host, void 0);
+    __privateAdd(this, _dataService, void 0);
+    __privateAdd(this, _metadataCatalog, void 0);
+    __privateSet(this, _host, host);
+    __privateSet(this, _dataService, __privateMethod(this, _getDataService, getDataService_fn).call(this));
+    __privateSet(this, _metadataCatalog, __privateMethod(this, _getMetadataCatalog, getMetadataCatalog_fn).call(this));
+    this.fetchCollectionTask = new Task(host, {
+      task: async ([collectionEntryId], { signal }) => {
+        __privateGet(this, _host).collectionWithServices = collectionEntryId ? await __privateGet(this, _dataService).getCollectionWithAvailableServices(
+          collectionEntryId,
+          {
+            signal,
+            environment: __privateGet(this, _host).environment
+          }
+        ) : void 0;
+        return __privateGet(this, _host).collectionWithServices;
+      },
+      args: () => [__privateGet(this, _host).collectionEntryId]
+    });
+    this.searchCmrTask = new Task(host, {
+      task: async ([searchQuery, searchType], { signal }) => {
+        if (!searchQuery) {
+          __privateGet(this, _host).collectionSearchResults = void 0;
+          return __privateGet(this, _host).collectionSearchResults;
+        }
+        __privateGet(this, _host).collectionSearchLoading = true;
+        const results = await __privateGet(this, _metadataCatalog).searchCmr(
+          searchQuery,
+          searchType,
+          {
+            signal
+          }
+        );
+        const fuse = new Fuse(results, {
+          keys: ["title", "entryId", "provider"]
+        });
+        __privateGet(this, _host).collectionSearchResults = fuse.search(searchQuery).map((result) => result.item);
+        __privateGet(this, _host).collectionSearchLoading = false;
+        return __privateGet(this, _host).collectionSearchResults;
+      },
+      args: () => [
+        __privateGet(this, _host).collectionSearchQuery,
+        __privateGet(this, _host).collectionSearchType
+      ]
+    });
+    this.jobStatusTask = new Task(host, {
+      task: async ([], { signal }) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+        let job;
+        if ((_a = this.currentJob) == null ? void 0 : _a.jobID) {
+          job = await __privateGet(this, _dataService).getSubsetJobStatus(
+            this.currentJob.jobID,
+            {
+              signal,
+              bearerToken: __privateGet(this, _host).bearerToken,
+              environment: __privateGet(this, _host).environment
+            }
+          );
+        } else {
+          const isGiovanniFormat = __privateGet(this, _host).selectedFormat === "text/csv" || __privateGet(this, _host).selectedFormat === "image/tiff";
+          const collectionId = isGiovanniFormat ? `${(_b = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _b.shortName}_${(_d = (_c = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _c.collection) == null ? void 0 : _d.Version}` : (_f = (_e = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _e.conceptId) != null ? _f : "";
+          let subsetOptions = __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, isGiovanniFormat ? { collectionEntryId: collectionId } : { collectionConceptId: collectionId }), ((_g = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _g.variableSubset) && (isGiovanniFormat ? {
+            variableConceptIds: ["parameter_vars"],
+            variableEntryIds: __privateGet(this, _host).selectedVariables.map(
+              (v) => {
+                var _a2, _b2, _c2;
+                return `${(_a2 = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _a2.shortName}_${(_c2 = (_b2 = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _b2.collection) == null ? void 0 : _c2.Version}_${v.name}`;
+              }
+            )
+          } : {
+            variableConceptIds: __privateGet(this, _host).selectedVariables.map(
+              (v) => v.conceptId
+            )
+          })), "w" in ((_h = __privateGet(this, _host).spatialSelection) != null ? _h : {}) && ((_i = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _i.bboxSubset) && {
+            boundingBox: __privateGet(this, _host).spatialSelection
+          }), __privateGet(this, _host).selectedDateRange.startDate && __privateGet(this, _host).selectedDateRange.endDate && ((_j = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _j.temporalSubset) && {
+            startDate: getUTCDate(
+              __privateGet(this, _host).selectedDateRange.startDate
+            ).toISOString(),
+            endDate: getUTCDate(
+              __privateGet(this, _host).selectedDateRange.endDate,
+              true
+            ).toISOString()
+          }), __privateGet(this, _host).selectedFormat && ((_l = (_k = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _k.outputFormats) == null ? void 0 : _l.length) && {
+            format: __privateGet(this, _host).selectedFormat
+          }), __privateGet(this, _host).selectedFormat === "text/csv" && {
+            average: "area"
+          }), __privateGet(this, _host).selectedFormat === "image/tiff" && {
+            average: "time"
+          }), {
+            labels: []
+          });
+          subsetOptions.labels = __privateMethod(this, _buildJobLabels, buildJobLabels_fn).call(this, subsetOptions);
+          console.log(
+            `Creating a job for collection, ${(_m = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _m.conceptId}, with subset options`,
+            subsetOptions
+          );
+          this.currentJob = __privateMethod(this, _getEmptyJob, getEmptyJob_fn).call(this);
+          job = await __privateGet(this, _dataService).createSubsetJob(subsetOptions, {
+            signal,
+            bearerToken: __privateGet(this, _host).bearerToken,
+            environment: __privateGet(this, _host).environment
+          });
+        }
+        console.log("Job status: ", job);
+        if (job) {
+          this.currentJob = job;
+        }
+        if (!FINAL_STATUSES.has(this.currentJob.status)) {
+          setTimeout(() => {
+            this.jobStatusTask.run();
+          }, JOB_STATUS_POLL_MILLIS);
+        } else if (job) {
+          console.log("Subset job completed ", job);
+          __privateGet(this, _host).emit("terra-subset-job-complete", {
+            detail: job
+          });
+        }
+        return job;
+      },
+      args: () => [],
+      autoRun: false
+      // this task won't automatically be triggered, the component has to trigger it manually
+    });
+  }
+  render(renderFunctions) {
+    return this.jobStatusTask.render(renderFunctions);
+  }
+  fetchJobByID(jobID) {
+    this.currentJob = {
+      jobID,
+      status: "fetching" /* FETCHING */,
+      message: "Your job is being retrieved.",
+      progress: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dataExpiration: "",
+      request: "",
+      numInputGranules: 0,
+      links: []
+    };
+    this.jobStatusTask.run();
+  }
+  cancelCurrentJob() {
+    var _a;
+    if (!((_a = this.currentJob) == null ? void 0 : _a.jobID)) {
+      return;
+    }
+    __privateGet(this, _dataService).cancelSubsetJob(this.currentJob.jobID, {
+      bearerToken: __privateGet(this, _host).bearerToken,
+      environment: __privateGet(this, _host).environment
+    });
+  }
+};
+_host = new WeakMap();
+_dataService = new WeakMap();
+_metadataCatalog = new WeakMap();
+_getMetadataCatalog = new WeakSet();
+getMetadataCatalog_fn = function() {
+  return new CmrCatalog();
+};
+_getDataService = new WeakSet();
+getDataService_fn = function() {
+  return new HarmonyDataService();
+};
+_getEmptyJob = new WeakSet();
+getEmptyJob_fn = function() {
+  return {
+    jobID: "",
+    status: "running" /* RUNNING */,
+    message: "Your job is being created and will start soon.",
+    progress: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dataExpiration: "",
+    request: "",
+    numInputGranules: 0,
+    links: []
+  };
+};
+_buildJobLabels = new WeakSet();
+buildJobLabels_fn = function(subsetOptions) {
+  var _a, _b;
+  const labels = [];
+  for (const key of Object.keys(subsetOptions)) {
+    if (key !== "labels") {
+      const value = subsetOptions[key];
+      const valueStr = typeof value === "object" ? JSON.stringify(value) : value;
+      labels.push(encodeURIComponent(`${key}: ${valueStr}`));
+    }
+  }
+  if (__privateGet(this, _host).collectionEntryId) {
+    labels.push(
+      encodeURIComponent(
+        `collection-entry-id: ${__privateGet(this, _host).collectionEntryId}`
+      )
+    );
+  }
+  if ((_b = (_a = __privateGet(this, _host).collectionWithServices) == null ? void 0 : _a.collection) == null ? void 0 : _b.EntryTitle) {
+    labels.push(
+      encodeURIComponent(
+        `collection-entry-title: ${__privateGet(this, _host).collectionWithServices.collection.EntryTitle}`
+      )
+    );
+  }
+  return labels;
+};
+
+export {
+  DataSubsetterController
+};