@nasa-terra/components 0.0.29 → 0.0.30

package/cdn/chunks/chunk.LLGXVXUH.js

@@ -0,0 +1,571 @@
+import {
+  format
+} from "./chunk.BPNFS4ED.js";
+import {
+  h,
+  i
+} from "./chunk.UGTZ22DI.js";
+import {
+  __asyncGenerator,
+  __await,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "./chunk.MR27IH5Z.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;
+}
+
+// node_modules/idb/build/index.js
+var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+var idbProxyableTypes;
+var cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+var transactionDoneMap = /* @__PURE__ */ new WeakMap();
+var transformCache = /* @__PURE__ */ new WeakMap();
+var reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
+}
+var idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      if (prop === "done")
+        return transactionDoneMap.get(target);
+      if (prop === "store") {
+        return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+var unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event.newVersion,
+      event
+    ));
+  }
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {
+  });
+  return openPromise;
+}
+var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+var writeMethods = ["put", "add", "delete", "clear"];
+var cachedMethods = /* @__PURE__ */ new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
+  }
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))
+  ) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx.store;
+    if (useIndex)
+      target2 = target2.index(args.shift());
+    return (await Promise.all([
+      target2[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps((oldTraps) => __spreadProps(__spreadValues({}, oldTraps), {
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
+var methodMap = {};
+var advanceResults = /* @__PURE__ */ new WeakMap();
+var ittrProxiedCursorToOriginalProxy = /* @__PURE__ */ new WeakMap();
+var cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop))
+      return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function(...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+function iterate(...args) {
+  return __asyncGenerator(this, null, function* () {
+    let cursor = this;
+    if (!(cursor instanceof IDBCursor)) {
+      cursor = yield new __await(cursor.openCursor(...args));
+    }
+    if (!cursor)
+      return;
+    cursor = cursor;
+    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+    reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+    while (cursor) {
+      yield proxiedCursor;
+      cursor = yield new __await(advanceResults.get(proxiedCursor) || cursor.continue());
+      advanceResults.delete(proxiedCursor);
+    }
+  });
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps((oldTraps) => __spreadProps(__spreadValues({}, oldTraps), {
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop))
+      return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+// src/internal/indexeddb.ts
+var DB_NAME = "terra";
+async function getDb() {
+  return await openDB(DB_NAME, 1, {
+    upgrade(db) {
+      db.createObjectStore("time-series" /* TIME_SERIES */, {
+        keyPath: "key"
+      });
+    }
+  });
+}
+async function withDb(callback) {
+  const db = await getDb();
+  try {
+    return await callback(db);
+  } finally {
+    await db.close();
+  }
+}
+function getDataByKey(store, key) {
+  return withDb(async (db) => {
+    return await db.get(store, key);
+  });
+}
+function storeDataByKey(store, key, data) {
+  return withDb(async (db) => {
+    await db.put(store, __spreadValues({
+      key
+    }, data));
+  });
+}
+
+// src/components/time-series/time-series.controller.ts
+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",
+  line: { color: "rgb(28, 103, 227)" }
+  // TODO: configureable?
+};
+var _bearerToken, _loadTimeSeries, loadTimeSeries_fn, _calculateDataGaps, calculateDataGaps_fn, _fetchTimeSeriesChunk, fetchTimeSeriesChunk_fn, _parseTimeSeriesCsv, parseTimeSeriesCsv_fn, _getDataInRange, getDataInRange_fn;
+var TimeSeriesController = class {
+  constructor(host, bearerToken) {
+    __privateAdd(this, _loadTimeSeries);
+    /**
+     * 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);
+    /**
+     * 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);
+    /**
+     * given a set of data and a date range, will return only the data that falls within that range
+     */
+    __privateAdd(this, _getDataInRange);
+    __privateAdd(this, _bearerToken, null);
+    this.emptyPlotData = [
+      __spreadProps(__spreadValues({}, plotlyDefaultData), {
+        x: [],
+        y: []
+      })
+    ];
+    __privateSet(this, _bearerToken, bearerToken);
+    this.host = host;
+    this.task = new h(host, {
+      autoRun: false,
+      // passing the signal in so the fetch request will be aborted when the task is aborted
+      task: async (_args, { signal }) => {
+        if (!this.collection || !this.variable || !this.startDate || !this.endDate || !this.location) {
+          return i;
+        }
+        const timeSeries = await __privateMethod(this, _loadTimeSeries, loadTimeSeries_fn).call(this, signal);
+        this.lastTaskValue = [
+          __spreadProps(__spreadValues({}, plotlyDefaultData), {
+            x: timeSeries.data.map((row) => row.timestamp),
+            y: timeSeries.data.map((row) => row.value)
+          })
+        ];
+        this.host.emit("terra-time-series-data-change", {
+          detail: {
+            data: timeSeries,
+            collection: this.collection,
+            variable: this.variable,
+            startDate: this.startDate.toISOString(),
+            endDate: this.endDate.toISOString(),
+            location: this.location
+          }
+        });
+        return this.lastTaskValue;
+      }
+    });
+  }
+  render(renderFunctions) {
+    return this.task.render(renderFunctions);
+  }
+};
+_bearerToken = new WeakMap();
+_loadTimeSeries = new WeakSet();
+loadTimeSeries_fn = async function(signal) {
+  const variableEntryId = `${this.collection}_${this.variable}`.replace(
+    /\./g,
+    "_"
+  );
+  const cacheKey = `${variableEntryId}_${this.location}`;
+  const existingTerraData = await getDataByKey(
+    "time-series" /* TIME_SERIES */,
+    cacheKey
+  );
+  if (existingTerraData && this.startDate.getTime() >= new Date(existingTerraData.startDate).getTime() && this.endDate.getTime() <= new Date(existingTerraData.endDate).getTime()) {
+    return __privateMethod(this, _getDataInRange, getDataInRange_fn).call(this, existingTerraData);
+  }
+  const dataGaps = __privateMethod(this, _calculateDataGaps, calculateDataGaps_fn).call(this, existingTerraData);
+  if (dataGaps.length === 0 && existingTerraData) {
+    return __privateMethod(this, _getDataInRange, getDataInRange_fn).call(this, existingTerraData);
+  }
+  const allChunks = [];
+  for (const gap of dataGaps) {
+    const chunks = calculateDateChunks(
+      this.host.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);
+      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);
+  }
+  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
+      }
+    );
+  }
+  return __privateMethod(this, _getDataInRange, getDataInRange_fn).call(this, {
+    metadata: consolidatedResult.metadata,
+    data: allData
+  });
+};
+_calculateDataGaps = new WeakSet();
+calculateDataGaps_fn = function(existingData) {
+  if (!existingData) {
+    return [{ start: this.startDate, end: this.endDate }];
+  }
+  const existingStartDate = new Date(existingData.startDate);
+  const existingEndDate = new Date(existingData.endDate);
+  const gaps = [];
+  if (this.startDate < existingStartDate) {
+    gaps.push({ start: this.startDate, end: existingStartDate });
+  }
+  if (this.endDate > existingEndDate) {
+    gaps.push({ start: existingEndDate, end: this.endDate });
+  }
+  return gaps;
+};
+_fetchTimeSeriesChunk = new WeakSet();
+fetchTimeSeriesChunk_fn = async function(variableEntryId, startDate, endDate, signal) {
+  var _a;
+  const [lon, lat] = decodeURIComponent((_a = this.location) != null ? _a : ", ").split(", ");
+  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: __spreadValues({
+      Accept: "application/json"
+    }, __privateGet(this, _bearerToken) ? { Authorization: `Bearer: ${__privateGet(this, _bearerToken)}` } : {})
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch time series data: ${response.statusText}`
+    );
+  }
+  return __privateMethod(this, _parseTimeSeriesCsv, parseTimeSeriesCsv_fn).call(this, await response.text());
+};
+_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 === "Timestamp (UTC),Data") {
+        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[dataHeaders[i2]] = parts[i2].trim();
+        }
+        data.push({
+          timestamp: row["Timestamp (UTC)"],
+          value: row["Data"]
+        });
+      }
+    }
+  }
+  return { metadata, data };
+};
+_getDataInRange = new WeakSet();
+getDataInRange_fn = function(data) {
+  return __spreadProps(__spreadValues({}, data), {
+    data: data.data.filter((row) => {
+      const timestamp = new Date(row.timestamp);
+      return timestamp >= this.startDate && timestamp <= this.endDate;
+    }).sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    )
+  });
+};
+
+export {
+  calculateDataPoints,
+  plotlyDefaultData,
+  TimeSeriesController
+};

package/cdn/chunks/{chunk.MOQDQMCK.js → chunk.LMBQZGKV.js}

@@ -1,6 +1,6 @@
 import {
   TerraSkeleton
-} from "./chunk.XUJ6GG3I.js";
+} from "./chunk.LCPNNUVW.js";
 
 // src/components/skeleton/skeleton.ts
 var skeleton_default = TerraSkeleton;

package/{dist/chunks/chunk.YQCBR4B6.js → cdn/chunks/chunk.MJAGRW43.js}

@@ -1,6 +1,6 @@
 import {
   TerraCombobox
-} from "./chunk.X2NOCGLF.js";
+} from "./chunk.6RTRSHJT.js";
 
 // src/components/combobox/combobox.ts
 var combobox_default = TerraCombobox;

package/cdn/chunks/{chunk.2NNEVPUU.js → chunk.MMPYQ7JX.js}

@@ -1,6 +1,6 @@
 import {
   TerraPlot
-} from "./chunk.EK2WNRX7.js";
+} from "./chunk.O7MMFKKX.js";
 
 // src/components/plot/plot.ts
 var plot_default = TerraPlot;

package/cdn/chunks/{chunk.NXRLD6HP.js → chunk.MU5CIHVF.js}

@@ -1,6 +1,6 @@
 import {
   TerraSkeleton
-} from "./chunk.XUJ6GG3I.js";
+} from "./chunk.LCPNNUVW.js";
 
 // src/react/skeleton/index.ts
 import * as React from "react";

package/cdn/chunks/{chunk.3BDUSUJJ.js → chunk.N3DIGSJT.js}

@@ -7,7 +7,7 @@ import {
 import {
   TerraElement,
   component_styles_default
-} from "./chunk.HSHJMWBR.js";
+} from "./chunk.AX2SA27I.js";
 import {
   n
 } from "./chunk.QCK7PTWV.js";

package/{dist/chunks/chunk.4RD7BI5G.js → cdn/chunks/chunk.N4W3LSG4.js}

@@ -1,6 +1,6 @@
 import {
   TerraLoader
-} from "./chunk.SBA3WOAN.js";
+} from "./chunk.GSG6MPDX.js";
 
 // src/react/loader/index.ts
 import * as React from "react";

package/cdn/chunks/{chunk.WGDILZM6.js → chunk.NMJ34B6C.js}

@@ -2,8 +2,8 @@ import {
   i
 } from "./chunk.PH7RLQK2.js";
 
-// src/components/giovanni-search/giovanni-search.styles.ts
-var giovanni_search_styles_default = i`
+// src/components/variable-keyword-search/variable-keyword-search.styles.ts
+var variable_keyword_search_styles_default = i`
     :host {
         --label-height: 1.8125rem;
 
@@ -221,5 +221,5 @@ var giovanni_search_styles_default = i`
 `;
 
 export {
-  giovanni_search_styles_default
+  variable_keyword_search_styles_default
 };

package/cdn/chunks/{chunk.EK2WNRX7.js → chunk.O7MMFKKX.js}

@@ -1,13 +1,13 @@
 import {
   plot_styles_default
-} from "./chunk.EZSX4R2K.js";
+} from "./chunk.PRXO3ACA.js";
 import {
   watch
 } from "./chunk.CBV7M6CJ.js";
 import {
   TerraElement,
   component_styles_default
-} from "./chunk.HSHJMWBR.js";
+} from "./chunk.AX2SA27I.js";
 import {
   e,
   n

package/cdn/chunks/{chunk.EZSX4R2K.js → chunk.PRXO3ACA.js}

@@ -9,7 +9,7 @@ var plot_styles_default = i`
     }
 
     :host::part(base) {
-        aspect-ratio: 4 / 3;
+        aspect-ratio: 16 / 9;
     }
 
     /**

package/{dist/chunks/chunk.V73GDG7A.js → cdn/chunks/chunk.PXFI6DWW.js}

@@ -1,6 +1,6 @@
 import {
   TerraChip
-} from "./chunk.BOJX33N7.js";
+} from "./chunk.N3DIGSJT.js";
 
 // src/components/chip/chip.ts
 var chip_default = TerraChip;

package/cdn/chunks/{chunk.4JSCLX3L.js → chunk.QALWOJYN.js}

@@ -1,6 +1,6 @@
 import {
   TerraDialog
-} from "./chunk.Z2TYLEAP.js";
+} from "./chunk.RE7Y5324.js";
 
 // src/react/dialog/index.ts
 import * as React from "react";