@nasa-terra/components 0.0.198 → 0.0.199

package/cdn/chunks/chunk.55WRSCJY.js

@@ -0,0 +1,978 @@
+import {
+  time_series_cache_service_default
+} from "./chunk.EM46QCN4.js";
+import {
+  require_plotly_min
+} from "./chunk.NPCTDW7V.js";
+import {
+  HarmonyRequestController
+} from "./chunk.CROGJ6YF.js";
+import {
+  HarmonyRequest
+} from "./chunk.5YAN7WHN.js";
+import {
+  extractHarmonyError
+} from "./chunk.USKVG5GU.js";
+import {
+  h,
+  i
+} from "./chunk.BQDEKCXK.js";
+import {
+  CollectionController
+} from "./chunk.JXSV4XD4.js";
+import {
+  FINAL_STATUSES,
+  ThumbnailService,
+  harmonyApi
+} from "./chunk.I7HUTXHU.js";
+import {
+  LatLngBounds
+} from "./chunk.B2HOZPO6.js";
+import {
+  LatLng
+} from "./chunk.Y3EV6C6T.js";
+import {
+  formatDate,
+  getUTCDate,
+  isDateRangeContained
+} from "./chunk.X2BIJLHO.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadProps,
+  __spreadValues,
+  __toESM,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/time-series/time-series.controller.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/dataset.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/types.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/dataset.ts
+var MAX_DATAPOINTS_PER_REQUEST = 2e5;
+var MILLIS_IN_HOUR = 1e3 * 60 * 60;
+var MILLIS_IN_DAY = MILLIS_IN_HOUR * 24;
+function getIntervalMs(timeInterval) {
+  switch (timeInterval) {
+    case "half-hourly" /* HalfHourly */:
+      return MILLIS_IN_HOUR / 2;
+    case "hourly" /* Hourly */:
+      return MILLIS_IN_HOUR;
+    case "3-hourly" /* ThreeHourly */:
+      return MILLIS_IN_HOUR * 3;
+    case "8-daily" /* EightDaily */:
+      return MILLIS_IN_DAY * 8;
+    case "daily" /* Daily */:
+      return MILLIS_IN_DAY;
+    case "weekly" /* Weekly */:
+      return MILLIS_IN_DAY * 7;
+    case "monthly" /* Monthly */:
+      return MILLIS_IN_DAY * 30;
+    default:
+      throw new Error(`Unsupported time interval: ${timeInterval}`);
+  }
+}
+function calculateDataPoints(timeInterval, startDate, endDate) {
+  const diffMs = endDate.getTime() - startDate.getTime();
+  switch (timeInterval) {
+    case "half-hourly" /* HalfHourly */:
+      return Math.floor(diffMs / (MILLIS_IN_HOUR / 2)) + 1;
+    case "hourly" /* Hourly */:
+      return Math.floor(diffMs / MILLIS_IN_HOUR) + 1;
+    case "3-hourly" /* ThreeHourly */:
+      return Math.floor(diffMs / (MILLIS_IN_HOUR * 3)) + 1;
+    case "8-daily" /* EightDaily */:
+      return Math.floor(diffMs / (MILLIS_IN_DAY * 8)) + 1;
+    case "daily" /* Daily */:
+      return Math.floor(diffMs / MILLIS_IN_DAY) + 1;
+    case "weekly" /* Weekly */:
+      return Math.floor(diffMs / (MILLIS_IN_DAY * 7)) + 1;
+    case "monthly" /* Monthly */:
+      return Math.floor(diffMs / (MILLIS_IN_DAY * 30)) + 1;
+    default:
+      throw new Error(`Unsupported time interval: ${timeInterval}`);
+  }
+}
+function calculateDateChunks(timeInterval, startDate, endDate) {
+  const totalDataPoints = calculateDataPoints(timeInterval, startDate, endDate);
+  if (totalDataPoints <= MAX_DATAPOINTS_PER_REQUEST) {
+    return [{ start: startDate, end: endDate }];
+  }
+  const chunks = [];
+  const intervalMs = getIntervalMs(timeInterval);
+  const maxChunkSpanMs = intervalMs * (MAX_DATAPOINTS_PER_REQUEST - 1);
+  let chunkStartMs = startDate.getTime();
+  const endMs = endDate.getTime();
+  while (chunkStartMs <= endMs) {
+    const chunkEndMs = Math.min(chunkStartMs + maxChunkSpanMs, endMs);
+    chunks.push({
+      start: new Date(chunkStartMs),
+      end: new Date(chunkEndMs)
+    });
+    if (chunkEndMs >= endMs) {
+      break;
+    }
+    const nextChunkStartMs = chunkEndMs + intervalMs;
+    if (nextChunkStartMs <= chunkStartMs) {
+      break;
+    }
+    chunkStartMs = nextChunkStartMs;
+  }
+  return chunks;
+}
+
+// src/components/time-series/time-series.controller.ts
+var Plotly = __toESM(require_plotly_min(), 1);
+var NUM_DATAPOINTS_TO_WARN_USER = 5e4;
+var HARMONY_LINK_PROXY_URL = "https://lpo4uv7f0h.execute-api.us-east-1.amazonaws.com/default/harmony-link-proxy";
+var HARMONY_STATUS_WAIT_INTERVAL_MS = 300;
+var MAX_CONCEPT_ID_WAIT_MS = 1e4;
+var MAX_GAP_FILL_PASSES = 4;
+var plotlyDefaultData = {
+  // holds the default Plotly configuration options.
+  // see https://plotly.com/javascript/time-series/
+  type: "scatter",
+  mode: "lines"
+};
+var _userConfirmedWarning, _cacheService, _thumbnailService, _lastHarmonyJobId, _lastFetchedVariableIds, _collectionController, _harmonyRequestController, _emitChunkProgress, emitChunkProgress_fn, _getRequestedVariables, getRequestedVariables_fn, _loadTimeSeries, loadTimeSeries_fn, _fetchTimeSeriesChunk, fetchTimeSeriesChunk_fn, _fetchHarmonyDataLink, fetchHarmonyDataLink_fn, _waitForHarmonyJob, waitForHarmonyJob_fn, _parseTimeSeriesCsv, parseTimeSeriesCsv_fn, _normalizeTimestamp, normalizeTimestamp_fn, _filterFillValues, filterFillValues_fn, _checkDataPointLimits, checkDataPointLimits_fn, _detectTimeInterval, detectTimeInterval_fn, _getCollectionEntryId, getCollectionEntryId_fn, _waitForCollectionConceptId, waitForCollectionConceptId_fn, _parseLocationInput, parseLocationInput_fn, _capturePlotThumbnail, capturePlotThumbnail_fn, _sleep, sleep_fn, _handleHarmonyError, handleHarmonyError_fn;
+var TimeSeriesController = class {
+  constructor(host) {
+    __privateAdd(this, _emitChunkProgress);
+    __privateAdd(this, _getRequestedVariables);
+    __privateAdd(this, _loadTimeSeries);
+    /**
+     * Fetches a single chunk of time series data
+     */
+    __privateAdd(this, _fetchTimeSeriesChunk);
+    __privateAdd(this, _fetchHarmonyDataLink);
+    __privateAdd(this, _waitForHarmonyJob);
+    /**
+     * the data we receive for the time series is in CSV format, but with metadata at the top
+     * this function parses the CSV data and returns an object of the metadata and the data
+     */
+    __privateAdd(this, _parseTimeSeriesCsv);
+    /**
+     * Normalizes timestamp format to be consistent between point-based and area-averaged data
+     * Point-based data format: "2013-11-28 23:30"
+     * Area-averaged data format: "2009-01-01T00:30:00.000000000"
+     * This function converts both formats to ISO 8601 format while preserving full time resolution
+     */
+    __privateAdd(this, _normalizeTimestamp);
+    /**
+     * Filters out fill values from time series data
+     */
+    __privateAdd(this, _filterFillValues);
+    /**
+     * Checks if the current date range will exceed data point limits
+     * Returns true if it's safe to proceed, false if confirmation is needed
+     */
+    __privateAdd(this, _checkDataPointLimits);
+    /**
+     * Detects the actual time interval from the data by analyzing timestamp differences
+     * Returns the detected TimeInterval or null if unable to determine
+     */
+    __privateAdd(this, _detectTimeInterval);
+    __privateAdd(this, _getCollectionEntryId);
+    __privateAdd(this, _waitForCollectionConceptId);
+    __privateAdd(this, _parseLocationInput);
+    __privateAdd(this, _capturePlotThumbnail);
+    __privateAdd(this, _sleep);
+    /**
+     * Handles errors from Harmony GraphQL operations and dispatches them as events
+     */
+    __privateAdd(this, _handleHarmonyError);
+    __privateAdd(this, _userConfirmedWarning, false);
+    __privateAdd(this, _cacheService, new time_series_cache_service_default());
+    __privateAdd(this, _thumbnailService, new ThumbnailService());
+    __privateAdd(this, _lastHarmonyJobId, void 0);
+    __privateAdd(this, _lastFetchedVariableIds, void 0);
+    __privateAdd(this, _collectionController, void 0);
+    __privateAdd(this, _harmonyRequestController, void 0);
+    this.emptyPlotData = [
+      __spreadProps(__spreadValues({}, plotlyDefaultData), {
+        x: [],
+        y: []
+      })
+    ];
+    this.host = host;
+    __privateSet(this, _collectionController, new CollectionController(this.host, {
+      getCollectionEntryId: () => __privateMethod(this, _getCollectionEntryId, getCollectionEntryId_fn).call(this),
+      getBearerToken: () => this.host.bearerToken
+    }));
+    __privateSet(this, _harmonyRequestController, new HarmonyRequestController(this.host));
+    new h(host, {
+      task: async (_args, { signal }) => {
+        var _a;
+        const { jobId } = this.host;
+        if (!jobId || !this.host.bearerToken || this.host.startDate && this.host.endDate && this.host.location) {
+          return;
+        }
+        const jobStatus = await harmonyApi.getJobStatus(jobId, {
+          bearerToken: this.host.bearerToken,
+          signal
+        });
+        const parsed = HarmonyRequest.fromUrl(jobStatus.request);
+        const {
+          startDate,
+          endDate,
+          location,
+          variables,
+          variableConceptIds
+        } = parsed.options;
+        if (startDate)
+          this.host.startDate = startDate;
+        if (endDate)
+          this.host.endDate = endDate;
+        if (location instanceof LatLng) {
+          this.host.location = `${location.lat},${location.lng}`;
+        } else if (location instanceof LatLngBounds) {
+          const [w, s, e, n] = [
+            location.getWest(),
+            location.getSouth(),
+            location.getEast(),
+            location.getNorth()
+          ];
+          this.host.location = `${w},${s},${e},${n}`;
+        }
+        const variableId = (_a = variables == null ? void 0 : variables[0]) != null ? _a : variableConceptIds == null ? void 0 : variableConceptIds[0];
+        if (variableId && !this.host.variableEntryId) {
+          this.host.variableEntryId = variableId;
+        }
+        this.host.requestUpdate();
+      },
+      args: () => [this.host.jobId, this.host.bearerToken]
+    });
+    this.task = new h(host, {
+      // passing the signal in so the fetch request will be aborted when the task is aborted
+      task: async (_args, { signal }) => {
+        var _a, _b;
+        console.log("Fetching time series data", {
+          variables: __privateMethod(this, _getRequestedVariables, getRequestedVariables_fn).call(this),
+          startDate: this.host.startDate,
+          endDate: this.host.endDate,
+          location: this.host.location
+        });
+        if (!__privateMethod(this, _getRequestedVariables, getRequestedVariables_fn).call(this).length || !this.host.startDate || !this.host.endDate || !this.host.location) {
+          console.log("Requirements not met to fetch the time series data ");
+          const currentVariableIds = __privateMethod(this, _getRequestedVariables, getRequestedVariables_fn).call(this).map((v) => v.dataFieldId).join("|");
+          if (currentVariableIds !== __privateGet(this, _lastFetchedVariableIds)) {
+            this.lastTaskValue = void 0;
+          }
+          return i;
+        }
+        const requestedVariables = __privateMethod(this, _getRequestedVariables, getRequestedVariables_fn).call(this);
+        const seriesResults = await Promise.all(
+          requestedVariables.map(async (variable) => {
+            var _a2;
+            const timeSeries = await __privateMethod(this, _loadTimeSeries, loadTimeSeries_fn).call(this, signal, variable);
+            const filteredData = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, timeSeries.data, (_a2 = timeSeries.metadata) == null ? void 0 : _a2.undef);
+            return {
+              variable,
+              timeSeries,
+              filteredData
+            };
+          })
+        );
+        this.metadata = (_a = seriesResults[0]) == null ? void 0 : _a.timeSeries.metadata;
+        __privateSet(this, _lastFetchedVariableIds, __privateMethod(this, _getRequestedVariables, getRequestedVariables_fn).call(this).map((v) => v.dataFieldId).join("|"));
+        this.lastTaskValue = seriesResults.map(
+          ({ variable, filteredData }) => {
+            var _a2, _b2;
+            return __spreadProps(__spreadValues({}, plotlyDefaultData), {
+              name: (_b2 = (_a2 = variable.dataFieldLongName) != null ? _a2 : variable.dataFieldShortName) != null ? _b2 : variable.dataFieldId,
+              hovertemplate: variable.dataFieldUnits ? `%{x}<br>%{y} ${variable.dataFieldUnits}<extra>%{fullData.name}</extra>` : "%{x}<br>%{y}<extra>%{fullData.name}</extra>",
+              x: filteredData.map((row) => row.timestamp),
+              y: filteredData.map((row) => row.value)
+            });
+          }
+        );
+        const firstSeries = seriesResults[0];
+        if (!firstSeries) {
+          return (_b = this.lastTaskValue) != null ? _b : this.emptyPlotData;
+        }
+        this.host.emit("terra-time-series-data-change", {
+          detail: {
+            data: firstSeries.timeSeries,
+            variable: firstSeries.variable,
+            series: seriesResults.map(({ variable, timeSeries }) => ({
+              variable,
+              data: timeSeries
+            })),
+            startDate: formatDate(this.host.startDate),
+            endDate: formatDate(this.host.endDate),
+            location: this.host.location
+          }
+        });
+        if (__privateGet(this, _lastHarmonyJobId)) {
+          __privateMethod(this, _capturePlotThumbnail, capturePlotThumbnail_fn).call(this, __privateGet(this, _lastHarmonyJobId)).catch(
+            console.error
+          );
+        }
+        return this.lastTaskValue;
+      },
+      args: () => [
+        this.host.catalogVariable,
+        this.host.catalogVariables,
+        this.host.startDate,
+        this.host.endDate,
+        this.host.location
+      ]
+    });
+  }
+  render(renderFunctions) {
+    return this.task.render(renderFunctions);
+  }
+  /**
+   * Cancels the in-flight Harmony job server-side (best-effort) and aborts
+   * the local data-loading task.
+   */
+  async cancelJob() {
+    const jobId = __privateGet(this, _harmonyRequestController).jobId;
+    if (jobId && jobId !== "new") {
+      try {
+        await __privateGet(this, _harmonyRequestController).cancelJob({
+          jobId,
+          options: { bearerToken: this.host.bearerToken }
+        });
+      } catch (error) {
+        console.warn("Failed to cancel Harmony job", error);
+      }
+    }
+    this.task.abort("Cancelled time series request");
+  }
+  /**
+   * Gets the cache key for the current time series data
+   */
+  getCacheKey() {
+    if (!this.host.location || !this.host.catalogVariable) {
+      return "";
+    }
+    return this.getCacheKeyForVariable(this.host.catalogVariable);
+  }
+  getCacheKeyForVariable(catalogVariable) {
+    return __privateGet(this, _cacheService).getCacheKeyForVariable(
+      catalogVariable.dataFieldId,
+      this.host.location,
+      this.host.environment
+    );
+  }
+  /**
+   * Called when the user confirms the data point warning
+   */
+  confirmDataPointWarning() {
+    __privateSet(this, _userConfirmedWarning, true);
+    this.host.showDataPointWarning = false;
+  }
+};
+_userConfirmedWarning = new WeakMap();
+_cacheService = new WeakMap();
+_thumbnailService = new WeakMap();
+_lastHarmonyJobId = new WeakMap();
+_lastFetchedVariableIds = new WeakMap();
+_collectionController = new WeakMap();
+_harmonyRequestController = new WeakMap();
+_emitChunkProgress = new WeakSet();
+emitChunkProgress_fn = function(currentChunk, totalChunks) {
+  this.host.dispatchEvent(
+    new CustomEvent("terra-time-series-chunk-progress-change", {
+      detail: {
+        currentChunk,
+        totalChunks
+      },
+      bubbles: true,
+      composed: true
+    })
+  );
+};
+_getRequestedVariables = new WeakSet();
+getRequestedVariables_fn = function() {
+  var _a;
+  if ((_a = this.host.catalogVariables) == null ? void 0 : _a.length) {
+    return this.host.catalogVariables;
+  }
+  if (this.host.catalogVariable) {
+    return [this.host.catalogVariable];
+  }
+  return [];
+};
+_loadTimeSeries = new WeakSet();
+loadTimeSeries_fn = async function(signal, catalogVariable) {
+  var _a, _b, _c, _d, _e;
+  const hostStartDate = this.host.startDate;
+  const hostEndDate = this.host.endDate;
+  if (!hostStartDate || !hostEndDate) {
+    throw new Error(
+      "Start and end date are required to fetch time series data"
+    );
+  }
+  const hasTimeComponent = (dateStr) => /T\d{2}:\d{2}/.test(dateStr);
+  const startDate = getUTCDate(hostStartDate);
+  const endDate = getUTCDate(hostEndDate, !hasTimeComponent(hostEndDate));
+  const cacheKey = this.getCacheKeyForVariable(catalogVariable);
+  const variableEntryId = catalogVariable.dataFieldId;
+  console.log(
+    "Loading time series for variable",
+    catalogVariable,
+    this.host.startDate,
+    this.host.endDate,
+    this.host.location
+  );
+  if (this.host.jobId) {
+    const jobStatus = await __privateMethod(this, _waitForHarmonyJob, waitForHarmonyJob_fn).call(this, this.host.jobId, signal);
+    if (jobStatus.status === "failed" /* FAILED */) {
+      const errorMessage = jobStatus.message || ((_b = (_a = jobStatus.errors) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) || "The subset job failed";
+      const error = new Error(errorMessage);
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+      throw error;
+    }
+    if (jobStatus.status === "complete_with_errors" /* COMPLETE_WITH_ERRORS */ && jobStatus.errors && jobStatus.errors.length > 0) {
+      const errorMessage = jobStatus.errors[0].message || "The subset job completed with errors";
+      const error = new Error(errorMessage);
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+      throw error;
+    }
+    const dataLink = (_c = jobStatus.links.find((link) => link.rel === "data")) == null ? void 0 : _c.href;
+    if (!dataLink) {
+      const error = new Error("No data link found for Harmony job");
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+      throw error;
+    }
+    __privateSet(this, _lastHarmonyJobId, this.host.jobId);
+    return __privateMethod(this, _fetchHarmonyDataLink, fetchHarmonyDataLink_fn).call(this, dataLink, signal);
+  }
+  const existingTerraData = this.host.cache ? await __privateGet(this, _cacheService).getValidCacheEntry(cacheKey) : void 0;
+  const existingStartDate = (existingTerraData == null ? void 0 : existingTerraData.startDate) ? getUTCDate(existingTerraData.startDate) : void 0;
+  const existingEndDate = (existingTerraData == null ? void 0 : existingTerraData.endDate) ? getUTCDate(existingTerraData.endDate, true) : void 0;
+  console.log("Existing data?", existingTerraData ? "Yes" : "No");
+  console.log(
+    "Is date range contained?",
+    existingStartDate && existingEndDate ? isDateRangeContained(
+      startDate,
+      endDate,
+      existingStartDate,
+      existingEndDate
+    ) : false
+  );
+  console.log(
+    "Is cache valid?",
+    __privateGet(this, _cacheService).isCacheValid(existingTerraData)
+  );
+  if (existingTerraData && existingStartDate && existingEndDate && isDateRangeContained(
+    startDate,
+    endDate,
+    existingStartDate,
+    existingEndDate
+  ) && __privateGet(this, _cacheService).isCacheValid(existingTerraData)) {
+    console.log("Returning existing data from cache ", this.getCacheKey());
+    const fillValue = (_d = existingTerraData.metadata) == null ? void 0 : _d.undef;
+    const filteredData2 = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, existingTerraData.data, fillValue);
+    const filteredTimeSeries = __spreadProps(__spreadValues({}, existingTerraData), {
+      data: filteredData2
+    });
+    return __privateGet(this, _cacheService).getDataInRange(
+      filteredTimeSeries,
+      startDate,
+      endDate
+    );
+  }
+  const dataGaps = __privateGet(this, _cacheService).calculateDataGaps(
+    startDate,
+    endDate,
+    existingTerraData
+  );
+  if (dataGaps.length === 0 && existingTerraData) {
+    const filteredData2 = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, existingTerraData.data, (_e = existingTerraData.metadata) == null ? void 0 : _e.undef);
+    const filteredTimeSeries = __spreadProps(__spreadValues({}, existingTerraData), {
+      data: filteredData2
+    });
+    return __privateGet(this, _cacheService).getDataInRange(
+      filteredTimeSeries,
+      startDate,
+      endDate
+    );
+  }
+  let allData = (existingTerraData == null ? void 0 : existingTerraData.data) || [];
+  let metadata = (existingTerraData == null ? void 0 : existingTerraData.metadata) || {};
+  let pendingGaps = dataGaps;
+  for (let pass = 0; pass < MAX_GAP_FILL_PASSES && pendingGaps.length > 0; pass++) {
+    const detectedInterval = allData.length ? __privateMethod(this, _detectTimeInterval, detectTimeInterval_fn).call(this, allData) : (existingTerraData == null ? void 0 : existingTerraData.data) ? __privateMethod(this, _detectTimeInterval, detectTimeInterval_fn).call(this, existingTerraData.data) : null;
+    const timeInterval = detectedInterval || catalogVariable.dataProductTimeInterval || "daily" /* Daily */;
+    const allChunks = [];
+    for (const gap of pendingGaps) {
+      const chunks = calculateDateChunks(timeInterval, gap.start, gap.end);
+      allChunks.push(...chunks);
+    }
+    const shouldReportChunkProgress = allChunks.length > 1;
+    const previousDataLength = allData.length;
+    try {
+      for (const [index, chunk] of allChunks.entries()) {
+        if (shouldReportChunkProgress) {
+          __privateMethod(this, _emitChunkProgress, emitChunkProgress_fn).call(this, index + 1, allChunks.length);
+        }
+        const result = await __privateMethod(this, _fetchTimeSeriesChunk, fetchTimeSeriesChunk_fn).call(this, variableEntryId, chunk.start, chunk.end, signal, catalogVariable);
+        allData = [...allData, ...result.data];
+        metadata = __spreadValues(__spreadValues({}, metadata), result.metadata);
+        allData = __privateGet(this, _cacheService).deduplicateByTimestamp(allData);
+        if (this.host.cache) {
+          await __privateGet(this, _cacheService).storeConsolidatedData({
+            cacheKey,
+            variableEntryId,
+            environment: this.host.environment,
+            metadata,
+            data: allData
+          });
+        }
+      }
+    } finally {
+      if (shouldReportChunkProgress) {
+        __privateMethod(this, _emitChunkProgress, emitChunkProgress_fn).call(this, 0, 0);
+      }
+    }
+    if (allData.length === previousDataLength) {
+      break;
+    }
+    const sortedData = [...allData].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const synthesizedCoverage = sortedData.length > 0 ? {
+      variableEntryId,
+      key: cacheKey,
+      startDate: sortedData[0].timestamp,
+      endDate: sortedData[sortedData.length - 1].timestamp,
+      cachedAt: Date.now(),
+      metadata,
+      data: sortedData,
+      environment: this.host.environment
+    } : void 0;
+    pendingGaps = __privateGet(this, _cacheService).calculateDataGaps(
+      startDate,
+      endDate,
+      synthesizedCoverage
+    );
+  }
+  const consolidatedResult = {
+    metadata,
+    data: allData
+  };
+  if (this.host.cache) {
+    await __privateGet(this, _cacheService).storeConsolidatedData({
+      cacheKey,
+      variableEntryId,
+      environment: this.host.environment,
+      metadata: consolidatedResult.metadata,
+      data: allData,
+      requestedStartDate: startDate,
+      requestedEndDate: endDate
+    });
+  }
+  const filteredData = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, allData, metadata == null ? void 0 : metadata.undef);
+  return __privateGet(this, _cacheService).getDataInRange(
+    {
+      metadata: consolidatedResult.metadata,
+      data: filteredData
+    },
+    startDate,
+    endDate
+  );
+};
+_fetchTimeSeriesChunk = new WeakSet();
+fetchTimeSeriesChunk_fn = async function(variableEntryId, startDate, endDate, signal, catalogVariable) {
+  var _a, _b, _c;
+  if (!__privateGet(this, _userConfirmedWarning) && !__privateMethod(this, _checkDataPointLimits, checkDataPointLimits_fn).call(this, catalogVariable, startDate, endDate)) {
+    throw new Error("User cancelled data point warning");
+  }
+  __privateSet(this, _userConfirmedWarning, false);
+  const location = __privateMethod(this, _parseLocationInput, parseLocationInput_fn).call(this);
+  const isBoundingBoxLocation = location instanceof LatLngBounds;
+  const collectionConceptId = await __privateMethod(this, _waitForCollectionConceptId, waitForCollectionConceptId_fn).call(this, signal);
+  const harmonyRequest = new HarmonyRequest({
+    collectionConceptId,
+    location
+  }).variable(variableEntryId).dateRange(startDate.toISOString(), endDate.toISOString()).format("text/csv").label("terra-time-series");
+  if (this.host.applicationId) {
+    harmonyRequest.label(this.host.applicationId);
+  }
+  harmonyRequest.addLabelsFromVariable(catalogVariable);
+  if (isBoundingBoxLocation) {
+    harmonyRequest.average("area");
+  }
+  let jobId;
+  try {
+    const job = await __privateGet(this, _harmonyRequestController).startJob({
+      harmonyRequest,
+      options: {
+        signal,
+        bearerToken: this.host.bearerToken,
+        environment: this.host.environment
+      }
+    });
+    jobId = job.jobID;
+    __privateSet(this, _lastHarmonyJobId, jobId);
+    this.host.emit("terra-harmony-job-status-update", {
+      detail: job
+    });
+  } catch (error) {
+    __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+    throw error;
+  }
+  const jobStatus = await __privateMethod(this, _waitForHarmonyJob, waitForHarmonyJob_fn).call(this, jobId, signal);
+  if (jobStatus.status === "failed" /* FAILED */) {
+    const errorMessage = jobStatus.message || ((_b = (_a = jobStatus.errors) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) || "The subset job failed";
+    const error = new Error(errorMessage);
+    __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+    throw error;
+  }
+  if (jobStatus.status === "complete_with_errors" /* COMPLETE_WITH_ERRORS */ && jobStatus.errors && jobStatus.errors.length > 0) {
+    const errorMessage = jobStatus.errors[0].message || "The subset job completed with errors";
+    const error = new Error(errorMessage);
+    __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+    throw error;
+  }
+  const dataLink = (_c = jobStatus.links.find((link) => link.rel === "data")) == null ? void 0 : _c.href;
+  if (!dataLink) {
+    const error = new Error("No data link found for Harmony job");
+    __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error, jobStatus.errors);
+    throw error;
+  }
+  return __privateMethod(this, _fetchHarmonyDataLink, fetchHarmonyDataLink_fn).call(this, dataLink, signal);
+};
+_fetchHarmonyDataLink = new WeakSet();
+fetchHarmonyDataLink_fn = async function(dataLink, signal) {
+  const normalizedLink = dataLink.replace("proxy-timeseries", "timeseries");
+  const proxyUrl = `${HARMONY_LINK_PROXY_URL}?url=${encodeURIComponent(normalizedLink)}`;
+  const response = await fetch(proxyUrl, {
+    signal,
+    headers: __spreadValues({}, this.host.bearerToken ? { Authorization: `Bearer ${this.host.bearerToken}` } : {})
+  });
+  if (!response.ok) {
+    const error = new Error(
+      `Failed to fetch subset job link contents: ${response.statusText}`
+    );
+    __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+    throw error;
+  }
+  return __privateMethod(this, _parseTimeSeriesCsv, parseTimeSeriesCsv_fn).call(this, await response.text());
+};
+_waitForHarmonyJob = new WeakSet();
+waitForHarmonyJob_fn = async function(jobId, signal) {
+  __privateGet(this, _harmonyRequestController).startPollForJobStatus(jobId, {
+    bearerToken: this.host.bearerToken
+  });
+  while (true) {
+    if (signal.aborted) {
+      throw new Error("Job polling was aborted");
+    }
+    const jobStatus = __privateGet(this, _harmonyRequestController).data;
+    if (jobStatus) {
+      this.host.emit("terra-harmony-job-status-update", {
+        detail: jobStatus
+      });
+    }
+    if ((jobStatus == null ? void 0 : jobStatus.jobID) === jobId && FINAL_STATUSES.has(jobStatus.status)) {
+      return jobStatus;
+    }
+    await __privateMethod(this, _sleep, sleep_fn).call(this, HARMONY_STATUS_WAIT_INTERVAL_MS, signal);
+  }
+};
+_parseTimeSeriesCsv = new WeakSet();
+parseTimeSeriesCsv_fn = function(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const metadata = {};
+  const data = [];
+  let inDataSection = false;
+  let dataHeaders = [];
+  for (const line of lines) {
+    if (!inDataSection) {
+      if (line.startsWith("Timestamp (UTC)") || line.startsWith("time,")) {
+        dataHeaders = line.split(",").map((h2) => h2.trim());
+        inDataSection = true;
+        continue;
+      }
+      const [key, value] = line.split(",");
+      if (key && value !== void 0) {
+        metadata[key.trim()] = value.trim();
+      }
+    } else {
+      const parts = line.split(",");
+      if (parts.length === dataHeaders.length) {
+        const row = [];
+        for (let i2 = 0; i2 < dataHeaders.length; i2++) {
+          row.push(parts[i2].trim());
+        }
+        const timestamp = __privateMethod(this, _normalizeTimestamp, normalizeTimestamp_fn).call(this, row[0]);
+        data.push({
+          timestamp,
+          value: row[1]
+        });
+      }
+    }
+  }
+  return { metadata, data };
+};
+_normalizeTimestamp = new WeakSet();
+normalizeTimestamp_fn = function(timestamp) {
+  try {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+      console.warn("Invalid timestamp:", timestamp);
+      return timestamp;
+    }
+    return date.toISOString();
+  } catch (error) {
+    console.warn("Failed to normalize timestamp:", timestamp, error);
+    return timestamp;
+  }
+};
+_filterFillValues = new WeakSet();
+filterFillValues_fn = function(data, fillValue) {
+  if (!fillValue) {
+    return data;
+  }
+  return data.filter((row) => {
+    const rowValue = row.value.trim();
+    const fillValueStr = String(fillValue).trim();
+    if (rowValue === fillValueStr) {
+      return false;
+    }
+    const rowNum = parseFloat(rowValue);
+    const fillNum = parseFloat(fillValueStr);
+    if (!Number.isNaN(rowNum) && !Number.isNaN(fillNum) && rowNum === fillNum) {
+      return false;
+    }
+    return true;
+  });
+};
+_checkDataPointLimits = new WeakSet();
+checkDataPointLimits_fn = function(catalogVariable, startDate, endDate) {
+  this.host.estimatedDataPoints = calculateDataPoints(
+    catalogVariable.dataProductTimeInterval,
+    startDate,
+    endDate
+  );
+  if (this.host.estimatedDataPoints < NUM_DATAPOINTS_TO_WARN_USER) {
+    return true;
+  }
+  return true;
+};
+_detectTimeInterval = new WeakSet();
+detectTimeInterval_fn = function(data) {
+  if (data.length < 2) {
+    return null;
+  }
+  const sortedData = [...data].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const intervals = [];
+  for (let i2 = 1; i2 < Math.min(sortedData.length, 100); i2++) {
+    const prevTime = new Date(sortedData[i2 - 1].timestamp).getTime();
+    const currTime = new Date(sortedData[i2].timestamp).getTime();
+    const diffMs = currTime - prevTime;
+    if (diffMs > 0) {
+      intervals.push(diffMs);
+    }
+  }
+  if (intervals.length === 0) {
+    return null;
+  }
+  const intervalCounts = /* @__PURE__ */ new Map();
+  intervals.forEach((interval) => {
+    const rounded = Math.round(interval / (1e3 * 60)) * (1e3 * 60);
+    intervalCounts.set(rounded, (intervalCounts.get(rounded) || 0) + 1);
+  });
+  let mostCommonInterval = 0;
+  let maxCount = 0;
+  intervalCounts.forEach((count, interval) => {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommonInterval = interval;
+    }
+  });
+  const MILLIS_IN_HOUR2 = 1e3 * 60 * 60;
+  const MILLIS_IN_DAY2 = MILLIS_IN_HOUR2 * 24;
+  if (mostCommonInterval <= MILLIS_IN_HOUR2 / 2 + 6e4) {
+    return "half-hourly" /* HalfHourly */;
+  } else if (mostCommonInterval <= MILLIS_IN_HOUR2 + 6e4) {
+    return "hourly" /* Hourly */;
+  } else if (mostCommonInterval <= MILLIS_IN_HOUR2 * 3 + 6e4) {
+    return "3-hourly" /* ThreeHourly */;
+  } else if (mostCommonInterval <= MILLIS_IN_DAY2 + 6e4) {
+    return "daily" /* Daily */;
+  } else if (mostCommonInterval <= MILLIS_IN_DAY2 * 7 + 6e4) {
+    return "weekly" /* Weekly */;
+  }
+  return "daily" /* Daily */;
+};
+_getCollectionEntryId = new WeakSet();
+getCollectionEntryId_fn = function() {
+  if (this.host.collection) {
+    return this.host.collection;
+  }
+  const variable = this.host.catalogVariable;
+  if (!variable) {
+    return void 0;
+  }
+  return `${variable.dataProductShortName}_${variable.dataProductVersion}`;
+};
+_waitForCollectionConceptId = new WeakSet();
+waitForCollectionConceptId_fn = async function(signal) {
+  var _a;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < MAX_CONCEPT_ID_WAIT_MS) {
+    if (signal.aborted) {
+      throw new Error(
+        "Request aborted while waiting for collection metadata"
+      );
+    }
+    const conceptId = __privateGet(this, _collectionController).conceptId;
+    if (conceptId) {
+      return conceptId;
+    }
+    if ((_a = __privateGet(this, _collectionController).collection) == null ? void 0 : _a.isError) {
+      const error2 = new Error(
+        "Unable to load collection metadata needed for Harmony requests"
+      );
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error2);
+      throw error2;
+    }
+    await __privateMethod(this, _sleep, sleep_fn).call(this, HARMONY_STATUS_WAIT_INTERVAL_MS, signal);
+  }
+  const error = new Error(
+    "Timed out waiting for collection metadata needed for Harmony requests"
+  );
+  __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+  throw error;
+};
+_parseLocationInput = new WeakSet();
+parseLocationInput_fn = function() {
+  var _a;
+  const rawLocation = decodeURIComponent((_a = this.host.location) != null ? _a : "");
+  const rawCoordinates = rawLocation.split(",").map((coord) => coord.trim());
+  const coordinates = rawCoordinates.map((coord) => Number(coord));
+  const hasInvalidCoordinates = rawCoordinates.some((coord) => coord.length === 0) || coordinates.some((value) => Number.isNaN(value));
+  if (hasInvalidCoordinates) {
+    const error2 = new Error(
+      'Invalid location format. Expected "lat,lon" or "west,south,east,north".'
+    );
+    this.host.dispatchEvent(
+      new CustomEvent("terra-time-series-error", {
+        detail: {
+          status: 400,
+          code: "INVALID_LOCATION",
+          message: error2.message,
+          context: rawLocation
+        },
+        bubbles: true,
+        composed: true
+      })
+    );
+    throw error2;
+  }
+  if (coordinates.length === 2) {
+    return new LatLng(coordinates[0], coordinates[1]);
+  }
+  if (coordinates.length === 4) {
+    return new LatLngBounds(coordinates);
+  }
+  const error = new Error(
+    'Invalid location format. Expected "lat,lon" or "west,south,east,north".'
+  );
+  this.host.dispatchEvent(
+    new CustomEvent("terra-time-series-error", {
+      detail: {
+        status: 400,
+        code: "INVALID_LOCATION",
+        message: error.message,
+        context: rawLocation
+      },
+      bubbles: true,
+      composed: true
+    })
+  );
+  throw error;
+};
+_capturePlotThumbnail = new WeakSet();
+capturePlotThumbnail_fn = async function(harmonyJobId, delayMs = 1e3, thumbWidth = 200, thumbHeight = 200) {
+  var _a;
+  await __privateMethod(this, _sleep, sleep_fn).call(this, delayMs);
+  const plotEl = (_a = this.host.plot) == null ? void 0 : _a.base;
+  if (!plotEl) {
+    return;
+  }
+  try {
+    const dataUrl = await Plotly.toImage(plotEl, {
+      format: "jpeg",
+      width: 500,
+      height: 500
+    });
+    const img = new Image();
+    img.src = dataUrl;
+    await img.decode();
+    const canvas = document.createElement("canvas");
+    canvas.width = thumbWidth;
+    canvas.height = thumbHeight;
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+      return void 0;
+    ctx.drawImage(img, 0, 0, thumbWidth, thumbHeight);
+    const blob = await new Promise(
+      (resolve, reject) => canvas.toBlob(
+        (b) => b ? resolve(b) : reject(new Error("toBlob failed")),
+        "image/jpeg",
+        0.8
+      )
+    );
+    await __privateGet(this, _thumbnailService).store(harmonyJobId, blob);
+  } catch (error) {
+    console.error("Failed to capture time series thumbnail", error);
+  }
+};
+_sleep = new WeakSet();
+sleep_fn = function(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (signal) {
+        signal.removeEventListener("abort", handleAbort);
+      }
+      resolve();
+    }, ms);
+    const handleAbort = () => {
+      clearTimeout(timeoutId);
+      reject(new Error("Operation aborted"));
+    };
+    if (signal) {
+      signal.addEventListener("abort", handleAbort, { once: true });
+    }
+  });
+};
+_handleHarmonyError = new WeakSet();
+handleHarmonyError_fn = function(error, jobErrors) {
+  const errorDetails = extractHarmonyError(error, jobErrors);
+  this.host.dispatchEvent(
+    new CustomEvent("terra-time-series-error", {
+      detail: errorDetails,
+      bubbles: true,
+      composed: true
+    })
+  );
+};
+
+export {
+  plotlyDefaultData,
+  TimeSeriesController
+};