@nasa-terra/components 0.0.173 → 0.0.175

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

@@ -1,770 +0,0 @@
-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
-};