@nasa-terra/components 0.0.175 → 0.0.177

package/dist/chunks/chunk.37I6WAMP.js

@@ -0,0 +1,770 @@
+import {
+  deleteDataByKey,
+  getDataByKey,
+  storeDataByKey
+} from "./chunk.A3DB425J.js";
+import {
+  extractHarmonyError
+} from "./chunk.ESNQNQUJ.js";
+import {
+  FINAL_STATUSES,
+  HarmonyDataService
+} from "./chunk.YLLE7U4B.js";
+import {
+  formatDate,
+  getUTCDate,
+  isDateRangeContained
+} from "./chunk.Y4QEHGFE.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "./chunk.SHKVBVTI.js";
+
+// 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 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 "daily" /* Daily */:
+      return Math.floor(diffMs / MILLIS_IN_DAY) + 1;
+    case "weekly" /* Weekly */:
+      return Math.floor(diffMs / (MILLIS_IN_DAY * 7)) + 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 totalDurationMs = endDate.getTime() - startDate.getTime();
+  const numChunks = Math.ceil(totalDataPoints / MAX_DATAPOINTS_PER_REQUEST);
+  const chunkSizeMs = Math.floor(totalDurationMs / numChunks);
+  let chunkStart = new Date(startDate);
+  let remainingDuration = totalDurationMs;
+  while (remainingDuration > 0) {
+    let potentialChunkEnd = new Date(chunkStart.getTime() + chunkSizeMs);
+    if (potentialChunkEnd > endDate) {
+      potentialChunkEnd = endDate;
+    }
+    const chunkDataPoints = calculateDataPoints(
+      timeInterval,
+      chunkStart,
+      potentialChunkEnd
+    );
+    if (chunkDataPoints > MAX_DATAPOINTS_PER_REQUEST) {
+      const maxDurationMs = chunkSizeMs * MAX_DATAPOINTS_PER_REQUEST / chunkDataPoints;
+      potentialChunkEnd = new Date(chunkStart.getTime() + maxDurationMs);
+    }
+    chunks.push({
+      start: new Date(chunkStart),
+      end: new Date(potentialChunkEnd)
+    });
+    remainingDuration = endDate.getTime() - potentialChunkEnd.getTime();
+    chunkStart = potentialChunkEnd;
+  }
+  return chunks;
+}
+
+// src/components/time-series/time-series.controller.ts
+import { format } from "date-fns";
+import { initialState, Task } from "@lit/task";
+var NUM_DATAPOINTS_TO_WARN_USER = 5e4;
+var REFRESH_HARMONY_DATA_INTERVAL = 2e3;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var endpoint = "https://8weebb031a.execute-api.us-east-1.amazonaws.com/SIT/timeseries-no-user";
+var plotlyDefaultData = {
+  // holds the default Plotly configuration options.
+  // see https://plotly.com/javascript/time-series/
+  type: "scatter",
+  mode: "lines"
+};
+var _userConfirmedWarning, _dataService, _getRequestedVariables, getRequestedVariables_fn, _loadTimeSeries, loadTimeSeries_fn, _isCacheValid, isCacheValid_fn, _calculateDataGaps, calculateDataGaps_fn, _fetchTimeSeriesChunk, fetchTimeSeriesChunk_fn, _waitForHarmonyJob, waitForHarmonyJob_fn, _parseTimeSeriesCsv, parseTimeSeriesCsv_fn, _normalizeTimestamp, normalizeTimestamp_fn, _filterFillValues, filterFillValues_fn, _deduplicateByTimestamp, deduplicateByTimestamp_fn, _getDataInRange, getDataInRange_fn, _normalizeCoordinates, normalizeCoordinates_fn, _checkDataPointLimits, checkDataPointLimits_fn, _detectTimeInterval, detectTimeInterval_fn, _getDataService, getDataService_fn, _handleHarmonyError, handleHarmonyError_fn;
+var TimeSeriesController = class {
+  constructor(host) {
+    __privateAdd(this, _getRequestedVariables);
+    __privateAdd(this, _loadTimeSeries);
+    /**
+     * Checks if cached data is still valid (not expired)
+     */
+    __privateAdd(this, _isCacheValid);
+    /**
+     * Calculates what data gaps need to be filled from the API
+     */
+    __privateAdd(this, _calculateDataGaps);
+    /**
+     * Fetches a single chunk of time series data
+     */
+    __privateAdd(this, _fetchTimeSeriesChunk);
+    __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);
+    /**
+     * Deduplicates time series data by timestamp, keeping the first occurrence
+     */
+    __privateAdd(this, _deduplicateByTimestamp);
+    /**
+     * given a set of data and a date range, will return only the data that falls within that range
+     */
+    __privateAdd(this, _getDataInRange);
+    /**
+     * Normalizes coordinates to 2 decimal places
+     */
+    __privateAdd(this, _normalizeCoordinates);
+    /**
+     * 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, _getDataService);
+    /**
+     * Handles errors from Harmony GraphQL operations and dispatches them as events
+     */
+    __privateAdd(this, _handleHarmonyError);
+    __privateAdd(this, _userConfirmedWarning, false);
+    __privateAdd(this, _dataService, void 0);
+    this.emptyPlotData = [
+      __spreadProps(__spreadValues({}, plotlyDefaultData), {
+        x: [],
+        y: []
+      })
+    ];
+    __privateSet(this, _dataService, __privateMethod(this, _getDataService, getDataService_fn).call(this));
+    this.host = host;
+    this.task = new Task(host, {
+      // passing the signal in so the fetch request will be aborted when the task is aborted
+      task: async (_args, { signal }) => {
+        var _a;
+        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 ");
+          return initialState;
+        }
+        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;
+        this.lastTaskValue = seriesResults.map(
+          ({ variable, filteredData }) => {
+            var _a2, _b;
+            return __spreadProps(__spreadValues({}, plotlyDefaultData), {
+              name: (_b = (_a2 = variable.dataFieldLongName) != null ? _a2 : variable.dataFieldShortName) != null ? _b : 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];
+        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
+          }
+        });
+        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);
+  }
+  /**
+   * 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) {
+    var _a;
+    if (!this.host.location) {
+      return "";
+    }
+    const normalizedCoordinates = __privateMethod(this, _normalizeCoordinates, normalizeCoordinates_fn).call(this, this.host.location.split(","));
+    const normalizedLocation = normalizedCoordinates.join(",%20");
+    const environment = (_a = this.host.environment) != null ? _a : "prod";
+    return `${catalogVariable.dataFieldId}_${normalizedLocation}_${environment}`;
+  }
+  /**
+   * Called when the user confirms the data point warning
+   */
+  confirmDataPointWarning() {
+    __privateSet(this, _userConfirmedWarning, true);
+    this.host.showDataPointWarning = false;
+  }
+  /**
+   * Clears expired cache entries for the current cache key
+   */
+  async clearExpiredCache() {
+    try {
+      const cacheKey = this.getCacheKey();
+      const existingData = await getDataByKey(
+        "time-series" /* TIME_SERIES */,
+        cacheKey
+      );
+      if (existingData && !__privateMethod(this, _isCacheValid, isCacheValid_fn).call(this, existingData)) {
+        await deleteDataByKey("time-series" /* TIME_SERIES */, cacheKey);
+        console.log(`Cleared expired cache for key: ${cacheKey}`);
+      }
+    } catch (error) {
+      console.warn("Error clearing expired cache:", error);
+    }
+  }
+};
+_userConfirmedWarning = new WeakMap();
+_dataService = new WeakMap();
+_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;
+  const startDate = getUTCDate(this.host.startDate);
+  const endDate = getUTCDate(this.host.endDate, true);
+  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
+  );
+  const existingTerraData = await getDataByKey(
+    "time-series" /* TIME_SERIES */,
+    cacheKey
+  );
+  console.log("Existing data?", existingTerraData ? "Yes" : "No");
+  console.log(
+    "Is date range contained?",
+    isDateRangeContained(
+      startDate,
+      endDate,
+      getUTCDate(existingTerraData == null ? void 0 : existingTerraData.startDate),
+      getUTCDate(existingTerraData == null ? void 0 : existingTerraData.endDate, true)
+    )
+  );
+  console.log("Is cache valid?", __privateMethod(this, _isCacheValid, isCacheValid_fn).call(this, existingTerraData));
+  if (existingTerraData && isDateRangeContained(
+    startDate,
+    endDate,
+    getUTCDate(existingTerraData == null ? void 0 : existingTerraData.startDate),
+    getUTCDate(existingTerraData == null ? void 0 : existingTerraData.endDate, true)
+  ) && __privateMethod(this, _isCacheValid, isCacheValid_fn).call(this, existingTerraData)) {
+    console.log("Returning existing data from cache ", this.getCacheKey());
+    const fillValue = (_a = existingTerraData.metadata) == null ? void 0 : _a.undef;
+    const filteredData2 = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, existingTerraData.data, fillValue);
+    const filteredTimeSeries = __spreadProps(__spreadValues({}, existingTerraData), {
+      data: filteredData2
+    });
+    return __privateMethod(this, _getDataInRange, getDataInRange_fn).call(this, filteredTimeSeries);
+  }
+  const dataGaps = __privateMethod(this, _calculateDataGaps, calculateDataGaps_fn).call(this, existingTerraData);
+  if (dataGaps.length === 0 && existingTerraData) {
+    const filteredData2 = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, existingTerraData.data, (_b = existingTerraData.metadata) == null ? void 0 : _b.undef);
+    const filteredTimeSeries = __spreadProps(__spreadValues({}, existingTerraData), {
+      data: filteredData2
+    });
+    return __privateMethod(this, _getDataInRange, getDataInRange_fn).call(this, filteredTimeSeries);
+  }
+  const detectedInterval = (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 dataGaps) {
+    const chunks = calculateDateChunks(timeInterval, gap.start, gap.end);
+    allChunks.push(...chunks);
+  }
+  const chunkResults = await Promise.all(
+    allChunks.map(async (chunk) => {
+      const result = await __privateMethod(this, _fetchTimeSeriesChunk, fetchTimeSeriesChunk_fn).call(this, variableEntryId, chunk.start, chunk.end, signal, catalogVariable);
+      return result;
+    })
+  );
+  let allData = (existingTerraData == null ? void 0 : existingTerraData.data) || [];
+  let metadata = {};
+  for (const chunkResult of chunkResults) {
+    allData = [...allData, ...chunkResult.data];
+    metadata = __spreadValues(__spreadValues({}, metadata), chunkResult.metadata);
+  }
+  allData = __privateMethod(this, _deduplicateByTimestamp, deduplicateByTimestamp_fn).call(this, allData);
+  const consolidatedResult = {
+    metadata,
+    data: allData
+  };
+  if (allData.length > 0) {
+    const sortedData = [...allData].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    await storeDataByKey(
+      "time-series" /* TIME_SERIES */,
+      cacheKey,
+      {
+        variableEntryId,
+        key: cacheKey,
+        startDate: sortedData[0].timestamp,
+        endDate: sortedData[sortedData.length - 1].timestamp,
+        metadata: consolidatedResult.metadata,
+        data: sortedData,
+        environment: this.host.environment,
+        cachedAt: (/* @__PURE__ */ new Date()).getTime()
+      }
+    );
+  }
+  const filteredData = __privateMethod(this, _filterFillValues, filterFillValues_fn).call(this, allData, metadata == null ? void 0 : metadata.undef);
+  return __privateMethod(this, _getDataInRange, getDataInRange_fn).call(this, {
+    metadata: consolidatedResult.metadata,
+    data: filteredData
+  });
+};
+_isCacheValid = new WeakSet();
+isCacheValid_fn = function(existingData) {
+  if (!(existingData == null ? void 0 : existingData.cachedAt)) {
+    this.clearExpiredCache();
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  const cacheIsExpired = now - existingData.cachedAt > CACHE_TTL_MS;
+  if (cacheIsExpired) {
+    this.clearExpiredCache();
+  }
+  return !cacheIsExpired;
+};
+_calculateDataGaps = new WeakSet();
+calculateDataGaps_fn = function(existingData) {
+  const start = getUTCDate(this.host.startDate);
+  const end = getUTCDate(this.host.endDate);
+  if (!existingData) {
+    return [{ start, end }];
+  }
+  const existingStartDate = new Date(existingData.startDate);
+  const existingEndDate = new Date(existingData.endDate);
+  const gaps = [];
+  if (start < existingStartDate) {
+    gaps.push({ start, end: existingStartDate });
+  }
+  if (end > existingEndDate) {
+    gaps.push({ start: existingEndDate, end });
+  }
+  return gaps;
+};
+_fetchTimeSeriesChunk = new WeakSet();
+fetchTimeSeriesChunk_fn = async function(variableEntryId, startDate, endDate, signal, catalogVariable) {
+  var _a, _b, _c;
+  let timeSeriesCsvData = "";
+  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 parsedLocation = decodeURIComponent((_a = this.host.location) != null ? _a : ",").split(
+    ","
+  );
+  if (parsedLocation.length === 4) {
+    const collection = `${catalogVariable.dataProductShortName}_${catalogVariable.dataProductVersion}`;
+    const [w, s, e, n] = parsedLocation;
+    let subsetOptions = {
+      collectionEntryId: collection,
+      variableConceptIds: ["parameter_vars"],
+      variableEntryIds: [variableEntryId],
+      startDate: format(startDate, "yyyy-MM-dd") + "T00%3A00%3A00",
+      endDate: format(endDate, "yyyy-MM-dd") + "T23%3A59%3A59",
+      format: "text/csv",
+      boundingBox: {
+        w: parseFloat(w),
+        s: parseFloat(s),
+        e: parseFloat(e),
+        n: parseFloat(n)
+      },
+      average: "area"
+    };
+    console.log(
+      `Creating a Harmony job for collection, ${collection}, with subset options`,
+      subsetOptions
+    );
+    let job;
+    try {
+      job = await __privateGet(this, _dataService).createSubsetJob(subsetOptions, {
+        signal,
+        bearerToken: this.host.bearerToken,
+        environment: this.host.environment
+      });
+    } catch (error) {
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+      throw error;
+    }
+    if (!job) {
+      const error = new Error("Failed to create subset job");
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+      throw error;
+    }
+    const jobStatus = await __privateMethod(this, _waitForHarmonyJob, waitForHarmonyJob_fn).call(this, job, signal);
+    if (jobStatus.status === "failed" /* FAILED */) {
+      const errorMessage = jobStatus.message || ((_c = (_b = jobStatus.errors) == null ? void 0 : _b[0]) == null ? void 0 : _c.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;
+    }
+    try {
+      const { text } = await __privateGet(this, _dataService).getSubsetJobData(jobStatus, {
+        signal,
+        bearerToken: this.host.bearerToken,
+        environment: this.host.environment
+      });
+      timeSeriesCsvData = text;
+    } catch (error) {
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+      throw error;
+    }
+  } else {
+    const [lat, lon] = __privateMethod(this, _normalizeCoordinates, normalizeCoordinates_fn).call(this, parsedLocation);
+    const url = `${endpoint}?${new URLSearchParams({
+      data: variableEntryId,
+      lat,
+      lon,
+      time_start: format(startDate, "yyyy-MM-dd") + "T00%3A00%3A00",
+      time_end: format(endDate, "yyyy-MM-dd") + "T23%3A59%3A59"
+    }).toString()}`;
+    const response = await fetch(url, {
+      mode: "cors",
+      signal,
+      headers: {
+        Accept: "application/json"
+        /* TODO: figure out why bearer tokens are not working
+        ...(this.host.bearerToken
+            ? { Authorization: `Bearer: ${this.host.bearerToken}` }
+            : {}),
+            */
+      }
+    });
+    if (!response.ok) {
+      let errorDetails = {};
+      const contentType = response.headers.get("content-type");
+      if (contentType == null ? void 0 : contentType.includes("application/json")) {
+        try {
+          errorDetails = await response.json();
+        } catch (e) {
+          errorDetails = { message: response.statusText };
+        }
+      } else {
+        errorDetails = { message: response.statusText };
+      }
+      this.host.dispatchEvent(
+        new CustomEvent("terra-time-series-error", {
+          detail: {
+            status: response.status,
+            code: errorDetails.code || String(response.status),
+            message: errorDetails.message || response.statusText,
+            context: errorDetails.context
+          },
+          bubbles: true,
+          composed: true
+        })
+      );
+      throw new Error(
+        `Failed to fetch time series data: ${errorDetails.message || response.statusText}`
+      );
+    }
+    timeSeriesCsvData = await response.text();
+  }
+  return __privateMethod(this, _parseTimeSeriesCsv, parseTimeSeriesCsv_fn).call(this, timeSeriesCsvData);
+};
+_waitForHarmonyJob = new WeakSet();
+waitForHarmonyJob_fn = function(job, signal) {
+  return new Promise(async (resolve, reject) => {
+    if (signal.aborted) {
+      reject(new Error("Job polling was aborted"));
+      return;
+    }
+    let jobStatus;
+    try {
+      jobStatus = await __privateGet(this, _dataService).getSubsetJobStatus(job.jobID, {
+        signal,
+        bearerToken: this.host.bearerToken,
+        environment: this.host.environment
+      });
+      console.log("Job status", jobStatus);
+    } catch (error) {
+      console.error("Error checking harmony job status", error);
+      if (signal.aborted || (error == null ? void 0 : error.name) === "AbortError") {
+        reject(error);
+        return;
+      }
+      __privateMethod(this, _handleHarmonyError, handleHarmonyError_fn).call(this, error);
+      reject(error);
+      return;
+    }
+    if (jobStatus && FINAL_STATUSES.has(jobStatus.status)) {
+      console.log("Job is done", jobStatus);
+      resolve(jobStatus);
+    } else {
+      if (signal.aborted) {
+        reject(new Error("Job polling was aborted"));
+        return;
+      }
+      const abortHandler = () => {
+        reject(new Error("Job polling was aborted"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      setTimeout(async () => {
+        signal.removeEventListener("abort", abortHandler);
+        if (signal.aborted) {
+          reject(new Error("Job polling was aborted"));
+          return;
+        }
+        try {
+          resolve(await __privateMethod(this, _waitForHarmonyJob, waitForHarmonyJob_fn).call(this, job, signal));
+        } catch (error) {
+          reject(error);
+        }
+      }, REFRESH_HARMONY_DATA_INTERVAL);
+    }
+  });
+};
+_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((h) => h.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 i = 0; i < dataHeaders.length; i++) {
+          row.push(parts[i].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 (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 (!isNaN(rowNum) && !isNaN(fillNum) && rowNum === fillNum) {
+      return false;
+    }
+    return true;
+  });
+};
+_deduplicateByTimestamp = new WeakSet();
+deduplicateByTimestamp_fn = function(data) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const timestamp = row.timestamp;
+    if (!seen.has(timestamp)) {
+      seen.set(timestamp, row);
+    }
+  }
+  return Array.from(seen.values());
+};
+_getDataInRange = new WeakSet();
+getDataInRange_fn = function(data) {
+  const startDate = getUTCDate(this.host.startDate);
+  const endDate = getUTCDate(this.host.endDate);
+  return __spreadProps(__spreadValues({}, data), {
+    data: data.data.filter((row) => {
+      const timestamp = new Date(row.timestamp);
+      return timestamp >= startDate && timestamp <= endDate;
+    }).sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    )
+  });
+};
+_normalizeCoordinates = new WeakSet();
+normalizeCoordinates_fn = function(coordinates) {
+  return coordinates.map((coord) => Number(coord).toFixed(2));
+};
+_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 i = 1; i < Math.min(sortedData.length, 100); i++) {
+    const prevTime = new Date(sortedData[i - 1].timestamp).getTime();
+    const currTime = new Date(sortedData[i].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 */;
+};
+_getDataService = new WeakSet();
+getDataService_fn = function() {
+  return new HarmonyDataService();
+};
+_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
+};