@powerhousedao/connect 1.0.17-dev.0 → 1.0.17-dev.2

package/dist/assets/{index-DDUCDBt7.js → index-CU3_V46J.js}

@@ -1,8 +1,8 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-loader-Y-ZBJpoD.js","assets/main.DWnLOhnO.js","assets/app-loader-DiF8OhX3.css"])))=>i.map(i=>d[i]);
-import { _ as __vitePreload } from "./main.DWnLOhnO.js";
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-loader-Ej0QwX6c.js","assets/main.D0KZAQpb.js","assets/app-loader-DiF8OhX3.css"])))=>i.map(i=>d[i]);
+import { _ as __vitePreload } from "./main.D0KZAQpb.js";
 import { createRoot } from "react-dom/client";
 async function renderApp(element) {
-  const AppLoader = await __vitePreload(() => import("./app-loader-Y-ZBJpoD.js").then((n) => n.ca), true ? __vite__mapDeps([0,1,2]) : void 0);
+  const AppLoader = await __vitePreload(() => import("./app-loader-Ej0QwX6c.js").then((n) => n.cb), true ? __vite__mapDeps([0,1,2]) : void 0);
   createRoot(element).render(AppLoader.default);
 }
 const AppElement = document.getElementById("app");
@@ -10,3 +10,4 @@ if (!AppElement) {
   throw new Error("#app element not found!");
 }
 renderApp(AppElement).catch(console.error);
+//# sourceMappingURL=index-CU3_V46J.js.map

package/dist/assets/index-CU3_V46J.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;AAEA,eAAe,UAAU,SAAsB;AACrC,oBAAY,MAAM,2BAAO,0BAA4B;AAC3D,aAAW,OAAO,EAAE,OAAO,UAAU,OAAO;AAChD;AAEA,MAAM,aAAa,SAAS,eAAe,KAAK;AAChD,IAAI,CAAC,YAAY;AACP,YAAI,MAAM,yBAAyB;AAC7C;AAEA,UAAU,UAAU,EAAE,MAAM,QAAQ,KAAK","names":[],"ignoreList":[],"sources":["../../src/index.ts"],"sourcesContent":["import { createRoot } from 'react-dom/client';\n\nasync function renderApp(element: HTMLElement) {\n    const AppLoader = await import('./components/app-loader.js');\n    createRoot(element).render(AppLoader.default);\n}\n\nconst AppElement = document.getElementById('app');\nif (!AppElement) {\n    throw new Error('#app element not found!');\n}\n\nrenderApp(AppElement).catch(console.error);\n"],"file":"assets/index-CU3_V46J.js"}

package/dist/assets/{main.DWnLOhnO.js → main.D0KZAQpb.js}

@@ -99,7 +99,8 @@ const __vitePreload = function preload(baseModule, deps, importerUrl) {
     return baseModule().catch(handlePreloadError);
   });
 };
-__vitePreload(() => import("./index-DDUCDBt7.js"), true ? [] : void 0);
+__vitePreload(() => import("./index-CU3_V46J.js"), true ? [] : void 0);
 export {
   __vitePreload as _
 };
+//# sourceMappingURL=main.D0KZAQpb.js.map

package/dist/assets/main.D0KZAQpb.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA8BA,OAAO,qBAAY","names":[],"ignoreList":[],"sources":["../../src/renderer.ts"],"sourcesContent":["/**\n * This file will automatically be loaded by vite and run in the \"renderer\" context.\n * To learn more about the differences between the \"main\" and the \"renderer\" context in\n * Electron, visit:\n *\n * https://electronjs.org/docs/tutorial/application-architecture#main-and-renderer-processes\n *\n * By default, Node.js integration in this file is disabled. When enabling Node.js integration\n * in a renderer process, please be aware of potential security implications. You can read\n * more about security risks here:\n *\n * https://electronjs.org/docs/tutorial/security\n *\n * To enable Node.js integration in this file, open up `main.js` and enable the `nodeIntegration`\n * flag:\n *\n * ```\n *  // Create the browser window.\n *  mainWindow = new BrowserWindow({\n *    width: 800,\n *    height: 600,\n *    webPreferences: {\n *      nodeIntegration: true\n *    }\n *  });\n * ```\n */\n\n// splits app code into separate chunk to avoid circular dependencies\n// eslint-disable-next-line @typescript-eslint/no-floating-promises\nimport('./index.js');\n"],"file":"assets/main.D0KZAQpb.js"}

package/dist/assets/reactor-analytics-BioFquA0.js

@@ -0,0 +1,605 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx } from "react/jsx-runtime";
+import { a3 as AnalyticsGranularity, a4 as DateTime, a5 as Interval, a6 as AnalyticsPath, a7 as CompoundOperator, a8 as QueryClient, a9 as QueryClientProvider, aa as useUnwrappedAnalyticsStore } from "./app-CayLrjAy.js";
+import { P as PassthroughAnalyticsProfiler } from "./AnalyticsProfiler-DD1sT8NE.js";
+import { createContext } from "react";
+import "./main.D0KZAQpb.js";
+import "./app-loader-Ej0QwX6c.js";
+import "react-dom";
+const getPeriodSeriesArray = (range) => {
+  const result = [];
+  const series = getPeriodSeries(range);
+  let next = series.next();
+  while (next) {
+    result.push(next);
+    next = series.next();
+  }
+  return result;
+};
+const getPeriodSeries = (range) => {
+  return {
+    ...range,
+    next: _createFactoryFn(range)
+  };
+};
+const _createFactoryFn = (range) => {
+  let current = range.start;
+  return () => {
+    if (current == null) {
+      return null;
+    }
+    let result = null;
+    switch (range.granularity) {
+      case AnalyticsGranularity.Total:
+        result = _nextTotalPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.Annual:
+        result = _nextAnnualPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.SemiAnnual:
+        result = _nextSemiAnnualPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.Quarterly:
+        result = _nextQuarterlyPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.Monthly:
+        result = _nextMonthlyPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.Weekly:
+        result = _nextWeeklyPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.Daily:
+        result = _nextDailyPeriod(current, range.end);
+        break;
+      case AnalyticsGranularity.Hourly:
+        result = _nextHourlyPeriod(current, range.end);
+    }
+    if (result === null) {
+      current = null;
+    } else {
+      current = result.end.plus({ milliseconds: 1 });
+    }
+    return result;
+  };
+};
+const _nextTotalPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  return {
+    period: "total",
+    start: nextStart,
+    end: seriesEnd
+  };
+};
+const _nextAnnualPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  const inputUtc = nextStart.toUTC();
+  const oneYearLater = DateTime.utc(inputUtc.year, inputUtc.month, inputUtc.day).plus({ years: 1 });
+  return {
+    period: "annual",
+    start: nextStart,
+    end: oneYearLater
+  };
+};
+const _nextSemiAnnualPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  const midYear = DateTime.utc(nextStart.year, 7, 1);
+  const endYear = DateTime.utc(nextStart.year, 12, 31, 23, 59, 59, 999);
+  let endDate;
+  if (midYear > nextStart) {
+    endDate = midYear;
+  } else {
+    endDate = endYear;
+  }
+  if (endDate > seriesEnd) {
+    endDate = seriesEnd;
+  }
+  return {
+    period: "semiAnnual",
+    start: nextStart,
+    end: endDate
+  };
+};
+const _nextQuarterlyPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  let endDate;
+  const nextStartUtc = nextStart.toUTC();
+  const startMonth = nextStartUtc.month;
+  if (startMonth < 3) {
+    endDate = DateTime.utc(nextStartUtc.year, 4, 1);
+  } else if (startMonth < 6) {
+    endDate = DateTime.utc(nextStartUtc.year, 7, 1);
+  } else if (startMonth < 9) {
+    endDate = DateTime.utc(nextStartUtc.year, 10, 1);
+  } else {
+    endDate = DateTime.utc(nextStartUtc.year, 12, 31, 23, 59, 59, 999);
+  }
+  if (endDate > seriesEnd) {
+    endDate = seriesEnd;
+  }
+  return {
+    period: "quarterly",
+    start: nextStart,
+    end: endDate
+  };
+};
+const _nextMonthlyPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  const nextStartUtc = nextStart.toUTC();
+  let endDate = DateTime.utc(nextStartUtc.year, nextStartUtc.month, nextStartUtc.day).plus({ months: 1 }).startOf("month");
+  if (endDate > seriesEnd) {
+    if (!nextStart.hasSame(seriesEnd, "month")) {
+      endDate = seriesEnd;
+    }
+  }
+  return {
+    period: "monthly",
+    start: nextStart,
+    end: endDate
+  };
+};
+const _nextWeeklyPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  const nextStartUtc = nextStart.toUTC();
+  const nextWeekStartUTC = DateTime.utc(nextStartUtc.year, nextStartUtc.month, nextStartUtc.day).plus({ weeks: 1 }).startOf("week");
+  if (nextWeekStartUTC > seriesEnd) {
+    if (!nextWeekStartUTC.hasSame(seriesEnd, "day")) {
+      return {
+        period: "weekly",
+        start: nextStart,
+        end: seriesEnd
+      };
+    }
+  }
+  return {
+    period: "weekly",
+    start: nextStart,
+    end: nextWeekStartUTC
+  };
+};
+const _nextDailyPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  const nextStartUtc = nextStart.toUTC();
+  let endDate = nextStartUtc.plus({ days: 1 }).startOf("day");
+  if (endDate > seriesEnd || endDate.hasSame(seriesEnd, "day")) {
+    endDate = seriesEnd;
+  }
+  return {
+    period: "daily",
+    start: nextStart,
+    end: endDate
+  };
+};
+const _nextHourlyPeriod = (nextStart, seriesEnd) => {
+  if (seriesEnd <= nextStart) {
+    return null;
+  }
+  const startDate = nextStart.toUTC();
+  let endDate = startDate.plus({ hours: 1 });
+  if (endDate > seriesEnd) {
+    if (nextStart.hour !== seriesEnd.hour) {
+      endDate = seriesEnd.toUTC();
+    }
+  }
+  return {
+    period: "hourly",
+    start: nextStart,
+    end: endDate
+  };
+};
+const getQuarter = (date) => {
+  return Math.floor((date.month - 1) / 3) + 1;
+};
+class AnalyticsDiscretizer {
+  static discretize(series, dimensions, start, end, granularity) {
+    const index = this._buildIndex(series, dimensions);
+    const periods = getPeriodSeriesArray(this._calculateRange(start, end, granularity, series));
+    const disretizedResults = this._discretizeNode(index, {}, dimensions, periods);
+    const groupedResults = this._groupResultsByPeriod(periods, disretizedResults);
+    return groupedResults;
+  }
+  static _calculateRange(start, end, granularity, results) {
+    let calculatedStart = start || null;
+    let calculatedEnd = end || null;
+    if (calculatedStart == null || calculatedEnd == null) {
+      for (const r of results) {
+        if (calculatedStart == null) {
+          calculatedStart = r.start;
+        }
+        const endValue = r.end || r.start;
+        if (calculatedEnd == null || calculatedEnd < endValue) {
+          calculatedEnd = endValue;
+        }
+      }
+    }
+    if (calculatedStart == null || calculatedEnd == null) {
+      throw new Error("Cannot determine query start and/or end.");
+    }
+    return {
+      start: calculatedStart,
+      end: calculatedEnd,
+      granularity
+    };
+  }
+  static _groupResultsByPeriod(periods, dimensionedResults) {
+    const result = {};
+    for (const p of periods) {
+      const id = p.start.toISO() + "-" + p.period;
+      const period = AnalyticsDiscretizer._getPeriodString(p);
+      result[id] = {
+        period,
+        start: p.start,
+        end: p.end,
+        rows: []
+      };
+    }
+    for (const r of dimensionedResults) {
+      for (const period of Object.keys(r.series)) {
+        result[period].rows.push({
+          dimensions: r.dimensions,
+          metric: r.metric,
+          unit: r.unit == "__NULL__" ? null : r.unit,
+          value: r.series[period].inc,
+          sum: r.series[period].sum
+        });
+      }
+    }
+    return Object.values(result);
+  }
+  static _getPeriodString(p) {
+    switch (p.period) {
+      case "annual":
+        return p.start.year.toString();
+      case "semiAnnual":
+        return `${p.start.year}/${p.start.month < 7 ? "H1" : "H2"}`;
+      case "quarterly":
+        return `${p.start.year}/Q${getQuarter(p.start)}`;
+      case "monthly":
+        const month = p.start.toUTC().month;
+        const formattedMonth = month < 10 ? `0${month}` : `${month}`;
+        return `${p.start.year}/${formattedMonth}`;
+      case "weekly":
+        return `${p.start.weekYear}/W${p.start.weekNumber}`;
+      case "daily":
+        const monthD = p.start.month;
+        const day = p.start.day;
+        const formattedMonthD = monthD < 10 ? `0${monthD}` : `${monthD}`;
+        const formattedDay = day < 10 ? `0${day}` : `${day}`;
+        return `${p.start.year}/${formattedMonthD}/${formattedDay}`;
+      case "hourly":
+        const monthH = p.start.month;
+        const dayH = p.start.day;
+        const hourH = p.start.hour;
+        const formattedMonthH = monthH < 10 ? `0${monthH}` : `${monthH}`;
+        const formattedDayH = dayH < 10 ? `0${dayH}` : `${dayH}`;
+        const formattedHourH = hourH < 10 ? `0${hourH}` : `${hourH}`;
+        return `${p.start.year}/${formattedMonthH}/${formattedDayH}/${formattedHourH}`;
+      default:
+        return p.period;
+    }
+  }
+  static _discretizeNode(node, dimensionValues, remainingDimensions, periods) {
+    const result = [];
+    if (remainingDimensions.length > 0) {
+      const subdimension = remainingDimensions[0];
+      Object.keys(node).forEach((subdimensionValue, index, arr) => {
+        const newDimensionValues = { ...dimensionValues };
+        newDimensionValues[subdimension] = subdimensionValue;
+        result.push(...this._discretizeNode(node[subdimensionValue], newDimensionValues, remainingDimensions.slice(1), periods));
+      });
+    } else {
+      Object.keys(node).forEach((metric) => {
+        result.push(...this._discretizeLeaf(node[metric], periods, metric, dimensionValues));
+      });
+    }
+    return result;
+  }
+  static _discretizeLeaf(leaf, periods, metric, dimensionValues) {
+    const result = [];
+    Object.keys(leaf).forEach((unit) => {
+      const metaDimensions = {};
+      Object.keys(dimensionValues).forEach((k) => {
+        metaDimensions[k] = {
+          path: leaf[unit][0].dimensions[k],
+          icon: leaf[unit][0].dimensions.icon,
+          label: leaf[unit][0].dimensions.label,
+          description: leaf[unit][0].dimensions.description
+        };
+      });
+      result.push({
+        unit,
+        metric,
+        dimensions: metaDimensions,
+        series: this._discretizeSeries(leaf[unit], periods)
+      });
+    });
+    return result;
+  }
+  static _discretizeSeries(series, periods) {
+    const result = {};
+    for (const s of series) {
+      let oldSum = this._getValue(s, periods[0].start);
+      for (const p of periods) {
+        const newSum = this._getValue(s, p.end);
+        const id = `${p.start.toISO()}-${p.period}`;
+        if (result[id]) {
+          result[id].inc += newSum - oldSum;
+          result[id].sum += newSum;
+        } else {
+          result[id] = {
+            inc: newSum - oldSum,
+            sum: newSum
+          };
+        }
+        oldSum = newSum;
+      }
+    }
+    return result;
+  }
+  static _getValue(series, when) {
+    switch (series.fn) {
+      case "Single":
+        return this._getSingleValue(series, when);
+      case "DssVest":
+        return this._getVestValue(series, when);
+      default:
+        return 0;
+    }
+  }
+  static _getSingleValue(series, when) {
+    return when >= series.start ? series.value : 0;
+  }
+  static _getVestValue(series, when) {
+    var _a;
+    const now = when;
+    const start = series.start;
+    const end = series.end;
+    const cliff = ((_a = series.params) == null ? void 0 : _a.cliff) ? DateTime.fromISO(series.params.cliff) : null;
+    if (now < start || cliff && now < cliff) {
+      return 0;
+    } else if (end && now >= end) {
+      return series.value;
+    }
+    const a = Interval.fromDateTimes(start, now);
+    const b = Interval.fromDateTimes(start, end || now);
+    return a.length() / b.length() * series.value;
+  }
+  static _buildIndex(series, dimensions) {
+    const result = {};
+    const map = {};
+    const dimName = dimensions[0] || "";
+    for (const s of series) {
+      const dimValue = s.dimensions[dimName];
+      if (void 0 === map[dimValue]) {
+        map[dimValue] = [];
+      }
+      map[dimValue].push(s);
+    }
+    if (dimensions.length > 1) {
+      const newDimensions = dimensions.slice(1);
+      Object.keys(map).forEach((k) => {
+        result[k] = this._buildIndex(map[k], newDimensions);
+      });
+    } else {
+      Object.keys(map).forEach((k) => {
+        result[k] = this._buildMetricsIndex(map[k]);
+      });
+    }
+    return result;
+  }
+  static _buildMetricsIndex(series) {
+    const result = {};
+    const map = {};
+    for (const s of series) {
+      const metric = s.metric;
+      if (void 0 === map[metric]) {
+        map[metric] = [];
+      }
+      map[metric].push(s);
+    }
+    Object.keys(map).forEach((k) => result[k] = this._buildUnitIndex(map[k]));
+    return result;
+  }
+  static _buildUnitIndex(series) {
+    const result = {};
+    for (const s of series) {
+      const unit = s.unit || "__NULL__";
+      if (void 0 === result[unit]) {
+        result[unit] = [];
+      }
+      result[unit].push(s);
+    }
+    return result;
+  }
+}
+class AnalyticsQueryEngine {
+  constructor(_analyticsStore, profiler) {
+    __publicField(this, "_analyticsStore");
+    __publicField(this, "_profiler");
+    this._analyticsStore = _analyticsStore;
+    this._profiler = profiler ?? new PassthroughAnalyticsProfiler();
+  }
+  async executeCompound(query) {
+    let result;
+    const inputsQuery = {
+      start: query.start,
+      end: query.end,
+      granularity: query.granularity,
+      lod: query.lod,
+      select: query.select,
+      metrics: query.expression.inputs.metrics,
+      currency: query.expression.inputs.currency
+    };
+    const operandQuery = {
+      start: query.start,
+      end: query.end,
+      granularity: query.granularity,
+      lod: { priceData: 1 },
+      select: { priceData: [AnalyticsPath.fromString("atlas")] },
+      metrics: [query.expression.operand.metric],
+      currency: query.expression.operand.currency
+    };
+    const inputExecute = await this.execute(inputsQuery);
+    const operandExecute = await this.execute(operandQuery);
+    if ([CompoundOperator.VectorAdd, CompoundOperator.VectorSubtract].includes(query.expression.operator)) {
+      result = await this._profiler.record("ApplyVectorOperator", async () => await this._applyVectorOperator(inputExecute, operandExecute, query.expression.operator, query.expression.resultCurrency));
+    } else {
+      result = await this._profiler.record("ApplyScalarOperator", async () => await this._applyScalarOperator(inputExecute, operandExecute, query.expression.operator, query.expression.operand.useSum, query.expression.resultCurrency));
+    }
+    return result;
+  }
+  async execute(query) {
+    const seriesResults = await this._executeSeriesQuery(query);
+    const normalizedSeriesResults = this._profiler.recordSync("ApplyLODs", () => this._applyLods(seriesResults, query.lod));
+    const dimensions = Object.keys(query.select);
+    const discretizedResult = this._profiler.recordSync("Discretize", () => normalizedSeriesResults.length < 1 ? [] : AnalyticsDiscretizer.discretize(normalizedSeriesResults, dimensions, query.start, query.end, query.granularity));
+    return discretizedResult;
+  }
+  async executeMultiCurrency(query, mcc) {
+    const baseQuery = {
+      ...query,
+      currency: mcc.targetCurrency
+    };
+    let result = await this.execute(baseQuery);
+    for (const conversion of mcc.conversions) {
+      const nextQuery = {
+        start: query.start,
+        end: query.end,
+        granularity: query.granularity,
+        lod: query.lod,
+        select: query.select,
+        expression: {
+          inputs: {
+            metrics: baseQuery.metrics,
+            currency: conversion.currency
+          },
+          operator: CompoundOperator.ScalarMultiply,
+          operand: {
+            metric: conversion.metric,
+            currency: mcc.targetCurrency,
+            useSum: true
+          },
+          resultCurrency: mcc.targetCurrency
+        }
+      };
+      const executedCompound = await this.executeCompound(nextQuery);
+      result = await this._applyVectorOperator(result, executedCompound, CompoundOperator.VectorAdd, mcc.targetCurrency);
+    }
+    return result;
+  }
+  async _applyVectorOperator(inputsA, inputsB, operator, resultCurrency) {
+    if ([CompoundOperator.ScalarMultiply, CompoundOperator.ScalarDivide].includes(operator)) {
+      throw new Error("Invalid operator for vector operation");
+    }
+    return inputsB;
+  }
+  async _applyScalarOperator(inputs, operand, operator, useOperandSum, resultCurrency) {
+    if ([CompoundOperator.VectorAdd, CompoundOperator.VectorSubtract].includes(operator)) {
+      throw new Error("Invalid operator for scalar operation");
+    }
+    const result = [];
+    const operandMap = {};
+    const key = useOperandSum ? "sum" : "value";
+    for (const operandPeriod of operand) {
+      if (operandPeriod.rows.length > 0) {
+        operandMap[operandPeriod.period] = operandPeriod.rows[0][key];
+      }
+    }
+    for (const inputPeriod of inputs) {
+      const outputPeriod = {
+        period: inputPeriod.period,
+        start: inputPeriod.start,
+        end: inputPeriod.end,
+        rows: inputPeriod.rows.map((row) => {
+          const newRow = {
+            dimensions: row.dimensions,
+            metric: row.metric,
+            unit: resultCurrency.toString(),
+            value: this._calculateOutputValue(row.value, operator, operandMap[inputPeriod.period]),
+            sum: -1
+          };
+          return newRow;
+        })
+      };
+      result.push(outputPeriod);
+    }
+    return result;
+  }
+  _calculateOutputValue(input, operator, operand) {
+    switch (operator) {
+      case CompoundOperator.VectorAdd:
+        return input + operand;
+      case CompoundOperator.VectorSubtract:
+        return input - operand;
+      case CompoundOperator.ScalarMultiply:
+        return input * operand;
+      case CompoundOperator.ScalarDivide:
+        return input / operand;
+    }
+  }
+  async _executeSeriesQuery(query) {
+    const seriesQuery = {
+      start: query.start,
+      end: query.end,
+      currency: query.currency,
+      select: query.select,
+      metrics: query.metrics
+    };
+    return await this._analyticsStore.getMatchingSeries(seriesQuery);
+  }
+  _applyLods(series, lods) {
+    return series.map((result) => ({
+      ...result,
+      dimensions: this._applyDimensionsLods(result.dimensions, lods)
+    }));
+  }
+  _applyDimensionsLods(dimensionMap, lods) {
+    const result = {};
+    for (const [dimension, lod] of Object.entries(lods)) {
+      if (lod !== null && dimensionMap[dimension]) {
+        result[dimension] = dimensionMap[dimension]["path"].applyLod(lod).toString();
+        result["icon"] = dimensionMap[dimension]["icon"].toString();
+        result["label"] = dimensionMap[dimension]["label"].toString();
+        result["description"] = dimensionMap[dimension]["description"].toString();
+      }
+    }
+    return result;
+  }
+  async getDimensions() {
+    return await this._analyticsStore.getDimensions();
+  }
+}
+const AnalyticsContext = createContext(null);
+const defaultQueryClient = new QueryClient();
+function AnalyticsProvider({ children, store, queryClient = defaultQueryClient }) {
+  const engine = new AnalyticsQueryEngine(store);
+  const content = jsx(AnalyticsContext.Provider, { value: { store, engine }, children });
+  if (queryClient === false) {
+    return content;
+  }
+  return jsx(QueryClientProvider, { client: queryClient, children: content });
+}
+function ReactorAnalyticsProvider({ children }) {
+  const store = useUnwrappedAnalyticsStore();
+  return store ? /* @__PURE__ */ jsx(AnalyticsProvider, { store, children }) : children;
+}
+export {
+  ReactorAnalyticsProvider,
+  ReactorAnalyticsProvider as default
+};
+//# sourceMappingURL=reactor-analytics-BioFquA0.js.map