@quillsql/react 2.16.20 → 2.16.22

package/dist/index.js

@@ -277,6 +277,9 @@ var init_valueFormatter = __esm({
       maximumFractionDigits: 2
     });
     formatPercent = (value) => {
+      if (typeof value === "string" && /^\s*[+-]?(?:\d+(?:\.\d+)?|\.\d+)\s*%\s*$/.test(value)) {
+        return value;
+      }
       return formatterPercent.format(Number(value));
     };
     _getUTCDateHelper = (value, fmt) => {
@@ -1572,6 +1575,7 @@ var init_dateRangePickerUtils = __esm({
         }
       });
       const defaultCustomIntervals = defaultIntervals.flatMap((interval2) => {
+        const normalizedLabel = interval2.label?.toLowerCase().trim();
         let createdIntervals = [];
         if (interval2.label === "This week") {
           createdIntervals = [
@@ -1721,13 +1725,13 @@ var init_dateRangePickerUtils = __esm({
               unit: "months"
             }
           ];
-        } else if (interval2.label === "Last month") {
+        } else if (normalizedLabel === "last month") {
           createdIntervals = [
             {
               type: "previous_month"
             }
           ];
-        } else if (interval2.label === "Last quarter") {
+        } else if (normalizedLabel === "previous quarter" || normalizedLabel === "last quarter") {
           createdIntervals = [
             {
               type: "previous_quarter"
@@ -2121,13 +2125,13 @@ var init_Filter = __esm({
       TimeUnit2[TimeUnit2["Hour"] = HOUR] = "Hour";
       return TimeUnit2;
     })(TimeUnit || {});
-    FieldType = /* @__PURE__ */ ((FieldType2) => {
-      FieldType2[FieldType2["String"] = STRING] = "String";
-      FieldType2[FieldType2["Number"] = NUMBER] = "Number";
-      FieldType2[FieldType2["Date"] = DATE] = "Date";
-      FieldType2[FieldType2["Null"] = NULL] = "Null";
-      FieldType2[FieldType2["Boolean"] = BOOLEAN] = "Boolean";
-      return FieldType2;
+    FieldType = /* @__PURE__ */ ((FieldType3) => {
+      FieldType3[FieldType3["String"] = STRING] = "String";
+      FieldType3[FieldType3["Number"] = NUMBER] = "Number";
+      FieldType3[FieldType3["Date"] = DATE] = "Date";
+      FieldType3[FieldType3["Null"] = NULL] = "Null";
+      FieldType3[FieldType3["Boolean"] = BOOLEAN] = "Boolean";
+      return FieldType3;
     })(FieldType || {});
     InternalFilterType = /* @__PURE__ */ ((InternalFilterType2) => {
       InternalFilterType2["StringFilter"] = "string-filter";
@@ -2273,7 +2277,7 @@ var init_Filter = __esm({
           fieldType = FieldType.Boolean;
           operator = filter.operator;
           field = filter.field;
-          value = null;
+          value = filter.value;
           table = filter.table;
           return {
             filterType,
@@ -2284,7 +2288,7 @@ var init_Filter = __esm({
             operator
           };
         case "date" /* Date */:
-          if (typeof filter.value === "object" && filter.value && "value" in filter.value && filter.value.unit) {
+          if (typeof filter.value === "object" && filter.value && "unit" in filter.value) {
             if (filter.value.value && typeof filter.value.value !== "number" || typeof filter.value.unit !== "string") {
               throw new Error(
                 `Invalid value for DateFilter, expected { value: number, unit: string }, got ${filter.value}`
@@ -2340,7 +2344,7 @@ var init_Filter = __esm({
             table = filter.table;
           } else {
             throw new Error(
-              `Invalid value for DateFilter, expected { value: number, unit: string }, { startDate: string, endDate: string}, or string, got ${filter.value}`
+              `Invalid value for DateFilter, expected { value?: number, unit: string }, { startDate: string, endDate: string}, or string, got ${filter.value}`
             );
           }
           return {
@@ -15951,7 +15955,7 @@ var init_dataProcessing = __esm({
       } else {
         if (data.dateField && data.dateField.field) {
           const dateField = data.dateField.field.replaceAll('"', "");
-          const maxDate = new Date(
+          const maxDate2 = new Date(
             data.rows.reduce((acc, row) => {
               const rowValue = row[dateField];
               if (rowValue) {
@@ -15960,7 +15964,7 @@ var init_dataProcessing = __esm({
               return Math.max(acc, 0);
             }, 0)
           );
-          const minDate = new Date(
+          const minDate2 = new Date(
             data.rows.reduce((acc, row) => {
               const rowValue = row[dateField];
               if (rowValue) {
@@ -15970,16 +15974,16 @@ var init_dataProcessing = __esm({
             }, (/* @__PURE__ */ new Date("3022-01-01")).getTime())
           );
           const dateBucket = getDateBucketFromRange({
-            start: minDate,
-            end: maxDate
+            start: minDate2,
+            end: maxDate2
           });
           const minDateBucket = getDateString(
-            minDate.toISOString(),
+            minDate2.toISOString(),
             void 0,
             dateBucket
           );
           const maxDateBucket = getDateString(
-            maxDate.toISOString(),
+            maxDate2.toISOString(),
             void 0,
             dateBucket
           );
@@ -16096,8 +16100,9 @@ async function generatePivotWithSQL({
   getPivotRowCount = true,
   caller,
   getToken,
-  reportBuilderState
+  reportBuilderState,
   // Add reportBuilderState parameter
+  overwriteCache = false
 }) {
   const databaseType = client.databaseType || "postgresql";
   if (!pivot.aggregations?.length && pivot.aggregationType) {
@@ -16146,7 +16151,8 @@ async function generatePivotWithSQL({
       })),
       // Only pass dashboard filters in Dashboard context, not ReportBuilder
       tenants,
-      additionalProcessing
+      additionalProcessing,
+      overwriteCache
     },
     getToken
   });
@@ -16320,8 +16326,9 @@ async function generatePivotTable({
   additionalProcessing,
   caller,
   pivotQuery,
-  reportBuilderState
+  reportBuilderState,
   // Add reportBuilderState parameter
+  overwriteCache
 }) {
   try {
     if (report && client) {
@@ -16338,8 +16345,9 @@ async function generatePivotTable({
         additionalProcessing,
         caller,
         getToken,
-        reportBuilderState
+        reportBuilderState,
         // Pass reportBuilderState
+        overwriteCache
       });
       return pivotTable;
     }
@@ -18224,7 +18232,7 @@ var init_tableProcessing = __esm({
       try {
         let data;
         if (reportBuilderState) {
-          let { data: data2 } = await quillFetch({
+          ({ data } = await quillFetch({
             client,
             task: "report-builder-counts",
             metadata: {
@@ -18238,9 +18246,9 @@ var init_tableProcessing = __esm({
               tenants
             },
             getToken
-          });
+          }));
         } else {
-          let { data: data2 } = await quillFetch({
+          ({ data } = await quillFetch({
             client,
             task: "query",
             metadata: {
@@ -18254,7 +18262,7 @@ var init_tableProcessing = __esm({
             },
             urlParameters: `caller=getCounts&task=query`,
             getToken
-          });
+          }));
         }
         if (data.errorMessage) {
           return { filteredColumns: columns, exceededColumns: void 0 };
@@ -19244,9 +19252,9 @@ var init_dataFetcher = __esm({
         return { error: "Failed to fetch data" };
       }
     };
-    parseFetchResponse = async (client, task, response, getToken) => {
+    parseFetchResponse = async (client, task, response, getToken, useInMemory = false) => {
       try {
-        if (response.status === "error" || response.data?.error) {
+        if (response.status === "error" || response.data?.error && !useInMemory) {
           let errorPrefix = "Error: ";
           let errorMessage = "Failed to fetch report: " + (response.error || response.data?.error);
           if (task === "query" || task === "report-builder") {
@@ -19831,7 +19839,8 @@ async function cleanDashboardItem({
   additionalProcessing,
   customFields,
   skipPivotFetch,
-  tenants
+  tenants,
+  overwriteCache
 }) {
   if (!item) return defaultDashboardItem;
   if (!item.rows) {
@@ -19887,11 +19896,12 @@ async function cleanDashboardItem({
       page: DEFAULT_PAGINATION
     };
     if (item.pivot && skipPivotFetch && item.rows && item.fields) {
+      const pivotSourceRows = item.rows.map((row) => ({ ...row }));
       const dateFilter = dashboardFilters?.find(
         (filter) => filter.filterType === "date_range"
       );
       pivotTable = processPivotData({
-        rows: item.rows,
+        rows: pivotSourceRows,
         fields: item.fields,
         pivot: {
           ...item.pivot,
@@ -19935,7 +19945,8 @@ async function cleanDashboardItem({
         dateBucket,
         shouldPaginatePivotAsTable ? additionalProcessing : pivotChartProcessing,
         tenants,
-        customFields
+        customFields,
+        overwriteCache
       );
     }
   } catch (e) {
@@ -20040,7 +20051,7 @@ async function cleanDashboardItem({
     referenceLines: item.referenceLines
   };
 }
-async function getPivotTable(report, dashboardFilters, dashboardName, getToken, client, eventTracking, dateBucketInitial, additionalProcessing, tenants, customFields) {
+async function getPivotTable(report, dashboardFilters, dashboardName, getToken, client, eventTracking, dateBucketInitial, additionalProcessing, tenants, customFields, overwriteCache) {
   if (!report) return void 0;
   const dateFilter = Object.values(dashboardFilters ?? {}).find(
     (filter) => filter.filterType === "date_range" || filter.operator === "BETWEEN"
@@ -20108,7 +20119,8 @@ async function getPivotTable(report, dashboardFilters, dashboardName, getToken,
         dashboardFilters,
         tenants,
         additionalProcessing,
-        getToken
+        getToken,
+        overwriteCache
       });
       return pivotTable;
     } catch (e) {
@@ -20356,7 +20368,8 @@ async function fetchReportRows({
   filters = [],
   getToken,
   abortSignal,
-  additionalProcessing
+  additionalProcessing,
+  overwriteCache = false
 }) {
   const fetchResp = await quillFetch({
     client,
@@ -20368,7 +20381,8 @@ async function fetchReportRows({
       filters: filters.map((filter) => ({ ...filter, options: void 0 })),
       useNewNodeSql: true,
       tenants,
-      additionalProcessing
+      additionalProcessing,
+      overwriteCache
     },
     abortSignal,
     getToken
@@ -20399,7 +20413,8 @@ async function fetchReport({
   abortSignal,
   getToken,
   eventTracking,
-  usePivotTask = false
+  usePivotTask = false,
+  overwriteCache = false
 }) {
   let reportInfo = void 0;
   let errorMessage = void 0;
@@ -20419,7 +20434,8 @@ async function fetchReport({
         rowsOnly,
         rowCountOnly,
         tenants,
-        flags
+        flags,
+        overwriteCache
       },
       abortSignal,
       getToken
@@ -20440,7 +20456,9 @@ async function fetchReport({
       getToken,
       eventTracking,
       tenants,
-      skipPivotFetch: usePivotTask
+      // When not using pivot-template, avoid fallback pivot-template fetches.
+      skipPivotFetch: !usePivotTask,
+      overwriteCache
     });
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
@@ -20490,7 +20508,8 @@ async function processReportResponse({
   getToken,
   eventTracking,
   tenants,
-  skipPivotFetch = false
+  skipPivotFetch = false,
+  overwriteCache
 }) {
   const shouldSkipPivotFetch = skipPivotFetch || !!resp?.pivotRows && !!resp?.fields;
   const dashboardItem = {
@@ -20523,7 +20542,8 @@ async function processReportResponse({
     getToken,
     tenants,
     eventTracking,
-    skipPivotFetch: shouldSkipPivotFetch
+    skipPivotFetch: shouldSkipPivotFetch,
+    overwriteCache
   });
   if (additionalProcessing) {
     reportInfo.pagination = additionalProcessing.page;
@@ -21600,6 +21620,1952 @@ async function getClientTenantIds({
 
 // src/Context.tsx
 init_columnProcessing();
+
+// src/utils/cacheCab.ts
+init_dataFetcher();
+
+// src/utils/inMemoryFilterEngine.ts
+init_Filter();
+init_dateRangePickerUtils();
+import {
+  addHours,
+  addMonths,
+  addWeeks,
+  addYears,
+  addDays as addDays2,
+  isValid as isValid4,
+  startOfDay as startOfDay3,
+  startOfHour,
+  startOfMonth as startOfMonth2,
+  startOfQuarter as startOfQuarter2,
+  startOfWeek as startOfWeek3,
+  startOfYear,
+  subDays as subDays2,
+  subHours as subHours2,
+  subMonths as subMonths3,
+  subWeeks as subWeeks2,
+  subYears as subYears2
+} from "date-fns";
+var UNSET = Symbol("unset");
+var isFilter = (f) => {
+  return f && typeof f === "object" && "filterType" in f && !("id" in f);
+};
+var isDashboardFilterUpdate = (f) => {
+  return f && typeof f === "object" && "label" in f;
+};
+var normalizeFilterString = (value) => value.replaceAll("%", "").toLowerCase();
+var normalizeRowString = (value) => value.toLowerCase();
+var resolveFieldKeys = (field, table, resolver) => {
+  if (!field) return [];
+  const resolved = resolver?.(field, table);
+  if (Array.isArray(resolved)) return resolved;
+  if (typeof resolved === "string") return [resolved];
+  return [field];
+};
+var getRowValue = (row, fieldKeys, cache) => {
+  if (fieldKeys.length === 0) return void 0;
+  const cacheKey = fieldKeys.join("|");
+  if (Object.prototype.hasOwnProperty.call(cache, cacheKey)) {
+    return cache[cacheKey];
+  }
+  for (const key of fieldKeys) {
+    if (Object.prototype.hasOwnProperty.call(row, key)) {
+      cache[cacheKey] = row[key];
+      return row[key];
+    }
+  }
+  cache[cacheKey] = void 0;
+  return void 0;
+};
+var coerceNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var coerceBoolean = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.toLowerCase();
+    if (normalized === "true" || normalized === "1") return true;
+    if (normalized === "false" || normalized === "0") return false;
+  }
+  return null;
+};
+var toDateMs = (value) => {
+  if (value instanceof Date) {
+    return isValid4(value) ? value.getTime() : null;
+  }
+  if (typeof value === "number") {
+    const date = new Date(value);
+    return isValid4(date) ? date.getTime() : null;
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return isValid4(date) ? date.getTime() : null;
+  }
+  return null;
+};
+var buildColumnTypeMap = (columns) => {
+  if (!columns?.length) return null;
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const column of columns) {
+    map[column.field] = column.jsType;
+  }
+  return map;
+};
+var resolveDashboardField = (filter, options) => {
+  const mapped = options.filterMap?.[filter.label];
+  if (mapped?.field) {
+    return { field: mapped.field, table: mapped.table };
+  }
+  if (filter.filterType === "date_range" /* Date */ && options.dateField?.field) {
+    return { field: options.dateField.field, table: options.dateField.table };
+  }
+  if (filter.field) {
+    return { field: filter.field, table: filter.table };
+  }
+  return null;
+};
+var buildRelativeDateRange = (operator, value, now2, weekStartsOn) => {
+  const amount = value.value || 1;
+  const unit = value.unit;
+  const currentStart = (() => {
+    switch (unit) {
+      case TimeUnit.Hour:
+        return startOfHour(now2);
+      case TimeUnit.Day:
+        return startOfDay3(now2);
+      case TimeUnit.Week:
+        return startOfWeek3(now2, { weekStartsOn });
+      case TimeUnit.Month:
+        return startOfMonth2(now2);
+      case TimeUnit.Quarter:
+        return startOfQuarter2(now2);
+      case TimeUnit.Year:
+        return startOfYear(now2);
+      default:
+        return startOfDay3(now2);
+    }
+  })();
+  const addUnit = (base, multiplier) => {
+    switch (unit) {
+      case TimeUnit.Hour:
+        return addHours(base, multiplier);
+      case TimeUnit.Day:
+        return addDays2(base, multiplier);
+      case TimeUnit.Week:
+        return addWeeks(base, multiplier);
+      case TimeUnit.Month:
+        return addMonths(base, multiplier);
+      case TimeUnit.Quarter:
+        return addMonths(base, multiplier * 3);
+      case TimeUnit.Year:
+        return addYears(base, multiplier);
+      default:
+        return addDays2(base, multiplier);
+    }
+  };
+  const subUnit = (base, multiplier) => {
+    switch (unit) {
+      case TimeUnit.Hour:
+        return subHours2(base, multiplier);
+      case TimeUnit.Day:
+        return subDays2(base, multiplier);
+      case TimeUnit.Week:
+        return subWeeks2(base, multiplier);
+      case TimeUnit.Month:
+        return subMonths3(base, multiplier);
+      case TimeUnit.Quarter:
+        return subMonths3(base, multiplier * 3);
+      case TimeUnit.Year:
+        return subYears2(base, multiplier);
+      default:
+        return subDays2(base, multiplier);
+    }
+  };
+  switch (operator) {
+    case DateOperator.InTheLast: {
+      const start2 = subUnit(now2, amount);
+      return { start: start2.getTime() };
+    }
+    case DateOperator.InThePrevious: {
+      const start2 = subUnit(currentStart, amount);
+      return { start: start2.getTime(), end: currentStart.getTime(), endExclusive: true };
+    }
+    case DateOperator.InTheCurrent: {
+      const end = addUnit(currentStart, 1);
+      return {
+        start: currentStart.getTime(),
+        end: end.getTime(),
+        endExclusive: true
+      };
+    }
+    default:
+      return null;
+  }
+};
+var buildStringPredicate = (operator, value, fieldKeys) => {
+  if (value === void 0 || value === null) return null;
+  const normalizedValue = Array.isArray(value) ? value.map((v) => normalizeFilterString(String(v))) : normalizeFilterString(String(value));
+  if (Array.isArray(normalizedValue)) {
+    if (normalizedValue.length === 0) return null;
+  } else if (normalizedValue === "") {
+    return null;
+  }
+  if (operator === StringOperator.Is || operator === StringOperator.IsNot) {
+    const values = Array.isArray(normalizedValue) ? normalizedValue : [normalizedValue];
+    const valueSet = new Set(values);
+    return (row, cache) => {
+      const rowValue = getRowValue(row, fieldKeys, cache);
+      if (rowValue === null || rowValue === void 0) return false;
+      const normalized = normalizeRowString(String(rowValue));
+      const hasValue = valueSet.has(normalized);
+      return operator === StringOperator.Is ? hasValue : !hasValue;
+    };
+  }
+  if (Array.isArray(normalizedValue)) {
+    return null;
+  }
+  return (row, cache) => {
+    const rowValue = getRowValue(row, fieldKeys, cache);
+    if (rowValue === null || rowValue === void 0) return false;
+    const normalizedRow = normalizeRowString(String(rowValue));
+    switch (operator) {
+      case StringOperator.IsExactly:
+        return normalizedRow === normalizedValue;
+      case StringOperator.IsNotExactly:
+        return normalizedRow !== normalizedValue;
+      case StringOperator.Contains:
+        return normalizedRow.includes(normalizedValue);
+      default:
+        return false;
+    }
+  };
+};
+var buildNumericPredicate = (operator, value, fieldKeys) => {
+  const filterValue = coerceNumber(value);
+  if (filterValue === null) return null;
+  return (row, cache) => {
+    const rowValue = getRowValue(row, fieldKeys, cache);
+    const parsed = coerceNumber(rowValue);
+    if (parsed === null) return false;
+    switch (operator) {
+      case NumberOperator.EqualTo:
+        return parsed === filterValue;
+      case NumberOperator.NotEqualTo:
+        return parsed !== filterValue;
+      case NumberOperator.GreaterThan:
+        return parsed > filterValue;
+      case NumberOperator.LessThan:
+        return parsed < filterValue;
+      case NumberOperator.GreaterThanOrEqualTo:
+        return parsed >= filterValue;
+      case NumberOperator.LessThanOrEqualTo:
+        return parsed <= filterValue;
+      default:
+        return false;
+    }
+  };
+};
+var buildNullPredicate = (operator, fieldKeys) => {
+  return (row, cache) => {
+    const rowValue = getRowValue(row, fieldKeys, cache);
+    const isNullish = rowValue === null || rowValue === void 0;
+    return operator === NullOperator.IsNull ? isNullish : !isNullish;
+  };
+};
+var buildBooleanPredicate = (operator, value, fieldKeys) => {
+  const filterValue = coerceBoolean(value);
+  if (filterValue === null) return null;
+  return (row, cache) => {
+    const rowValue = getRowValue(row, fieldKeys, cache);
+    const parsed = coerceBoolean(rowValue);
+    if (parsed === null) return false;
+    return operator === BoolOperator.EqualTo ? parsed === filterValue : parsed !== filterValue;
+  };
+};
+var buildDateComparisonPredicate = (operator, value, fieldKeys) => {
+  const filterDate = toDateMs(value);
+  if (filterDate === null) return null;
+  return (row, cache) => {
+    const rowValue = getRowValue(row, fieldKeys, cache);
+    const rowDate = toDateMs(rowValue);
+    if (rowDate === null) return false;
+    switch (operator) {
+      case DateOperator.EqualTo:
+        return rowDate === filterDate;
+      case DateOperator.NotEqualTo:
+        return rowDate !== filterDate;
+      case DateOperator.GreaterThan:
+        return rowDate > filterDate;
+      case DateOperator.LessThan:
+        return rowDate < filterDate;
+      case DateOperator.GreaterThanOrEqualTo:
+        return rowDate >= filterDate;
+      case DateOperator.LessThanOrEqualTo:
+        return rowDate <= filterDate;
+      default:
+        return false;
+    }
+  };
+};
+var buildDateRangePredicate = (range, fieldKeys) => {
+  if (range.start === void 0 && range.end === void 0) return null;
+  return (row, cache) => {
+    const rowValue = getRowValue(row, fieldKeys, cache);
+    const rowDate = toDateMs(rowValue);
+    if (rowDate === null) return false;
+    if (range.start !== void 0 && rowDate < range.start) return false;
+    if (range.end !== void 0) {
+      if (range.endExclusive) {
+        return rowDate < range.end;
+      }
+      return rowDate <= range.end;
+    }
+    return true;
+  };
+};
+var buildCustomDatePredicate = (value, fieldKeys) => {
+  const start2 = value.startDate ? toDateMs(value.startDate) : null;
+  const end = value.endDate ? toDateMs(value.endDate) : null;
+  if (start2 === null && end === null) return null;
+  return buildDateRangePredicate(
+    {
+      start: start2 ?? void 0,
+      end: end ?? void 0,
+      endExclusive: false
+    },
+    fieldKeys
+  );
+};
+var compileCustomFilter = (filter, options) => {
+  const fieldKeys = resolveFieldKeys(
+    filter.field,
+    filter.table,
+    options.fieldKeyResolver
+  );
+  if (fieldKeys.length === 0) return null;
+  switch (filter.filterType) {
+    case "string-filter" /* StringFilter */:
+    case "string-in-filter" /* StringInFilter */:
+      return buildStringPredicate(
+        filter.operator,
+        filter.value,
+        fieldKeys
+      );
+    case "numeric-filter" /* NumericFilter */:
+      return buildNumericPredicate(
+        filter.operator,
+        filter.value,
+        fieldKeys
+      );
+    case "null-filter" /* NullFilter */:
+      return buildNullPredicate(
+        filter.operator,
+        fieldKeys
+      );
+    case "boolean-filter" /* BooleanFilter */:
+      return buildBooleanPredicate(
+        filter.operator,
+        filter.value,
+        fieldKeys
+      );
+    case "date-custom-filter" /* DateCustomFilter */:
+      return buildCustomDatePredicate(
+        filter.value,
+        fieldKeys
+      );
+    case "date-comparison-filter" /* DateComparisonFilter */:
+      return buildDateComparisonPredicate(
+        filter.operator,
+        filter.value,
+        fieldKeys
+      );
+    case "date-filter" /* DateFilter */: {
+      const value = filter.value;
+      if (!value?.unit) return null;
+      const now2 = options.now ?? /* @__PURE__ */ new Date();
+      const range = buildRelativeDateRange(
+        filter.operator,
+        value,
+        now2,
+        options.weekStartsOn ?? 0
+      );
+      if (!range) return null;
+      return buildDateRangePredicate(range, fieldKeys);
+    }
+    default:
+      return null;
+  }
+};
+var compileDashboardFilter = (filter, options, columnTypeMap) => {
+  const resolved = resolveDashboardField(filter, options);
+  if (!resolved?.field) return null;
+  const fieldKeys = resolveFieldKeys(
+    resolved.field,
+    resolved.table,
+    options.fieldKeyResolver
+  );
+  if (fieldKeys.length === 0) return null;
+  switch (filter.filterType) {
+    case "string" /* String */: {
+      const stringFilter = filter;
+      if (stringFilter.stringFilterType === "multiselect" /* Multiselect */) {
+        if (!stringFilter.values || stringFilter.values.length === 0) {
+          return null;
+        }
+        return buildStringPredicate(
+          StringOperator.Is,
+          stringFilter.values,
+          fieldKeys
+        );
+      }
+      if (!stringFilter.selectedValue) return null;
+      return buildStringPredicate(
+        StringOperator.IsExactly,
+        stringFilter.selectedValue,
+        fieldKeys
+      );
+    }
+    case "date_range" /* Date */: {
+      const dateFilter = filter;
+      const start2 = dateFilter.startDate ? dateFilter.startDate.getTime() : void 0;
+      const end = dateFilter.endDate ? dateFilter.endDate.getTime() : void 0;
+      return buildDateRangePredicate(
+        { start: start2, end, endExclusive: false },
+        fieldKeys
+      );
+    }
+    case "tenant" /* Tenant */: {
+      const tenantFilter = filter;
+      if (!tenantFilter.values || tenantFilter.values.length === 0) {
+        return null;
+      }
+      const normalizedValues = tenantFilter.values.map(
+        (v) => normalizeFilterString(String(v))
+      );
+      const valueSet = new Set(normalizedValues);
+      const fieldType = columnTypeMap?.[resolved.field] ?? "string";
+      return (row, cache) => {
+        const rowValue = getRowValue(row, fieldKeys, cache);
+        if (rowValue === null || rowValue === void 0) return false;
+        if (fieldType === "number") {
+          const numeric = coerceNumber(rowValue);
+          return numeric !== null && valueSet.has(normalizeFilterString(String(numeric)));
+        }
+        return valueSet.has(normalizeRowString(String(rowValue)));
+      };
+    }
+    default:
+      return null;
+  }
+};
+var updateDashboardFilters = (filtersToUpdate, dashboardFilters) => {
+  return dashboardFilters.map((filter) => {
+    const update = filtersToUpdate.find((u) => u.label === filter.label);
+    if (!update) return filter;
+    if (filter.filterType === "string" /* String */) {
+      if (filter.stringFilterType === "multiselect" /* Multiselect */) {
+        return {
+          ...filter,
+          values: update.value
+        };
+      }
+      return {
+        ...filter,
+        selectedValue: update.value
+      };
+    }
+    if (filter.filterType === "date_range" /* Date */) {
+      const presetOptions = convertPresetOptionsToSelectableList(
+        filter.presetOptions ?? [],
+        filter.defaultPresetRanges ?? []
+      );
+      const value = update.value;
+      const preset = presetOptions.find((p) => {
+        const pStart = p.startDate ? new Date(p.startDate).toISOString() : void 0;
+        const vStart = value.startDate ? new Date(value.startDate).toISOString() : void 0;
+        const pEnd = p.endDate ? new Date(p.endDate).toISOString() : void 0;
+        const vEnd = value.endDate ? new Date(value.endDate).toISOString() : void 0;
+        return pStart === vStart && pEnd === vEnd;
+      });
+      if (!preset) {
+        return { ...filter, startDate: value.startDate, endDate: value.endDate };
+      }
+      return {
+        ...filter,
+        preset,
+        startDate: value.startDate,
+        endDate: value.endDate
+      };
+    }
+    if (filter.filterType === "tenant" /* Tenant */) {
+      const value = update.value;
+      let values;
+      if (Array.isArray(value)) {
+        values = value;
+      } else if (typeof value === "string") {
+        values = [value];
+      } else {
+        values = [];
+      }
+      return {
+        ...filter,
+        values
+      };
+    }
+    return filter;
+  });
+};
+var compileApplyFiltersPredicate = (filters, options) => {
+  const dashboardUpdates = filters.filter(isDashboardFilterUpdate);
+  const customFilters = filters.filter(isFilter);
+  const internalCustomFilters = customFilters.map((filter) => {
+    try {
+      return convertCustomFilter(filter);
+    } catch (error) {
+      return null;
+    }
+  }).concat(options.customFilters ?? []).filter((filter) => filter !== null && filter !== void 0);
+  const dashboardFilters = options.dashboardFilters ?? [];
+  const updatedDashboardFilters = dashboardUpdates.length ? updateDashboardFilters(dashboardUpdates, dashboardFilters) : dashboardFilters;
+  const columnTypeMap = buildColumnTypeMap(options.columns);
+  const predicates = [];
+  for (const filter of internalCustomFilters) {
+    const predicate = compileCustomFilter(filter, options);
+    if (predicate) predicates.push(predicate);
+  }
+  for (const filter of updatedDashboardFilters) {
+    const predicate = compileDashboardFilter(
+      filter,
+      options,
+      columnTypeMap
+    );
+    if (predicate) predicates.push(predicate);
+  }
+  if (predicates.length === 0) {
+    return { predicate: () => true, hasPredicates: false };
+  }
+  return {
+    predicate: (row) => {
+      const cache = /* @__PURE__ */ Object.create(null);
+      for (const predicate of predicates) {
+        if (!predicate(row, cache)) return false;
+      }
+      return true;
+    },
+    hasPredicates: true
+  };
+};
+var applyFiltersInMemory = (rows, filters, options) => {
+  if (!rows.length) return rows;
+  const { predicate, hasPredicates } = compileApplyFiltersPredicate(
+    filters,
+    options
+  );
+  if (!hasPredicates) return rows;
+  const results = [];
+  for (let i = 0; i < rows.length; i += 1) {
+    const row = rows[i];
+    if (predicate(row)) {
+      results.push(row);
+    }
+  }
+  return results;
+};
+
+// src/utils/inMemoryPivotEngine.ts
+init_columnType();
+var MS_IN_DAY = 24 * 60 * 60 * 1e3;
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var INVALID_DATE_KEY = "-2026";
+function singleAggToMultiAgg(pivot) {
+  if (pivot.aggregations) {
+    return pivot;
+  }
+  const newPivot = { ...pivot };
+  const newAgg = { aggregationType: pivot.aggregationType };
+  const fieldsToCopy = [
+    "valueField",
+    "valueFieldType",
+    "valueField2",
+    "valueField2Type"
+  ];
+  fieldsToCopy.forEach((x) => {
+    if (pivot[x]) {
+      newAgg[x] = pivot[x];
+      delete newPivot[x];
+    }
+  });
+  newPivot.aggregations = [newAgg];
+  return newPivot;
+}
+function isDateFormat2(xAxisFormat) {
+  const DATE_FORMATS = [
+    "yyyy",
+    "mmm_dd",
+    "mmm_yyyy",
+    "mmm_dd_yyyy",
+    "hh_ap_pm",
+    "mmm_dd-mmm_dd",
+    "mmm_dd_hh:mm_ap_pm",
+    "wo, yyyy"
+  ];
+  const isDate = DATE_FORMATS.includes(xAxisFormat.toLowerCase());
+  return isDate;
+}
+function isValidDate3(date) {
+  try {
+    return date instanceof Date && !isNaN(date.getTime());
+  } catch {
+    return false;
+  }
+}
+function isDateLikeType(fieldType) {
+  if (!fieldType) {
+    return false;
+  }
+  return isDateType(fieldType) || isDateFormat2(fieldType);
+}
+function inferDateBucketFromFilters(pivot, filters) {
+  if (!pivot?.rowFieldType) {
+    return void 0;
+  }
+  const normalizedType = String(pivot.rowFieldType).toLowerCase();
+  if (isDateFormat2(normalizedType)) {
+    switch (normalizedType) {
+      case "mmm_dd-mmm_dd":
+        return "week";
+      case "yyyy":
+      case "wo, yyyy":
+        return "year";
+      case "mmm_dd_hh:mm_ap_pm":
+      case "hh_ap_pm":
+        return "day";
+      default:
+        return "month";
+    }
+  }
+  const isDateLike = isDateType(normalizedType);
+  if (!isDateLike) {
+    return void 0;
+  }
+  let earliest;
+  let latest;
+  const extractTimestamp = (value) => {
+    if (!value) {
+      return void 0;
+    }
+    if (value instanceof Date) {
+      return value.getTime();
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  };
+  (Array.isArray(filters) ? filters : []).forEach((filter) => {
+    if (!filter || filter.filterType !== "date_range") {
+      return;
+    }
+    if (filter.primaryRange?.value === "ALL_TIME") {
+      earliest = -1;
+      return;
+    }
+    const possibleStarts = [
+      filter.startDate,
+      filter.start,
+      filter.primaryRange?.startDate,
+      filter.primaryRange?.start,
+      filter.range?.startDate,
+      filter.range?.start
+    ];
+    const possibleEnds = [
+      filter.endDate,
+      filter.end,
+      filter.primaryRange?.endDate,
+      filter.primaryRange?.end,
+      filter.range?.endDate,
+      filter.range?.end
+    ];
+    possibleStarts.forEach((value) => {
+      const timestamp = extractTimestamp(value);
+      if (timestamp === void 0) {
+        return;
+      }
+      earliest = earliest === void 0 ? timestamp : Math.min(earliest, timestamp);
+    });
+    possibleEnds.forEach((value) => {
+      const timestamp = extractTimestamp(value);
+      if (timestamp === void 0) {
+        return;
+      }
+      latest = latest === void 0 ? timestamp : Math.max(latest, timestamp);
+    });
+  });
+  if (earliest === -1) {
+    return "month";
+  }
+  if (earliest === void 0 || latest === void 0) {
+    return void 0;
+  }
+  if (latest < earliest) {
+    [earliest, latest] = [latest, earliest];
+  }
+  const diffInDays = Math.max(1, Math.round((latest - earliest) / MS_IN_DAY));
+  if (diffInDays < 20) {
+    return "day";
+  }
+  if (diffInDays <= 59) {
+    return "week";
+  }
+  if (diffInDays <= 400) {
+    return "month";
+  }
+  return "year";
+}
+function getDateRangeFromFilters(filters) {
+  let earliest;
+  let latest;
+  const extractTimestamp = (value) => {
+    if (!value) return void 0;
+    if (value instanceof Date) return value.getTime();
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  };
+  (Array.isArray(filters) ? filters : []).forEach((filter) => {
+    if (!filter || filter.filterType !== "date_range") return;
+    if (filter.primaryRange?.value === "ALL_TIME") return;
+    const possibleStarts = [
+      filter.startDate,
+      filter.start,
+      filter.primaryRange?.startDate,
+      filter.primaryRange?.start,
+      filter.range?.startDate,
+      filter.range?.start
+    ];
+    const possibleEnds = [
+      filter.endDate,
+      filter.end,
+      filter.primaryRange?.endDate,
+      filter.primaryRange?.end,
+      filter.range?.endDate,
+      filter.range?.end
+    ];
+    possibleStarts.forEach((v) => {
+      const ts = extractTimestamp(v);
+      if (ts === void 0) return;
+      earliest = earliest === void 0 ? ts : Math.min(earliest, ts);
+    });
+    possibleEnds.forEach((v) => {
+      const ts = extractTimestamp(v);
+      if (ts === void 0) return;
+      latest = latest === void 0 ? ts : Math.max(latest, ts);
+    });
+  });
+  if (earliest === void 0 || latest === void 0) return void 0;
+  if (latest < earliest) [earliest, latest] = [latest, earliest];
+  return {
+    start: new Date(earliest),
+    end: new Date(latest)
+  };
+}
+function generateBucketKeys(start2, end, bucket) {
+  const keys = /* @__PURE__ */ new Set();
+  const startDay = new Date(
+    Date.UTC(start2.getUTCFullYear(), start2.getUTCMonth(), start2.getUTCDate())
+  );
+  const endDay = new Date(
+    Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate())
+  );
+  const cur = new Date(startDay);
+  while (cur <= endDay) {
+    keys.add(getDateKey(cur, bucket));
+    cur.setUTCDate(cur.getUTCDate() + 1);
+  }
+  return Array.from(keys).sort((a, b) => parseInt(a) - parseInt(b));
+}
+function buildEmptyAggRow(aggregations) {
+  const multiAgg = aggregations.length > 1;
+  const empty = {};
+  aggregations.forEach((agg) => {
+    const { aggregationType: type, valueField } = agg;
+    const key = !valueField ? `${type}` + (multiAgg ? `_${type}` : "") : `${valueField}` + (multiAgg ? `_${type}` : "");
+    empty[key] = 0;
+  });
+  return empty;
+}
+function getBucketRange(dateKey, bucket) {
+  const d = new Date(parseInt(dateKey, 10));
+  let start2 = new Date(d);
+  let end = new Date(d);
+  switch (bucket) {
+    case "day":
+      start2 = new Date(
+        Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())
+      );
+      end = new Date(start2);
+      break;
+    case "week":
+      start2 = new Date(d);
+      end = new Date(start2);
+      end.setUTCDate(start2.getUTCDate() + 6);
+      break;
+    case "month":
+      start2 = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1));
+      end = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0));
+      break;
+    case "year":
+      start2 = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+      end = new Date(Date.UTC(d.getUTCFullYear(), 11, 31));
+      break;
+  }
+  return { start: start2, end };
+}
+function formatBucketNameFromRange(start2, end, bucket) {
+  const pad = (n) => String(n).padStart(2, "0");
+  switch (bucket) {
+    case "day":
+      return `${pad(start2.getUTCDate())} ${MONTHS[start2.getUTCMonth()]} ${start2.getUTCFullYear()}`;
+    case "week": {
+      const sameMonth = start2.getUTCMonth() === end.getUTCMonth();
+      return sameMonth ? `${MONTHS[start2.getUTCMonth()]} ${start2.getUTCDate()} - ${end.getUTCDate()}` : `${MONTHS[start2.getUTCMonth()]} ${start2.getUTCDate()} - ${MONTHS[end.getUTCMonth()]} ${end.getUTCDate()}`;
+    }
+    case "month":
+      return `${MONTHS[start2.getUTCMonth()]} ${start2.getUTCFullYear()}`;
+    case "year":
+      return `${start2.getUTCFullYear()}`;
+    default:
+      return "";
+  }
+}
+function getDateKey(date, bucket) {
+  if (!isValidDate3(date)) {
+    return INVALID_DATE_KEY;
+  }
+  switch (bucket) {
+    case "day":
+      return Date.UTC(
+        date.getUTCFullYear(),
+        date.getUTCMonth(),
+        date.getUTCDate()
+      ).toString();
+    case "week": {
+      const day = date.getUTCDay();
+      const mondayUtc = Date.UTC(
+        date.getUTCFullYear(),
+        date.getUTCMonth(),
+        date.getUTCDate() - (day + 6) % 7
+      );
+      return mondayUtc.toString();
+    }
+    case "month":
+      return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1).toString();
+    case "year":
+      return Date.UTC(date.getUTCFullYear(), 0, 1).toString();
+    default:
+      return INVALID_DATE_KEY;
+  }
+}
+function sortRows(rows, pivot) {
+  try {
+    const { sort, sortField, sortFieldType, sortDirection } = pivot;
+    if (!sort || sortField == null || sortFieldType == null) return rows;
+    const sortFunc = isBoolType(sortFieldType) ? (a, b) => a === b ? 0 : a ? 1 : -1 : isDateType(sortFieldType) ? (a, b) => {
+      const ta = new Date(a), tb = new Date(b);
+      const aValid = isValidDate3(ta), bValid = isValidDate3(tb);
+      if (!aValid && !bValid) return 0;
+      if (!aValid) return 1;
+      if (!bValid) return -1;
+      return ta.getTime() - tb.getTime();
+    } : isStringType(sortFieldType) ? (a, b) => a.localeCompare(b) : (a, b) => a - b;
+    const dir = sortDirection === "ASC" ? 1 : -1;
+    rows.sort((a, b) => {
+      const av = a[sortField], bv = b[sortField];
+      if (av == null && bv == null) return 0;
+      if (av == null) return 1;
+      if (bv == null) return -1;
+      return dir * sortFunc(av, bv);
+    });
+  } catch {
+    console.warn(`Sorting failed.`);
+  }
+  return rows;
+}
+function assembleFinalRows(seen, rowKey, dateBucket, dateRange) {
+  const allColumns = /* @__PURE__ */ new Set();
+  Object.keys(seen).forEach((rowKeyVal) => {
+    Object.keys(seen[rowKeyVal]).forEach((col) => {
+      allColumns.add(col);
+    });
+  });
+  const filled = {};
+  Object.keys(seen).forEach((rowKeyVal) => {
+    filled[rowKeyVal] = {};
+    allColumns.forEach((col) => {
+      const value = seen[rowKeyVal][col];
+      filled[rowKeyVal][col] = value ?? 0;
+    });
+  });
+  if (dateBucket) {
+    return Object.keys(filled).sort((a, b) => parseInt(a) - parseInt(b)).map((k) => {
+      if (k === INVALID_DATE_KEY) {
+        return { [rowKey]: "Invalid Date", ...filled[k], __quillRawDate: 0 };
+      }
+      const { start: start2, end } = getBucketRange(k, dateBucket);
+      let bucketStart = start2;
+      let bucketEnd = end;
+      if (dateRange) {
+        if (bucketStart < dateRange.start) bucketStart = dateRange.start;
+        if (bucketEnd > dateRange.end) bucketEnd = dateRange.end;
+      }
+      return {
+        [rowKey]: formatBucketNameFromRange(
+          bucketStart,
+          bucketEnd,
+          dateBucket
+        ),
+        ...filled[k],
+        __quillRawDate: bucketStart.toISOString()
+      };
+    });
+  }
+  return Object.keys(filled).sort().map((k) => ({ [rowKey]: k, ...filled[k] }));
+}
+function anyToNum(valueFieldType, obj) {
+  if (!valueFieldType) {
+    if (typeof obj === "number") return obj;
+    if (typeof obj === "string" && !isNaN(Number(obj))) return Number(obj);
+    return obj ? 1 : 0;
+  }
+  if (isNumberType(valueFieldType)) {
+    return Number(obj);
+  }
+  return obj ? 1 : 0;
+}
+function updateAccumulator(acc, row, agg, isOneRow) {
+  const {
+    aggregationType: type,
+    valueField,
+    valueFieldType,
+    valueField2,
+    valueField2Type
+  } = agg;
+  if (!valueField) return;
+  const distinctDenom = !!valueField2 && !!valueField2Type && valueField !== valueField2;
+  const rawVal = row[valueField];
+  if (valueFieldType && (type === "min" || type === "max") && (isDateType(valueFieldType) || isDateFormat2(valueFieldType))) {
+    const dateVal = rawVal instanceof Date ? rawVal : new Date(rawVal);
+    if (!isNaN(dateVal.getTime())) {
+      if (type === "min") {
+        acc.minDate = acc.minDate && acc.minDate.getTime() < dateVal.getTime() ? acc.minDate : dateVal;
+      } else {
+        acc.maxDate = acc.maxDate && acc.maxDate.getTime() > dateVal.getTime() ? acc.maxDate : dateVal;
+      }
+    }
+    return;
+  }
+  const numVal = anyToNum(valueFieldType, rawVal);
+  switch (type) {
+    case "sum":
+      acc.sum += numVal;
+      break;
+    case "average":
+    case "avg":
+      acc.sum += numVal;
+      acc.count++;
+      break;
+    case "min":
+      acc.min = acc.hasVal ? Math.min(acc.min, numVal) : numVal;
+      acc.hasVal = true;
+      break;
+    case "max":
+      acc.max = acc.hasVal ? Math.max(acc.max, numVal) : numVal;
+      acc.hasVal = true;
+      break;
+    case "count":
+      acc.count += numVal;
+      break;
+    case "percentage":
+      acc.sum += numVal;
+      acc.count += distinctDenom ? anyToNum(valueField2Type, row[valueField2]) : isOneRow ? 1 : numVal;
+      break;
+  }
+}
+function getFinalAggregationValue({
+  type,
+  valueFieldType,
+  valueField,
+  acc,
+  distinctDenom = false,
+  sumOfDenom,
+  rowsLength,
+  totalRowsForCount
+}) {
+  if (valueFieldType && (type === "min" || type === "max") && (isDateType(valueFieldType) || isDateFormat2(valueFieldType))) {
+    const dateVal = type === "min" ? acc.minDate : acc.maxDate;
+    return dateVal?.toISOString() ?? "";
+  }
+  if (type === "count") {
+    return totalRowsForCount ?? acc.count;
+  }
+  let final;
+  if (!valueField && type === "percentage" && rowsLength !== void 0) {
+    final = rowsLength ? (totalRowsForCount ?? 0) / rowsLength : 0;
+  } else {
+    switch (type) {
+      case "sum":
+        final = acc.sum;
+        break;
+      case "average":
+      case "avg":
+        final = acc.count ? acc.sum / acc.count : 0;
+        break;
+      case "min":
+        final = acc.hasVal ? acc.min : 0;
+        break;
+      case "max":
+        final = acc.hasVal ? acc.max : 0;
+        break;
+      case "percentage": {
+        const denom = distinctDenom ? acc.count : sumOfDenom ?? acc.count;
+        final = denom ? acc.sum / denom : 0;
+        break;
+      }
+      default:
+        final = 0;
+    }
+  }
+  return final;
+}
+function aggregateToOneRow(rows, aggregations) {
+  const multiAgg = aggregations.length > 1;
+  const resultArray = aggregations.map((agg) => {
+    const { aggregationType: type, valueField, valueFieldType } = agg;
+    if (!valueField) {
+      if (type !== "count") {
+        return {};
+      }
+      const finalKey2 = "count" + (multiAgg ? "_count" : "");
+      return { [finalKey2]: rows.length };
+    }
+    const finalKey = `${valueField}` + (multiAgg ? `_${type}` : "");
+    const acc = {
+      sum: 0,
+      count: 0,
+      min: Infinity,
+      max: -Infinity,
+      hasVal: false,
+      minDate: null,
+      maxDate: null
+    };
+    for (const row of rows) {
+      updateAccumulator(acc, row, agg, true);
+    }
+    return {
+      [finalKey]: getFinalAggregationValue({
+        type,
+        valueFieldType,
+        valueField,
+        acc,
+        totalRowsForCount: acc.count
+      })
+    };
+  });
+  return [
+    resultArray.reduce((acc, current) => {
+      return { ...acc, ...current };
+    }, {})
+  ];
+}
+function aggregateWithColumn(rows, colKey, aggregations, getGroupKey) {
+  if (!colKey) return;
+  const seen = {};
+  const multiAgg = aggregations.length > 1;
+  aggregations.forEach((agg) => {
+    const {
+      aggregationType: type,
+      valueField,
+      valueFieldType,
+      valueField2,
+      valueField2Type
+    } = agg;
+    if (!valueField) {
+      if (type !== "count" && type !== "percentage") return;
+    }
+    const distinctDenom = !!valueField2 && !!valueField2Type && valueField !== valueField2;
+    const accs = {};
+    rows.forEach((row) => {
+      const groupKey = getGroupKey(row);
+      const colVal = row[colKey];
+      if (!accs[groupKey]) accs[groupKey] = {};
+      if (!accs[groupKey][colVal]) {
+        accs[groupKey][colVal] = {
+          sum: 0,
+          count: 0,
+          min: Infinity,
+          max: -Infinity,
+          hasVal: false,
+          minDate: null,
+          maxDate: null,
+          totalRows: 0
+        };
+      }
+      const acc = accs[groupKey][colVal];
+      acc.totalRows += 1;
+      if (!valueField) {
+        if (type === "count") acc.count += 1;
+        else if (type === "percentage") acc.sum += 1;
+        return;
+      }
+      updateAccumulator(acc, row, agg, false);
+    });
+    Object.keys(accs).forEach((groupKey) => {
+      if (!seen[groupKey]) seen[groupKey] = {};
+      const sumOfDenom = Object.values(accs[groupKey]).reduce(
+        (t, a) => t + a.count,
+        0
+      );
+      Object.keys(accs[groupKey]).forEach((colVal) => {
+        const acc = accs[groupKey][colVal];
+        const finalKey = `${colVal}` + (multiAgg ? `_${type}` : "");
+        seen[groupKey][finalKey] = getFinalAggregationValue({
+          type,
+          valueFieldType,
+          valueField,
+          acc,
+          distinctDenom,
+          sumOfDenom,
+          totalRowsForCount: acc.totalRows
+        });
+      });
+    });
+  });
+  return seen;
+}
+function aggregateWithoutColumn(rows, aggregations, getGroupKey) {
+  const seen = {};
+  const multiAgg = aggregations.length > 1;
+  aggregations.forEach((agg) => {
+    const {
+      aggregationType: type,
+      valueField,
+      valueFieldType,
+      valueField2,
+      valueField2Type
+    } = agg;
+    if (!valueField) {
+      if (type !== "count" && type !== "percentage") return;
+    }
+    const finalKey = !valueField ? `${type}` + (multiAgg ? `_${type}` : "") : `${valueField}` + (multiAgg ? `_${type}` : "");
+    const distinctDenom = !!valueField2 && !!valueField2Type && valueField !== valueField2;
+    const accs = {};
+    rows.forEach((row) => {
+      const key = getGroupKey(row);
+      if (!seen[key]) seen[key] = {};
+      if (!accs[key]) {
+        accs[key] = {
+          sum: 0,
+          count: 0,
+          min: Infinity,
+          max: -Infinity,
+          hasVal: false,
+          minDate: null,
+          maxDate: null,
+          totalRows: 0
+        };
+      }
+      const acc = accs[key];
+      acc.totalRows += 1;
+      if (!valueField) {
+        if (type === "count") acc.count += 1;
+        else if (type === "percentage") acc.sum += 1;
+        return;
+      }
+      updateAccumulator(acc, row, agg, false);
+    });
+    const sumOfDenom = Object.values(accs).reduce(
+      (t, a) => t + a.count,
+      0
+    );
+    Object.keys(accs).forEach((k) => {
+      const acc = accs[k];
+      seen[k][finalKey] = getFinalAggregationValue({
+        type,
+        valueFieldType,
+        valueField,
+        acc,
+        distinctDenom,
+        sumOfDenom,
+        rowsLength: rows.length,
+        totalRowsForCount: acc.totalRows
+      });
+    });
+  });
+  return seen;
+}
+function applyPivotInMemory(rows, pivot, filters) {
+  if (!pivot) return rows;
+  const multiAggPivot = pivot.aggregations ? pivot : singleAggToMultiAgg(pivot);
+  if (multiAggPivot.rowField === void 0) {
+    return aggregateToOneRow(rows, multiAggPivot.aggregations);
+  }
+  const { rowField, columnField, aggregations } = multiAggPivot;
+  const dateBucket = inferDateBucketFromFilters(pivot, filters);
+  const dateRange = dateBucket ? getDateRangeFromFilters(filters) : void 0;
+  const getRowKey = dateBucket ? (row) => {
+    const rawValue = row[rowField];
+    const rawDateFromQuill = row.__quillRawDate;
+    const rawDateValue = rawDateFromQuill ?? (rawValue !== null && typeof rawValue === "object" && rawValue.value ? rawValue.value : rawValue);
+    return getDateKey(new Date(rawDateValue), dateBucket);
+  } : (row) => row[rowField];
+  const aggregated = columnField ? aggregateWithColumn(rows, columnField, aggregations, getRowKey) : aggregateWithoutColumn(rows, aggregations, getRowKey);
+  const aggregatedRows = aggregated || {};
+  if (rows.length === 0 && dateBucket && dateRange && !columnField) {
+    const bucketKeys = generateBucketKeys(
+      dateRange.start,
+      dateRange.end,
+      dateBucket
+    );
+    const emptyAgg = buildEmptyAggRow(aggregations);
+    bucketKeys.forEach((k) => {
+      aggregatedRows[k] = { ...emptyAgg };
+    });
+  }
+  const finalRows = assembleFinalRows(
+    aggregatedRows,
+    rowField,
+    dateBucket,
+    rows.length === 0 ? dateRange : void 0
+  );
+  const sorted = sortRows(finalRows, pivot);
+  if (pivot.rowLimit) {
+    return sorted.slice(0, pivot.rowLimit);
+  }
+  return sorted;
+}
+function generatePivotColumnsInMemory({
+  pivot,
+  pivotRows,
+  sourceColumns
+}) {
+  if (!pivot?.rowField || !Array.isArray(pivotRows) || pivotRows.length === 0) {
+    return void 0;
+  }
+  const columns = Array.isArray(sourceColumns) ? sourceColumns : [];
+  const rowSource = columns.find((col) => col.field === pivot.rowField);
+  const isRowFieldDate = isDateLikeType(pivot.rowFieldType);
+  const rowFieldType = rowSource?.fieldType ?? pivot.rowFieldType ?? "string";
+  const rowColumn = {
+    field: pivot.rowField,
+    label: rowSource?.label ?? pivot.rowField,
+    format: isRowFieldDate ? "string" : rowSource?.format ?? "string",
+    fieldType: rowFieldType,
+    dataTypeID: rowSource?.dataTypeID ?? 1043,
+    jsType: rowSource?.jsType ?? (isRowFieldDate ? "date" : "string")
+  };
+  const valueFieldFormat = (valueField) => columns.find((col) => col.field === valueField)?.format ?? "whole_number";
+  const multiAgg = (pivot.aggregations?.length ?? 0) > 1;
+  const aggregationBySuffix = new Map(
+    (pivot.aggregations ?? []).map((agg) => [
+      multiAgg ? `_${agg.aggregationType}` : "",
+      agg
+    ])
+  );
+  const valueKeys = Array.from(
+    new Set(
+      pivotRows.flatMap(
+        (row) => Object.keys(row).filter(
+          (key) => key !== pivot.rowField && key !== "__quillRawDate"
+        )
+      )
+    )
+  );
+  const valueColumns = valueKeys.map((key) => {
+    const matchingSuffix = Array.from(aggregationBySuffix.keys()).find(
+      (suffix) => suffix && key.endsWith(suffix)
+    );
+    const matchedAgg = matchingSuffix ? aggregationBySuffix.get(matchingSuffix) : pivot.aggregations?.[0];
+    const format9 = matchedAgg?.aggregationType === "percentage" ? "percent" : valueFieldFormat(matchedAgg?.valueField);
+    const valueFieldType = matchedAgg?.valueFieldType ?? "number";
+    return {
+      field: key,
+      label: key,
+      format: format9,
+      fieldType: valueFieldType,
+      jsType: valueFieldType,
+      dataTypeID: columns.find((col) => col.field === matchedAgg?.valueField)?.dataTypeID ?? 20
+    };
+  });
+  return [rowColumn, ...valueColumns];
+}
+
+// src/utils/cacheCab.ts
+import { openDB } from "idb";
+import { endOfDay as endOfDay3, max as maxDate, subMonths as subMonths4, min as minDate, startOfDay as startOfDay4 } from "date-fns";
+import { utcToZonedTime as utcToZonedTime2, zonedTimeToUtc } from "date-fns-tz";
+var TZ = "America/Los_Angeles";
+var CacheCab = class {
+  fetchedRange = {};
+  cachedReportIds = [];
+  uncacheableReportIDs = [];
+  uncacheableInFlight = /* @__PURE__ */ new Map();
+  storage;
+  META_KEY = "cachecab:meta";
+  DATA_PREFIX = "cachecab:data:";
+  UNCACHEABLE_PREFIX = "cachecab:uncacheable:";
+  constructor({
+    storageType = "memory"
+  } = {}) {
+    this.storage = storageType !== "idb" ? new MemoryStorage() : new IdbStorage();
+    void this.loadMetaFromStorage();
+  }
+  async get(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, pageSize, getToken, eventTracking, forceRefresh) {
+    if (this.isCached(reportId, tenants) && !forceRefresh) {
+      return this.getFromCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking);
+    } else {
+      return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, true, forceRefresh);
+    }
+  }
+  isCached(reportId, tenants) {
+    return this.cachedReportIds.includes(this.getCacheKey(reportId, tenants));
+  }
+  isCacheable(reportId) {
+    return !this.uncacheableReportIDs.includes(reportId);
+  }
+  async getUncacheableResult(reportId, client, tenants, flags, filters, additionalProcessing, pivot) {
+    const key = this.getUncacheableRequestKey(
+      reportId,
+      client,
+      tenants,
+      flags,
+      filters,
+      additionalProcessing,
+      pivot
+    );
+    try {
+      const raw = await this.storage.getItem(key);
+      return raw ? JSON.parse(raw) : null;
+    } catch {
+      return null;
+    }
+  }
+  async setUncacheableResult(reportId, client, tenants, flags, filters, additionalProcessing, pivot, report) {
+    const key = this.getUncacheableRequestKey(
+      reportId,
+      client,
+      tenants,
+      flags,
+      filters,
+      additionalProcessing,
+      pivot
+    );
+    try {
+      await this.storage.setItem(key, JSON.stringify(report));
+    } catch {
+    }
+  }
+  async getOrFetchUncacheableResult(reportId, client, tenants, flags, filters, additionalProcessing, pivot, fetcher, forceRefresh = false) {
+    const key = this.getUncacheableRequestKey(
+      reportId,
+      client,
+      tenants,
+      flags,
+      filters,
+      additionalProcessing,
+      pivot
+    );
+    if (!forceRefresh) {
+      const raw = await this.storage.getItem(key);
+      if (raw) {
+        return { report: JSON.parse(raw), fromCache: true };
+      }
+      const inFlight = this.uncacheableInFlight.get(key);
+      if (inFlight) {
+        const report = await inFlight;
+        return { report, fromCache: false };
+      }
+    }
+    const requestPromise = (async () => {
+      const report = await fetcher();
+      try {
+        await this.storage.setItem(key, JSON.stringify(report));
+      } catch {
+      }
+      return report;
+    })();
+    this.uncacheableInFlight.set(key, requestPromise);
+    try {
+      const report = await requestPromise;
+      return { report, fromCache: false };
+    } finally {
+      this.uncacheableInFlight.delete(key);
+    }
+  }
+  async addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, firstTime = true, forceRefresh = false) {
+    const tenantPart = tenants ? JSON.stringify(tenants) : "";
+    const cacheKey = this.getCacheKey(reportId, tenants);
+    if (firstTime) {
+      const result = await this.fetchInitialReport({ reportId, client, tenants, flags, filters: dashboardFilters, getToken, eventTracking, forceRefresh });
+      try {
+        await this.storage.setItem(this.DATA_PREFIX + cacheKey, JSON.stringify(result));
+        this.cachedReportIds.push(cacheKey);
+        await this.persistMetaToStorage();
+      } catch {
+        console.warn(`Failed to cache report: ${reportId}. Cache full?`);
+      }
+      const newRows = await this.applyPivotsAndFilters(result, dashboardFilters, customFilters, pivot, tenantPart, false);
+      if (pivot) {
+        const pivotColumns = generatePivotColumnsInMemory({
+          pivot,
+          pivotRows: newRows,
+          sourceColumns: result.columnInternal ?? result.columns
+        });
+        return { ...result, pivotRows: newRows, pivotColumns: pivotColumns ?? result.pivotColumns, pivotRowCount: newRows.length };
+      }
+      return { ...result, rows: newRows, rowCount: newRows.length };
+    } else {
+      const dbDateFilter = dashboardFilters.find((x) => x.filterType === "date_range");
+      const { start: requestedStart, end: requestedEnd } = normalizePSTRanges(
+        dbDateFilter?.startDate ? new Date(dbDateFilter.startDate) : void 0,
+        dbDateFilter?.endDate ? new Date(dbDateFilter.endDate) : void 0
+      );
+      if (!requestedStart || !requestedEnd) {
+        return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, true);
+      }
+      const currentRange = this.fetchedRange[cacheKey];
+      const rangeStart = currentRange?.start ?? requestedStart;
+      const rangeEnd = currentRange?.end ?? endOfDayPST(/* @__PURE__ */ new Date());
+      const existingRaw = await this.storage.getItem(this.DATA_PREFIX + cacheKey);
+      let existing;
+      let fetchedRows = [];
+      try {
+        existing = JSON.parse(existingRaw);
+        if (!existing.rows) {
+          throw new Error("Invalid Cache!");
+        }
+        if (requestedStart < rangeStart) {
+          const olderReport = await this.fetchReport({
+            reportId,
+            client,
+            tenants,
+            flags,
+            filters: dashboardFilters,
+            getToken,
+            eventTracking,
+            start: requestedStart,
+            end: rangeStart
+          });
+          fetchedRows = olderReport.rows;
+        }
+        if (requestedEnd && requestedEnd > rangeEnd) {
+          const newerReport = await this.fetchReport({
+            reportId,
+            client,
+            tenants,
+            flags,
+            filters: dashboardFilters,
+            getToken,
+            eventTracking,
+            start: rangeEnd,
+            end: requestedEnd
+          });
+          fetchedRows = fetchedRows.concat(newerReport.rows);
+        }
+      } catch {
+        existing = await this.fetchReport({
+          reportId,
+          client,
+          tenants,
+          flags,
+          filters: dashboardFilters,
+          getToken,
+          eventTracking,
+          start: requestedStart,
+          end: requestedEnd
+        });
+        fetchedRows = existing.rows;
+      }
+      const dateKey = existing.dateField?.field ? removeQuotes(existing.dateField.field) : void 0;
+      let mergedRows;
+      if (dateKey) {
+        const startMs = rangeStart.getTime();
+        const endMs = rangeEnd.getTime();
+        const boundaryRows = existing.rows.filter((row) => {
+          const raw = row[dateKey];
+          if (!raw) return false;
+          const t = new Date(raw).getTime();
+          return Math.abs(t - startMs) <= MS_IN_DAY || Math.abs(t - endMs) <= MS_IN_DAY;
+        });
+        const filteredNew = filterNewRows(boundaryRows, fetchedRows);
+        mergedRows = filteredNew.concat(existing.rows);
+      } else {
+        mergedRows = filterNewRows(existing.rows, fetchedRows).concat(existing.rows);
+      }
+      const merged = { ...existing, rows: mergedRows };
+      await this.storage.setItem(this.DATA_PREFIX + cacheKey, JSON.stringify(merged));
+      await this.persistMetaToStorage();
+      const newRows = await this.applyPivotsAndFilters(merged, dashboardFilters, customFilters, pivot, tenantPart, false);
+      if (pivot) {
+        const pivotColumns = generatePivotColumnsInMemory({
+          pivot,
+          pivotRows: newRows,
+          sourceColumns: merged.columnInternal ?? merged.columns
+        });
+        return { ...merged, pivotRows: newRows, pivotColumns: pivotColumns ?? merged.pivotColumns, pivotRowCount: newRows.length };
+      }
+      return { ...merged, rows: newRows, rowCount: newRows.length };
+    }
+  }
+  /**
+   * Returns cache entry (or re-queries if stale)
+   */
+  async getFromCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking) {
+    const dateRangeFilter = dashboardFilters.find((x) => x.filterType === "date_range");
+    const cacheKey = this.getCacheKey(reportId, tenants);
+    if (!dateRangeFilter || dateRangeFilter?.primaryRange.value === "ALL_TIME") {
+      const fetchInfo = this.fetchedRange[cacheKey];
+      if (!fetchInfo || fetchInfo?.allTimeDoneBefore === false || Date.now() - fetchInfo.fetchedAtUTCMS >= MS_IN_DAY) {
+        return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, true);
+      }
+    } else if (this.weShouldReQuery(cacheKey, dateRangeFilter)) {
+      return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, false);
+    }
+    try {
+      const raw = await this.storage.getItem(this.DATA_PREFIX + cacheKey);
+      if (!raw) {
+        throw new Error("Invalid Cache!");
+      }
+      const parsed = JSON.parse(raw);
+      const tenantPart = tenants ? JSON.stringify(tenants) : "";
+      const newRows = await this.applyPivotsAndFilters(parsed, dashboardFilters, customFilters, pivot, tenantPart);
+      if (pivot) {
+        const pivotColumns = generatePivotColumnsInMemory({
+          pivot,
+          pivotRows: newRows,
+          sourceColumns: parsed.columnInternal ?? parsed.columns
+        });
+        return { ...parsed, pivotRows: newRows, pivotColumns: pivotColumns ?? parsed.pivotColumns, pivotRowCount: newRows.length };
+      }
+      return { ...parsed, rows: newRows, rowCount: newRows.length };
+    } catch (err) {
+      console.error(err);
+      return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, false);
+    }
+  }
+  weShouldReQuery(cacheKey, dateRangeFilter) {
+    const start2 = dateRangeFilter.startDate;
+    const end = dateRangeFilter.endDate;
+    const range = this.fetchedRange[cacheKey];
+    const { start: s, end: e } = normalizePSTRanges(
+      start2 ? new Date(start2) : void 0,
+      end ? new Date(end) : void 0
+    );
+    return !range || !s || !e || range.start > s || range.end < e;
+  }
+  async fetchInitialReport({
+    reportId,
+    client,
+    tenants,
+    flags,
+    filters = [],
+    getToken,
+    eventTracking,
+    forceRefresh
+  }) {
+    let start2;
+    let end;
+    const dateRangeFilter = filters.find((x) => x.filterType === "date_range");
+    const cacheRange = dateRangeFilter?.initialCacheDateRange;
+    if (cacheRange && cacheRange.startDate) {
+      const startDate = dateRangeFilter?.startDate;
+      start2 = startDate ? minDate([new Date(cacheRange.startDate), new Date(startDate)]) : new Date(cacheRange.startDate);
+      end = endOfDayPST(/* @__PURE__ */ new Date());
+    } else {
+      const endDate = dateRangeFilter?.endDate ? new Date(dateRangeFilter.endDate) : void 0;
+      const currentDay = endOfDayPST(/* @__PURE__ */ new Date());
+      end = endDate ? maxDate([currentDay, endDate]) : currentDay;
+      start2 = subMonths4(end, 7);
+    }
+    const normalized = normalizePSTRanges(start2, end);
+    return this.fetchReport({
+      reportId,
+      client,
+      tenants,
+      flags,
+      filters,
+      getToken,
+      eventTracking,
+      start: normalized.start,
+      end: normalized.end,
+      forceRefresh
+    });
+  }
+  async fetchReport({
+    reportId,
+    client,
+    tenants,
+    flags,
+    filters = [],
+    getToken,
+    eventTracking,
+    start: start2,
+    end,
+    forceRefresh
+  }) {
+    let reportInfo = void 0;
+    try {
+      const { start: s, end: e } = normalizePSTRanges(start2, end);
+      const adjusted = [...filters].map((x) => {
+        return { ...x, options: void 0 };
+      });
+      const dateFilterIndex = adjusted.findIndex((x) => x.filterType === "date_range");
+      const isAllTime = dateFilterIndex !== -1 && adjusted[dateFilterIndex].primaryRange?.value === "ALL_TIME";
+      if (!isAllTime) {
+        const dateFilter = adjusted[dateFilterIndex];
+        if (dateFilter && dateFilter.startDate && dateFilter.endDate) {
+          adjusted[dateFilterIndex] = { ...dateFilter, startDate: s, endDate: e };
+        }
+      }
+      const fetchResp = await quillFetch({
+        client,
+        task: "report",
+        metadata: {
+          reportId,
+          clientId: client.publicKey,
+          databaseType: client.databaseType,
+          filters: adjusted,
+          additionalProcessing: { page: { rowsPerPage: 1e3, rowsPerRequest: 1e5 } },
+          useNewNodeSql: true,
+          tenants,
+          flags,
+          overwriteCache: forceRefresh ?? false
+        },
+        getToken
+      });
+      const resp = await parseFetchResponse(
+        client,
+        "report",
+        fetchResp,
+        getToken,
+        true
+      );
+      reportInfo = await processReportResponse({
+        resp,
+        client,
+        filters: adjusted,
+        dateBucket: resp?.dateBucket,
+        additionalProcessing: { page: { rowsPerPage: 1e3, rowsPerRequest: 1e5 } },
+        getToken,
+        eventTracking,
+        tenants,
+        // CacheCab fetches with task: 'report'; keep pivot processing local.
+        skipPivotFetch: true,
+        overwriteCache: forceRefresh ?? false
+      });
+      const dateField = reportInfo.dateField?.field;
+      if (!isAllTime && dateField !== void 0 && reportInfo.rows.length > 0) {
+        const cleanedDateField = removeQuotes(dateField);
+        const missingDateFieldCount = reportInfo.rows.some((row) => row[cleanedDateField] === void 0);
+        if (missingDateFieldCount) {
+          this.uncacheableReportIDs.push(reportId);
+          return EMPTY_INTERNAL_REPORT;
+        }
+      }
+      const requiredFilterFields = adjusted.flatMap((x, idx) => {
+        if (idx === dateFilterIndex || !x.values && !x.selectedValue) return [];
+        return removeQuotes(x.field);
+      });
+      const missingFields = [...new Set(requiredFilterFields.filter(
+        (field) => reportInfo?.rows.some((row) => row[field] === void 0)
+      ))];
+      if (missingFields.length > 0) {
+        this.uncacheableReportIDs.push(reportId);
+        return EMPTY_INTERNAL_REPORT;
+      }
+      const cacheKey = this.getCacheKey(reportId, tenants);
+      if (isAllTime) {
+        this.fetchedRange[cacheKey] = { start: /* @__PURE__ */ new Date(0), end: /* @__PURE__ */ new Date(), fetchedAtUTCMS: Date.now(), allTimeDoneBefore: true };
+      } else {
+        const existing = this.fetchedRange[cacheKey];
+        if (existing && !forceRefresh) {
+          const oldStart = existing.start;
+          const oldEnd = existing.end;
+          this.fetchedRange[cacheKey] = { start: getMinDate(oldStart, s), end: getMaxDate(oldEnd, e), fetchedAtUTCMS: Date.now(), allTimeDoneBefore: false };
+        } else {
+          this.fetchedRange[cacheKey] = { start: s, end: e, fetchedAtUTCMS: Date.now(), allTimeDoneBefore: false };
+        }
+      }
+    } catch (error) {
+      console.warn(error);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw error;
+      }
+    }
+    return reportInfo || EMPTY_INTERNAL_REPORT;
+  }
+  async applyPivotsAndFilters(report, dashboardFilters, customFilters, pivot, tenantPart, useCache = true) {
+    const datasetVersion = this.fetchedRange[report.id + tenantPart]?.fetchedAtUTCMS ?? 0;
+    const keyParts = [
+      report.queryString,
+      tenantPart,
+      datasetVersion,
+      // prevents fetching stale filters on hard refresh
+      hashString(stableStringify(dashboardFilters)),
+      hashString(stableStringify(customFilters))
+    ];
+    const queryKey = this.DATA_PREFIX + keyParts.join("|");
+    let filtersApplied;
+    if (useCache) {
+      try {
+        const cache = await this.storage.getItem(queryKey);
+        if (cache) {
+          filtersApplied = JSON.parse(cache);
+        }
+      } catch {
+      }
+    }
+    if (!filtersApplied) {
+      const dateIndex = dashboardFilters.findIndex((x) => x.filterType === "date_range");
+      const requiredFilterFields = dashboardFilters.flatMap((x, idx) => {
+        if (idx === dateIndex || !x.values?.length && !x.selectedValue) return [];
+        return removeQuotes(x.field);
+      });
+      const missingFields = [...new Set(requiredFilterFields.filter(
+        (field) => report.rows.some((row) => row[field] === void 0)
+      ))];
+      if (missingFields.length > 0) {
+        this.uncacheableReportIDs.push(report.id);
+        return [];
+      }
+      const dbDateFilter = dashboardFilters.find((x) => x.filterType === "date_range");
+      if (report.dateField && dbDateFilter?.startDate) {
+        const { start: startDate, end: endDate } = normalizePSTRanges(
+          new Date(dbDateFilter.startDate),
+          dbDateFilter.endDate ? new Date(dbDateFilter.endDate) : void 0
+        );
+        const fieldToUse = report.rows[0] && report.rows[0]["__quillRawDate"] ? "__quillRawDate" : removeQuotes(report.dateField.field);
+        const dateFilteredRows = report.rows.filter((x) => {
+          const rowDate = new Date(x[fieldToUse]);
+          return startDate <= rowDate && (endDate ? rowDate <= endDate : true);
+        });
+        filtersApplied = applyFiltersInMemory(dateFilteredRows, [], { dashboardFilters, customFilters });
+      } else {
+        filtersApplied = applyFiltersInMemory(report.rows, [], { dashboardFilters, customFilters });
+      }
+    }
+    try {
+      await this.storage.setItem(queryKey, JSON.stringify(filtersApplied));
+    } catch {
+    }
+    const withPivot = applyPivotInMemory(filtersApplied, pivot, dashboardFilters.concat(customFilters));
+    return withPivot;
+  }
+  getCacheKey(reportId, tenants) {
+    const tenantPart = tenants ? JSON.stringify(tenants) : "";
+    return reportId + tenantPart;
+  }
+  getUncacheableRequestKey(reportId, client, tenants, flags, filters, additionalProcessing, pivot) {
+    const canonicalFilters = filters.map(
+      (f) => canonicalizeFilterForUncacheableKey(f)
+    );
+    const keyParts = [
+      reportId,
+      client.publicKey,
+      client.databaseType,
+      hashString(stableStringify(canonicalizeForKey(tenants ?? null))),
+      hashString(stableStringify(canonicalizeForKey(flags ?? null))),
+      hashString(stableStringify(canonicalFilters)),
+      hashString(stableStringify(canonicalizeForKey(additionalProcessing ?? null))),
+      hashString(stableStringify(canonicalizeForKey(pivot ?? null)))
+    ];
+    return this.UNCACHEABLE_PREFIX + keyParts.join("|");
+  }
+  async loadMetaFromStorage() {
+    const meta = await this.storage.getItem(this.META_KEY);
+    if (!meta) return;
+    try {
+      const parsed = JSON.parse(meta);
+      this.cachedReportIds = parsed.cached || [];
+      this.uncacheableReportIDs = parsed.cannotBeCached;
+      this.fetchedRange = Object.fromEntries(
+        Object.entries(parsed.fetchedRange || {}).map(([id2, range]) => [
+          id2,
+          { ...range, start: new Date(range.start), end: new Date(range.end) }
+        ])
+      );
+    } catch (err) {
+      console.warn("CacheCab: could not parse meta from storage", err);
+    }
+  }
+  async persistMetaToStorage() {
+    const serializableRange = Object.fromEntries(
+      Object.entries(this.fetchedRange).map(([id2, range]) => [
+        id2,
+        { ...range }
+      ])
+    );
+    await this.storage.setItem(
+      this.META_KEY,
+      JSON.stringify({
+        fetchedRange: serializableRange,
+        cached: this.cachedReportIds,
+        cannotBeCached: this.uncacheableReportIDs
+      })
+    );
+  }
+};
+var MemoryStorage = class {
+  store = /* @__PURE__ */ new Map();
+  async getItem(key) {
+    return this.store.get(key) ?? null;
+  }
+  async setItem(key, value) {
+    this.store.set(key, value);
+  }
+};
+var DB_NAME = "quill.cachecab";
+var STORE_NAME = "kv";
+var IdbStorage = class {
+  dbPromise;
+  constructor() {
+    this.dbPromise = openDB(DB_NAME, 1, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME);
+        }
+      }
+    });
+  }
+  async getItem(key) {
+    const db = await this.dbPromise;
+    return await db.get(STORE_NAME, key) ?? null;
+  }
+  async setItem(key, value) {
+    const db = await this.dbPromise;
+    await db.put(STORE_NAME, value, key);
+  }
+};
+function removeQuotes(str) {
+  return str.replace(/^['"]|['"]$/g, "");
+}
+function getMaxDate(d1, d2) {
+  return d1 > d2 ? d1 : d2;
+}
+function getMinDate(d1, d2) {
+  return d2 > d1 ? d1 : d2;
+}
+function hashString(str) {
+  let h1 = 3735928559 ^ 0, h2 = 1103547991 ^ 0;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+function filterNewRows(existingRows, newRows) {
+  const seen = /* @__PURE__ */ new Set();
+  const getKey = (row) => stableStringify(row);
+  existingRows.forEach((row) => seen.add(getKey(row)));
+  return newRows.filter((row) => {
+    const k = getKey(row);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function stableStringify(obj) {
+  if (obj === null || typeof obj !== "object") return JSON.stringify(obj);
+  if (Array.isArray(obj)) {
+    return `[${obj.map(stableStringify).join(",")}]`;
+  }
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",")}}`;
+}
+function canonicalizeForKey(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(canonicalizeForKey);
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    Object.keys(value).sort().forEach((key) => {
+      if (value[key] !== void 0) {
+        out[key] = canonicalizeForKey(value[key]);
+      }
+    });
+    return out;
+  }
+  return value;
+}
+function canonicalizeFilterForUncacheableKey(filter) {
+  const raw = canonicalizeForKey(filter) ?? {};
+  const base = {
+    filterType: raw.filterType,
+    field: raw.field,
+    table: raw.table,
+    label: raw.label,
+    operator: raw.operator
+  };
+  if (raw.selectedValue !== void 0) {
+    base.selectedValue = raw.selectedValue;
+  }
+  if (Array.isArray(raw.values)) {
+    base.values = [...raw.values].map(canonicalizeForKey).sort();
+  }
+  if (raw.value !== void 0) {
+    base.value = canonicalizeForKey(raw.value);
+  }
+  if (raw.filterType === "date_range") {
+    const { start: start2, end } = normalizePSTRanges(
+      raw.startDate ? new Date(raw.startDate) : void 0,
+      raw.endDate ? new Date(raw.endDate) : void 0
+    );
+    base.startDate = start2 ? start2.toISOString() : void 0;
+    base.endDate = end ? end.toISOString() : void 0;
+    base.primaryRange = raw.primaryRange?.value;
+    base.comparisonRange = raw.comparisonRange?.value;
+  }
+  return canonicalizeForKey(base);
+}
+function startOfDayPST(date) {
+  const pstDate = utcToZonedTime2(date, TZ);
+  const startPst = startOfDay4(pstDate);
+  return zonedTimeToUtc(startPst, TZ);
+}
+function endOfDayPST(date) {
+  const pstDate = utcToZonedTime2(date, TZ);
+  const endPst = endOfDay3(pstDate);
+  return zonedTimeToUtc(endPst, TZ);
+}
+function normalizePSTRanges(start2, end) {
+  return {
+    start: start2 ? startOfDayPST(start2) : void 0,
+    end: end ? endOfDayPST(end) : void 0
+  };
+}
+
+// src/Context.tsx
 import { jsx } from "react/jsx-runtime";
 var dummySetter = () => {
 };
@@ -21931,7 +23897,9 @@ var ReportFiltersContext = createContext({
   loadFiltersForReport: async () => {
   },
   abortLoadingFilters: () => {
-  }
+  },
+  customFiltersLoaded: false,
+  setCustomFiltersLoaded: dummySetter
 });
 var customDashboardFiltersReducer = (state, action) => {
   switch (action.type) {
@@ -22021,6 +23989,9 @@ var FetchContext = createContext({
 var EventTrackingContext = createContext({
   eventTracking: null
 });
+var CacheCabContext = createContext({
+  getCacheCab: (storageType) => new CacheCab({ storageType })
+});
 var ContextProvider = ({
   children,
   initialTheme,
@@ -22034,6 +24005,14 @@ var ContextProvider = ({
   getAuthorizationToken = async () => "",
   eventTracking = null
 }) => {
+  const cacheCabByTypeRef = useRef({});
+  const getCacheCab = useCallback((storageType) => {
+    const key = storageType === "idb" ? "idb" : "memory";
+    if (!cacheCabByTypeRef.current[key]) {
+      cacheCabByTypeRef.current[key] = new CacheCab({ storageType: key });
+    }
+    return cacheCabByTypeRef.current[key];
+  }, []);
   const [client, setClient] = useState(
     typeof window !== "undefined" && sessionStorage ? JSON.parse(sessionStorage.getItem("quill-client") ?? "null") : null
   );
@@ -22096,6 +24075,7 @@ var ContextProvider = ({
     reportFiltersReducer,
     {}
   );
+  const [customFiltersLoaded, setCustomFiltersLoaded] = useState(false);
   const reportFilterOptionsAbortControllers = useRef({});
   const [reports, reportsDispatch] = useReducer(reportsReducer, {});
   const [reportsLoadingState, reportsLoadingStateDispatch] = useReducer(
@@ -22119,6 +24099,11 @@ var ContextProvider = ({
   const viewerTenantsByOwnerRequests = useRef(/* @__PURE__ */ new Set());
   const mappedTenantsRequests = useRef(/* @__PURE__ */ new Set());
   const loadDashboardProcessId = useRef({});
+  useEffect(() => {
+    if (Object.keys(customReportFilters).length) {
+      setCustomFiltersLoaded(true);
+    }
+  }, [customReportFilters]);
   useEffect(() => {
     if (!theme) {
       const populatedTheme = {
@@ -22887,6 +24872,7 @@ var ContextProvider = ({
           ...dashboard2,
           dateFilter: dashboard2.dateFilter ? {
             ...dashboard2.dateFilter,
+            initialCacheDateRange: dashboard2.initialCacheDateRange ? { ...dashboard2.initialCacheDateRange } : void 0,
             presetOptions: dashboard2.dateFilter.presetOptions?.map(
               (preset) => ({
                 ...preset,
@@ -23229,6 +25215,7 @@ var ContextProvider = ({
         ...dashboard2,
         dateFilter: dashboard2.dateFilter ? {
           ...dashboard2.dateFilter,
+          initialCacheDateRange: dashboard2.initialCacheDateRange ? { ...dashboard2.initialCacheDateRange } : void 0,
           presetOptions: dashboard2.dateFilter.presetOptions?.map(
             (preset) => ({
               ...preset,
@@ -23273,6 +25260,7 @@ var ContextProvider = ({
         if (dashboard2.dateFilter) {
           dashboard2.dateFilter = {
             ...dashboard2.dateFilter,
+            initialCacheDateRange: dashboard2.initialCacheDateRange ? { ...dashboard2.initialCacheDateRange } : void 0,
             startDate: presetOptions.find(
               (elem) => elem.value === dashboard2.dateFilter.primaryRange?.value
             )?.startDate,
@@ -23541,7 +25529,7 @@ var ContextProvider = ({
   if (!theme) {
     return null;
   }
-  return /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx(CacheCabContext.Provider, { value: { getCacheCab }, children: /* @__PURE__ */ jsx(
     ClientContext.Provider,
     {
       value: [
@@ -23582,7 +25570,9 @@ var ContextProvider = ({
                         reportFiltersDispatch,
                         customReportFiltersDispatch,
                         loadFiltersForReport,
-                        abortLoadingFilters
+                        abortLoadingFilters,
+                        customFiltersLoaded,
+                        setCustomFiltersLoaded
                       },
                       children: /* @__PURE__ */ jsx(
                         ReportsContext.Provider,
@@ -23625,7 +25615,7 @@ var ContextProvider = ({
         }
       ) })
     }
-  );
+  ) });
 };
 
 // src/hooks/useExport.tsx
@@ -23644,12 +25634,12 @@ init_filterProcessing();
 init_columnType();
 import {
   add,
-  startOfDay as startOfDay3,
-  startOfMonth as startOfMonth2,
-  startOfWeek as startOfWeek3,
-  startOfYear
+  startOfDay as startOfDay5,
+  startOfMonth as startOfMonth3,
+  startOfWeek as startOfWeek4,
+  startOfYear as startOfYear2
 } from "date-fns";
-import { utcToZonedTime as utcToZonedTime2 } from "date-fns-tz";
+import { utcToZonedTime as utcToZonedTime3 } from "date-fns-tz";
 function mergeComparisonRange(resp) {
   if (resp.chartType === "table") return resp;
   const compRows = resp.compareRows;
@@ -23692,6 +25682,18 @@ var useDashboardInternal = (dashboardName, customFilters) => {
       (f) => f.filter
     ) : null;
   }, [dashboardFilters, dashboardName]);
+  const getExistingDateFilter = useMemo2(
+    () => (name2) => {
+      if (!name2) return void 0;
+      const filtersForDashboard = dashboardFilters[name2];
+      if (!filtersForDashboard) return void 0;
+      const entry = Object.values(filtersForDashboard).find(
+        (f) => f?.filter?.filterType === "date_range" /* Date */
+      );
+      return entry?.filter;
+    },
+    [dashboardFilters]
+  );
   useEffect2(() => {
     if (!dashboardName) return;
     if (backfilledDashboards.current.has(dashboardName)) return;
@@ -23729,7 +25731,7 @@ var useDashboardInternal = (dashboardName, customFilters) => {
       customFilters
     );
   }, [dashboardName, loading, dashboardConfig, dashboardFilters]);
-  const handleReload = async (overrideDashboardName, fetchFromServer = false, reportAction, overrideFilters) => {
+  const handleReload = async (overrideDashboardName, fetchFromServer = false, reportAction, overrideFilters, options) => {
     if (!dashboardName) return;
     if (overrideFilters) {
       const dateFilter2 = overrideFilters.filters.find(
@@ -23782,10 +25784,19 @@ var useDashboardInternal = (dashboardName, customFilters) => {
       Object.values(dashboard?.sections ?? {}).flat(),
       dashboardName
     ) : void 0;
+    const existingDateFilter = options?.preserveExistingDateFilter ? getExistingDateFilter(dashboardName) : void 0;
+    const mergedDateFilter = dateFilter && existingDateFilter ? {
+      ...dateFilter,
+      startDate: existingDateFilter.startDate ?? dateFilter.startDate,
+      endDate: existingDateFilter.endDate ?? dateFilter.endDate,
+      preset: existingDateFilter.preset ?? dateFilter.preset,
+      primaryRange: existingDateFilter.primaryRange ?? dateFilter.primaryRange,
+      comparisonRange: existingDateFilter.comparisonRange ?? dateFilter.comparisonRange
+    } : dateFilter ?? existingDateFilter;
     loadFiltersForDashboard(
       dashboardName,
       [
-        ...dateFilter ? [dateFilter] : [],
+        ...mergedDateFilter ? [mergedDateFilter] : [],
         ...updatedDashboard?.filters?.map((filter) => ({
           ...filter,
           query: void 0
@@ -24070,7 +26081,8 @@ var useDashboards = () => {
     tenantFilters,
     dateFilter,
     customFilters,
-    tenantKeys
+    tenantKeys,
+    initialCacheDateRange
   }) => {
     if (!client) return;
     if (tenantKeys?.some((key) => !key)) {
@@ -24091,6 +26103,7 @@ var useDashboards = () => {
       filters,
       tenantFilters,
       dateFilter: dateFilter ?? null,
+      initialCacheDateRange,
       name: name2.trim(),
       task: "edit-dashboard",
       clientId: client.clientId,
@@ -24302,7 +26315,9 @@ var useDashboards = () => {
   };
 };
 var useDashboard = (dashboardName, config) => {
+  const logCacheStatistics = config?.showCacheLogs || false;
   const { data, dashboardFilters, reload, isLoading } = useDashboardInternal(dashboardName);
+  const [lastUpdated, setLastUpdated] = useState2(0);
   const { customFilterDispatch } = useContext(DashboardFiltersContext);
   const { reportsDispatch, reportsLoadingStateDispatch } = useContext(ReportsContext);
   const initialLoad = useRef2(true);
@@ -24311,15 +26326,19 @@ var useDashboard = (dashboardName, config) => {
   const [client] = useContext(ClientContext);
   const { tenants, flags } = useContext(TenantContext);
   const { getToken } = useContext(FetchContext);
-  const { customReportFilters } = useContext(ReportFiltersContext);
+  const { customReportFilters, customFiltersLoaded, setCustomFiltersLoaded } = useContext(ReportFiltersContext);
   const { eventTracking } = useContext(EventTrackingContext);
-  const customFiltersRef = useRef2(customReportFilters);
+  const { getCacheCab } = useContext(CacheCabContext);
   const reportRequestIds = useRef2({});
   const lastDashboardName = useRef2(null);
   const pendingNameChangeReload = useRef2(false);
-  useEffect2(() => {
-    customFiltersRef.current = customReportFilters;
-  }, [customReportFilters]);
+  const [loadedDashes, setLoadedDashes] = useState2([]);
+  const [lastUpdatedDict, setLastUpdatedDict] = useState2({});
+  const cacheEnabled = config?.cacheEnabled ?? true;
+  const cacheCab = useMemo2(
+    () => getCacheCab(config?.cacheType),
+    [getCacheCab, config?.cacheType]
+  );
   useEffect2(() => {
     const nameChanged = dashboardName !== lastDashboardName.current;
     if (nameChanged) {
@@ -24329,19 +26348,29 @@ var useDashboard = (dashboardName, config) => {
       backfilledDashboards.current = false;
       reportRequestIds.current = {};
       pendingNameChangeReload.current = true;
+      if (customFiltersLoaded && !loadedDashes.includes(dashboardName)) {
+        setCustomFiltersLoaded(false);
+      }
+      setLastUpdated(lastUpdatedDict[dashboardName] || 0);
     }
     if (!dashboardName) return;
     if (pendingNameChangeReload.current && data) {
       pendingNameChangeReload.current = false;
       initialLoad.current = false;
+      fetchedInitialReports.current = false;
       return;
     }
     if (pendingNameChangeReload.current && !isLoading && !data && initialLoad.current) {
       initialLoad.current = false;
       pendingNameChangeReload.current = false;
-      reload();
+      reload(dashboardName, false, void 0, void 0, {
+        preserveExistingDateFilter: true
+      });
     }
   }, [isLoading, data, dashboardName]);
+  useEffect2(() => {
+    setLastUpdated(lastUpdatedDict[dashboardName] || 0);
+  }, [lastUpdatedDict, dashboardName]);
   useEffect2(() => {
     if (backfilledDashboards.current) return;
     if (isLoading || !data) return;
@@ -24350,7 +26379,9 @@ var useDashboard = (dashboardName, config) => {
     );
     if (!needsBackfill) return;
     backfilledDashboards.current = true;
-    reload(dashboardName, false);
+    reload(dashboardName, false, void 0, void 0, {
+      preserveExistingDateFilter: true
+    });
   }, [isLoading, data, dashboardFilters, dashboardName]);
   const { allReportsById } = useAllReports();
   const sections = useMemo2(() => {
@@ -24374,7 +26405,13 @@ var useDashboard = (dashboardName, config) => {
       fetchedInitialReports.current = true;
       fetchReports([], dashboardFilters ?? [], config?.pageSize);
     }
-  }, [fetchedInitialReports, data, dashboardFilters]);
+  }, [fetchedInitialReports, data, dashboardFilters, customFiltersLoaded]);
+  useEffect2(() => {
+    if (customFiltersLoaded && data && dashboardFilters !== null) {
+      fetchedInitialReports.current = true;
+      fetchReports([], dashboardFilters ?? [], config?.pageSize);
+    }
+  }, [customFiltersLoaded]);
   const applyDashboardFilters = (filtersToUpdate) => {
     const newFilters = (dashboardFilters ?? []).map((f) => {
       const update = filtersToUpdate.find((u) => u.label === f.label);
@@ -24453,7 +26490,7 @@ var useDashboard = (dashboardName, config) => {
     });
     return internalFilters;
   };
-  const isFilter = (f) => {
+  const isFilter2 = (f) => {
     return f && typeof f === "object" && "filterType" in f && !("id" in f);
   };
   const isDashboardFilter = (f) => {
@@ -24461,29 +26498,22 @@ var useDashboard = (dashboardName, config) => {
   };
   const applyFilters = (filters2) => {
     const dashboardFilters2 = filters2.filter(isDashboardFilter);
-    const customFilters = filters2.filter(isFilter);
+    const customFilters = filters2.filter(isFilter2);
     const newCustomFilters = applyCustomFilters(customFilters);
     const newDashboardFilters = applyDashboardFilters(dashboardFilters2);
     fetchReports(newCustomFilters, newDashboardFilters);
   };
-  const waitForCustomFilters = async (reportId) => {
-    let attempts = 0;
-    const maxAttempts = 10;
-    while (attempts < maxAttempts) {
-      const filters2 = customFiltersRef.current[reportId];
-      if (filters2 && filters2.length > 0) {
-        return filters2;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      attempts++;
-    }
-    return [];
+  const forceCacheRefresh = () => {
+    if (!cacheEnabled) return;
+    fetchReports([], dashboardFilters ?? [], config?.pageSize, true);
   };
-  const fetchReports = async (customFilters, dashboardFilters2, pageSize) => {
+  const fetchReports = async (customFilters, dashboardFilters2, pageSize, forceCacheToRefresh = false) => {
     if (!client || !sections) return;
     const allReports = Object.values(sections).flat();
+    const fetchStartTime = Date.now();
+    let totalCached = 0;
     await Promise.all(
-      allReports.map(async (reportInfo) => {
+      allReports.map(async (reportInfo, idx) => {
         const reportId = reportInfo.id;
         const requestId = (reportRequestIds.current[reportId] ?? 0) + 1;
         reportRequestIds.current[reportId] = requestId;
@@ -24492,7 +26522,7 @@ var useDashboard = (dashboardName, config) => {
           id: reportId,
           data: true
         });
-        const customReportFiltersArray = await waitForCustomFilters(reportId);
+        const customReportFiltersArray = customReportFilters[reportId] ?? [];
         let rowsPerRequest = pageSize || 600;
         if (!pageSize && (reportInfo.chartType === "table" || reportInfo.chartType === "metric")) {
           rowsPerRequest = 10;
@@ -24504,17 +26534,162 @@ var useDashboard = (dashboardName, config) => {
         const additionalProcessing = {
           page: pagination
         };
-        const usePivotTask = !!reportInfo.pivot;
+        const usePivotTask = !cacheEnabled && !!reportInfo.pivot;
+        const allFilters = dashboardFilters2.concat(customFilters).concat(customReportFiltersArray);
+        const applyInMemoryPivotIfNeeded = (report2) => {
+          const pivotToApply = reportInfo.pivot ?? report2.pivot;
+          if (!pivotToApply || usePivotTask) {
+            return report2;
+          }
+          const pivotRows = applyPivotInMemory(
+            report2.rows ?? [],
+            pivotToApply,
+            allFilters
+          );
+          const pivotColumns = generatePivotColumnsInMemory({
+            pivot: pivotToApply,
+            pivotRows,
+            sourceColumns: report2.columnInternal ?? report2.columns
+          });
+          return {
+            ...report2,
+            pivot: pivotToApply,
+            pivotRows,
+            pivotColumns: pivotColumns ?? report2.pivotColumns,
+            pivotRowCount: pivotRows.length
+          };
+        };
+        if (cacheEnabled && cacheCab.isCacheable(reportId)) {
+          const report2 = await cacheCab.get(reportId, dashboardFilters2, customFilters.concat(customReportFiltersArray), reportInfo.pivot, client, tenants, flags, pageSize, getToken, eventTracking, forceCacheToRefresh);
+          if (reportRequestIds.current[reportId] !== requestId) {
+            return null;
+          }
+          if (cacheCab.isCacheable(reportId)) {
+            reportsDispatch({
+              type: "UPDATE_REPORT",
+              id: reportId,
+              data: {
+                ...report2,
+                pagination,
+                triggerReload: false
+              }
+            });
+            reportsLoadingStateDispatch({
+              type: "SET_REPORT_LOADING",
+              id: reportId,
+              data: false
+            });
+            totalCached += 1;
+            return report2;
+          }
+        }
+        if (cacheEnabled && !cacheCab.isCacheable(reportId)) {
+          try {
+            const { report: uncacheableReport, fromCache } = await cacheCab.getOrFetchUncacheableResult(
+              reportId,
+              client,
+              tenants,
+              flags,
+              allFilters,
+              additionalProcessing,
+              reportInfo.pivot,
+              async () => {
+                const { report: report2, error: error2 } = await fetchReport({
+                  reportId,
+                  client,
+                  tenants,
+                  flags,
+                  additionalProcessing,
+                  filters: allFilters,
+                  getToken,
+                  eventTracking,
+                  usePivotTask,
+                  overwriteCache: forceCacheToRefresh
+                });
+                if (error2 || !report2) {
+                  throw error2 ?? new Error("Failed to fetch uncacheable report");
+                }
+                return report2;
+              },
+              forceCacheToRefresh
+            );
+            if (reportRequestIds.current[reportId] !== requestId) {
+              return null;
+            }
+            const uncacheableReportWithPivot = applyInMemoryPivotIfNeeded(uncacheableReport);
+            reportsDispatch({
+              type: "UPDATE_REPORT",
+              id: reportId,
+              data: {
+                ...uncacheableReportWithPivot,
+                pagination,
+                triggerReload: false
+              }
+            });
+            reportsLoadingStateDispatch({
+              type: "SET_REPORT_LOADING",
+              id: reportId,
+              data: false
+            });
+            if (fromCache) {
+              totalCached += 1;
+            }
+            if (usePivotTask) {
+              fetchReportRows({
+                reportId,
+                client,
+                tenants,
+                filters: allFilters,
+                getToken,
+                additionalProcessing,
+                overwriteCache: forceCacheToRefresh
+              }).then(({ rows, rowCount, columns, fields }) => {
+                if (reportRequestIds.current[reportId] !== requestId) {
+                  return;
+                }
+                reportsDispatch({
+                  type: "UPDATE_REPORT",
+                  id: reportId,
+                  data: {
+                    rows,
+                    rowCount,
+                    columnInternal: columns,
+                    columns: columns.map((col) => ({
+                      field: col.field,
+                      format: col.format,
+                      label: col.label,
+                      inferFormat: col.inferFormat
+                    })),
+                    // @ts-ignore fields is not typed on QuillReportInternal
+                    fields,
+                    triggerReload: false
+                  }
+                });
+              }).catch((e) => {
+                if (e instanceof Error && e.name === "AbortError") {
+                  return;
+                }
+                console.error("Failed to fetch background rows", e);
+              });
+            }
+            return uncacheableReportWithPivot;
+          } catch (error2) {
+            console.error(error2);
+            return null;
+          }
+        }
         const { report, error } = await fetchReport({
           reportId,
           client,
           tenants,
           flags,
           additionalProcessing,
-          filters: dashboardFilters2.concat(customFilters).concat(customReportFiltersArray),
+          filters: allFilters,
           getToken,
           eventTracking,
-          usePivotTask
+          usePivotTask,
+          overwriteCache: forceCacheToRefresh
+          // usePivotTask: false,
         });
         if (error) {
           console.error(error);
@@ -24542,9 +26717,10 @@ var useDashboard = (dashboardName, config) => {
             reportId,
             client,
             tenants,
-            filters: dashboardFilters2.concat(customFilters).concat(customReportFiltersArray),
+            filters: allFilters,
             getToken,
-            additionalProcessing
+            additionalProcessing,
+            overwriteCache: forceCacheToRefresh
           }).then(({ rows, rowCount, columns, fields }) => {
             if (reportRequestIds.current[reportId] !== requestId) {
               return;
@@ -24568,19 +26744,30 @@ var useDashboard = (dashboardName, config) => {
               }
             });
           }).catch((e) => {
-            if (e instanceof Error && e.name === "AbortError") return;
+            if (e instanceof Error && e.name === "AbortError") {
+              return;
+            }
             console.error("Failed to fetch background rows", e);
           });
         }
         return report;
       })
     );
+    if (!loadedDashes.includes(dashboardName) || !cacheEnabled || forceCacheToRefresh) {
+      setLoadedDashes((prev) => prev.includes(dashboardName) ? prev : [...prev, dashboardName]);
+      setLastUpdatedDict((prev) => ({ ...prev, [dashboardName]: Date.now() }));
+    }
+    if (logCacheStatistics) {
+      console.log(`Dashboard "${dashboardName}": Cache Rate: ${(100 * totalCached / allReports.length).toFixed(1)}%, load time: ${((Date.now() - fetchStartTime) / 1e3).toFixed(2)} secs`);
+    }
   };
   return {
     isLoading: !!isLoading || !sections,
     sections: isLoading ? null : sections,
     filters,
-    applyFilters
+    applyFilters,
+    lastUpdated,
+    forceCacheRefresh
   };
 };
 var useDashboardReportInternal = (reportId, config) => {
@@ -24604,15 +26791,6 @@ var useDashboardReportInternal = (reportId, config) => {
   } = useDashboardInternal(reports[reportId]?.dashboardName ?? null);
   const [pageLoading, setPageLoading] = useState2(false);
   const [maxPage, setMaxPage] = useState2(0);
-  useEffect2(() => {
-    if (config?.initialFilters) {
-      customReportFiltersDispatch({
-        type: "ADD_CUSTOM_REPORT_FILTERS",
-        reportId,
-        data: config.initialFilters.map(convertCustomFilter)
-      });
-    }
-  }, []);
   const processedReport = useMemo2(() => {
     if (!reports[reportId]) return null;
     const dashboardName = reports[reportId].dashboardName;
@@ -24817,6 +26995,7 @@ var useDashboardReportInternal = (reportId, config) => {
 };
 var useDashboardReport = (reportId, config) => {
   const { report, loading, applyFilters, deleteReport, nextPage } = useDashboardReportInternal(reportId, config);
+  const { customReportFiltersDispatch } = useContext(ReportFiltersContext);
   const fetchingRef = useRef2(false);
   const fetchNextPage = async () => {
     if (fetchingRef.current) {
@@ -24831,6 +27010,15 @@ var useDashboardReport = (reportId, config) => {
       fetchingRef.current = false;
     }
   };
+  useEffect2(() => {
+    if (config?.initialFilters) {
+      customReportFiltersDispatch({
+        type: "ADD_CUSTOM_REPORT_FILTERS",
+        reportId,
+        data: config.initialFilters.map(convertCustomFilter)
+      });
+    }
+  }, []);
   return {
     report,
     isLoading: loading || fetchingRef.current,
@@ -27995,19 +30183,23 @@ var RenderLegend = ({
   const seeAllMeasureRef = useRef5(null);
   const seeAllTriggerRef = useRef5(null);
   const itemRefs = useRef5([]);
-  if (!payload || payload.length === 0) return null;
-  const maxItems = limit ?? payload.length;
+  const safePayload = payload ?? [];
+  const maxItems = limit ?? safePayload.length;
   const measuredLimit = visibleCount ?? maxItems;
-  const visiblePayload = payload.slice(0, Math.min(maxItems, measuredLimit));
+  const visiblePayload = safePayload.slice(0, Math.min(maxItems, measuredLimit));
   const handleOpen = () => setIsOpen(true);
   const handleClose = () => setIsOpen(false);
   useLayoutEffect2(() => {
     if (!containerRef.current) return;
-    if (!payload.length) return;
+    if (!safePayload.length) {
+      setShowSeeAll(false);
+      setVisibleCount(null);
+      return;
+    }
     const updateVisibleCount = () => {
       const containerWidth = containerRef.current?.offsetWidth ?? 0;
       if (!containerWidth) return;
-      const maxCount = Math.min(maxItems, payload.length);
+      const maxCount = Math.min(maxItems, safePayload.length);
       const seeAllWidth = getOuterWidth(seeAllMeasureRef.current);
       const computeCount = (reserveSeeAll) => {
         const availableWidth = containerWidth - (reserveSeeAll ? seeAllWidth : 0);
@@ -28023,7 +30215,7 @@ var RenderLegend = ({
         return Math.max(1, nextCount);
       };
       const countWithSeeAll = computeCount(true);
-      const shouldShowSeeAll = payload.length > countWithSeeAll;
+      const shouldShowSeeAll = safePayload.length > countWithSeeAll;
       const finalCount = shouldShowSeeAll ? countWithSeeAll : computeCount(false);
       setShowSeeAll(shouldShowSeeAll);
       setVisibleCount(finalCount);
@@ -28032,7 +30224,8 @@ var RenderLegend = ({
     const observer = new ResizeObserver(updateVisibleCount);
     observer.observe(containerRef.current);
     return () => observer.disconnect();
-  }, [payload.length, maxItems]);
+  }, [safePayload.length, maxItems]);
+  if (!safePayload.length) return null;
   return /* @__PURE__ */ jsxs19(
     "div",
     {
@@ -28072,7 +30265,7 @@ var RenderLegend = ({
                     justifyContent: "flex-start",
                     flexWrap: "nowrap"
                   },
-                  children: payload.slice(0, maxItems).map((entry, index) => /* @__PURE__ */ jsx27(
+                  children: safePayload.slice(0, maxItems).map((entry, index) => /* @__PURE__ */ jsx27(
                     "div",
                     {
                       ref: (element) => {
@@ -28161,7 +30354,7 @@ var RenderLegend = ({
                   maxWidth: 520,
                   gap: "0.5rem"
                 },
-                children: payload.map((entry, index) => /* @__PURE__ */ jsx27(
+                children: safePayload.map((entry, index) => /* @__PURE__ */ jsx27(
                   LegendItem,
                   {
                     entry,
@@ -28511,8 +30704,8 @@ var PieChartWrapper = React4.forwardRef(
                   cy: "50%",
                   startAngle: 90,
                   endAngle: -270,
-                  innerRadius: isDonut ? showLegend ? "50%" : "70%" : "0%",
-                  outerRadius: showLegend ? "70%" : "100%",
+                  innerRadius: isDonut ? "70%" : "0%",
+                  outerRadius: "100%",
                   paddingAngle: 0,
                   dataKey: category,
                   nameKey: index,
@@ -29115,8 +31308,8 @@ import {
 } from "recharts";
 
 // src/utils/axisFormatter.ts
-import { endOfWeek as endOfWeek2, format as format5, getWeek as getWeek2, isValid as isValid4, startOfWeek as startOfWeek4 } from "date-fns";
-import { utcToZonedTime as utcToZonedTime3 } from "date-fns-tz";
+import { endOfWeek as endOfWeek2, format as format5, getWeek as getWeek2, isValid as isValid5, startOfWeek as startOfWeek5 } from "date-fns";
+import { utcToZonedTime as utcToZonedTime4 } from "date-fns-tz";
 var axisFormatter = ({ value, field, fields }) => {
   if (field === void 0 || field === null) return "";
   if (value === void 0 || value === null) return "";
@@ -29232,8 +31425,8 @@ var formatPercent2 = (value) => {
   return formatter.format(Number(value));
 };
 var _getUTCDateHelper2 = (value, fmt) => {
-  const utcDate = utcToZonedTime3(new Date(value), "UTC");
-  if (!isValid4(utcDate)) return "Invalid date";
+  const utcDate = utcToZonedTime4(new Date(value), "UTC");
+  if (!isValid5(utcDate)) return "Invalid date";
   return format5(utcDate, fmt);
 };
 var format_YYYY2 = (value) => _getUTCDateHelper2(value, "yyyy");
@@ -29242,9 +31435,9 @@ var format_MMM_yyyy2 = (value) => _getUTCDateHelper2(value, "MMM yyyy");
 var format_hh_ap_pm2 = (value) => _getUTCDateHelper2(value, "hh:mm aa");
 var format_MMM_dd_yyyy2 = (value) => _getUTCDateHelper2(value, "dd MMM yyyy");
 var format_MMM_dd_MMM_dd = (value) => {
-  const utcDate = utcToZonedTime3(new Date(value), "UTC");
-  if (!isValid4(utcDate)) return "Invalid date";
-  const monday = startOfWeek4(utcDate, { weekStartsOn: 1 });
+  const utcDate = utcToZonedTime4(new Date(value), "UTC");
+  if (!isValid5(utcDate)) return "Invalid date";
+  const monday = startOfWeek5(utcDate, { weekStartsOn: 1 });
   const sunday = endOfWeek2(utcDate, { weekStartsOn: 1 });
   if (format5(monday, "MMM") === format5(sunday, "MMM")) {
     return `${format5(monday, "MMM dd")} - ${format5(sunday, "dd")}`;
@@ -29253,20 +31446,20 @@ var format_MMM_dd_MMM_dd = (value) => {
   }
 };
 var format_MMM_dd_hh_mm_ap_pm2 = (value) => {
-  const utcDate = utcToZonedTime3(new Date(value), "UTC");
-  if (!isValid4(utcDate)) return "Invalid date";
+  const utcDate = utcToZonedTime4(new Date(value), "UTC");
+  if (!isValid5(utcDate)) return "Invalid date";
   const formatStr = utcDate.getMinutes() === 0 ? "MMM do h a" : "MMM do h:mm a";
   const res = format5(utcDate, formatStr);
   return res.slice(0, -2) + res.slice(-2).toLowerCase();
 };
 var format_wo_yyyy2 = (value) => {
-  const utcDate = utcToZonedTime3(new Date(value), "UTC");
-  if (!isValid4(utcDate)) return "Invalid date";
+  const utcDate = utcToZonedTime4(new Date(value), "UTC");
+  if (!isValid5(utcDate)) return "Invalid date";
   return `${getWeek2(utcDate)},${utcDate.getFullYear()}`;
 };
 
 // src/components/Chart/ChartTooltip.tsx
-import { format as format6, subDays as subDays2 } from "date-fns";
+import { format as format6, subDays as subDays3 } from "date-fns";
 
 // src/components/Chart/ChartTooltipFrame.tsx
 import { jsx as jsx30 } from "react/jsx-runtime";
@@ -29510,7 +31703,7 @@ function reformatComparisonPayload(props, primaryLabel, comparisonLabel) {
       const nameKey = isComparison ? `comparison_${props.xAxisField}` : props.xAxisField;
       const days = LABEL_TO_DAYS[primaryLabel] ?? 0;
       const primaryDate = item.payload[props.xAxisField] ?? 0;
-      const compDate = subDays2(new Date(primaryDate), days + 1);
+      const compDate = subDays3(new Date(primaryDate), days + 1);
       const date = item.payload[nameKey] ?? format6(compDate, props.xAxisFormat);
       const name2 = props.dateFormatter(date);
       const color2 = item.color;
@@ -30576,16 +32769,16 @@ import {
   useState as useState12
 } from "react";
 import {
-  startOfMonth as startOfMonth3,
+  startOfMonth as startOfMonth4,
   endOfMonth as endOfMonth2,
   format as format7,
   eachDayOfInterval,
-  subMonths as subMonths3,
-  startOfWeek as startOfWeek5,
+  subMonths as subMonths5,
+  startOfWeek as startOfWeek6,
   endOfWeek as endOfWeek3,
   differenceInDays as differenceInDays3,
-  startOfDay as startOfDay4,
-  addMonths,
+  startOfDay as startOfDay6,
+  addMonths as addMonths2,
   isBefore as isBefore2,
   isAfter as isAfter2
 } from "date-fns";
@@ -31110,20 +33303,20 @@ function CalendarRow({
   setLocalPreset
 }) {
   const firstMonthDisplayedDates = eachDayOfInterval({
-    start: startOfWeek5(anchorStartDate),
+    start: startOfWeek6(anchorStartDate),
     end: endOfWeek3(endOfMonth2(anchorStartDate))
   });
   const secondMonthDisplayedDates = eachDayOfInterval({
-    start: startOfWeek5(startOfMonth3(anchorEndDate)),
+    start: startOfWeek6(startOfMonth4(anchorEndDate)),
     end: endOfWeek3(anchorEndDate)
   });
   const incrementAnchorDates = () => {
-    setAnchorStartDate(startOfMonth3(addMonths(anchorStartDate, 1)));
-    setAnchorEndDate(endOfMonth2(addMonths(anchorEndDate, 1)));
+    setAnchorStartDate(startOfMonth4(addMonths2(anchorStartDate, 1)));
+    setAnchorEndDate(endOfMonth2(addMonths2(anchorEndDate, 1)));
   };
   const decrementAnchorDates = () => {
-    setAnchorStartDate(startOfMonth3(subMonths3(anchorStartDate, 1)));
-    setAnchorEndDate(endOfMonth2(subMonths3(anchorEndDate, 1)));
+    setAnchorStartDate(startOfMonth4(subMonths5(anchorStartDate, 1)));
+    setAnchorEndDate(endOfMonth2(subMonths5(anchorEndDate, 1)));
   };
   return /* @__PURE__ */ jsx40("div", { style: { position: "absolute", zIndex: 100, marginTop: 12 }, children: /* @__PURE__ */ jsxs30(
     "div",
@@ -31377,10 +33570,10 @@ function DayPicker({
   setLocalPreset,
   theme
 }) {
-  const isStartDate = differenceInDays3(startOfDay4(date), startOfDay4(localStartDate || 0)) === 0;
-  const isEndDate = differenceInDays3(startOfDay4(date), startOfDay4(localEndDate || 0)) === 0;
+  const isStartDate = differenceInDays3(startOfDay6(date), startOfDay6(localStartDate || 0)) === 0;
+  const isEndDate = differenceInDays3(startOfDay6(date), startOfDay6(localEndDate || 0)) === 0;
   const isBetweenStartAndEnd = isBefore2(date, localEndDate || 0) && isAfter2(date, localStartDate || 0);
-  const isBeginningOfWeek = differenceInDays3(startOfWeek5(date), date) === 0;
+  const isBeginningOfWeek = differenceInDays3(startOfWeek6(date), date) === 0;
   const isEndOfWeek = differenceInDays3(endOfWeek3(date), date) === 0;
   return /* @__PURE__ */ jsx40(
     "button",
@@ -31429,7 +33622,7 @@ function DayPicker({
           });
           setLocalPreset("");
         }
-        if (localStartDate && localEndDate && differenceInDays3(startOfDay4(date), startOfDay4(localStartDate)) === 0) {
+        if (localStartDate && localEndDate && differenceInDays3(startOfDay6(date), startOfDay6(localStartDate)) === 0) {
           setLocalStartDate(void 0);
           setLocalEndDate(void 0);
         }
@@ -31440,16 +33633,16 @@ function DayPicker({
 }
 function getAnchorStartDate(startDate, endDate) {
   if (!startDate && !endDate) {
-    return startOfMonth3(subMonths3(/* @__PURE__ */ new Date(), 1));
+    return startOfMonth4(subMonths5(/* @__PURE__ */ new Date(), 1));
   }
   if (startDate && !endDate) {
-    return startOfMonth3(startDate);
+    return startOfMonth4(startDate);
   }
   if (!startDate && endDate) {
-    return startOfMonth3(subMonths3(endDate, 1));
+    return startOfMonth4(subMonths5(endDate, 1));
   }
   if (startDate && endDate) {
-    return startOfMonth3(startDate);
+    return startOfMonth4(startDate);
   }
   return /* @__PURE__ */ new Date();
 }
@@ -31458,13 +33651,13 @@ function getAnchorEndDate(startDate, endDate) {
     return endOfMonth2(/* @__PURE__ */ new Date());
   }
   if (startDate && !endDate) {
-    return endOfMonth2(addMonths(startDate, 1));
+    return endOfMonth2(addMonths2(startDate, 1));
   }
   if (!startDate && endDate) {
     return endOfMonth2(endDate);
   }
   if (startDate && endDate) {
-    return endOfMonth2(addMonths(startDate, 1));
+    return endOfMonth2(addMonths2(startDate, 1));
   }
   return /* @__PURE__ */ new Date();
 }
@@ -32659,6 +34852,164 @@ function DashboardFilter2({
 // src/Chart.tsx
 init_paginationProcessing();
 
+// src/utils/cloudCacheValidation.ts
+var LIMIT_CLAUSE_REGEX = /^limit\b\s+(?:all|\d+|\$\d+|:[a-zA-Z_][a-zA-Z0-9_]*|\?)/i;
+var SQL_CONTENT_TO_IGNORE_REGEX = /'(?:''|[^'])*'|"(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|--[^\n]*|\/\*[\s\S]*?\*\//g;
+function isWordChar(char) {
+  if (!char) {
+    return false;
+  }
+  return /[A-Za-z0-9_]/.test(char);
+}
+function getFinalSqlStatement(query) {
+  const statements = query.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+  return statements[statements.length - 1] ?? "";
+}
+function hasTopLevelLimitClause(statement) {
+  let depth = 0;
+  for (let i = 0; i < statement.length; i += 1) {
+    const char = statement[i];
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth !== 0) {
+      continue;
+    }
+    const previousChar = i > 0 ? statement[i - 1] : void 0;
+    if (isWordChar(previousChar)) {
+      continue;
+    }
+    if (!LIMIT_CLAUSE_REGEX.test(statement.slice(i))) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function unwrapIdentifier(identifier) {
+  if (!identifier) {
+    return "";
+  }
+  const trimmed = identifier.trim();
+  if (trimmed.length < 2) {
+    return trimmed;
+  }
+  const startsAndEndsWithDoubleQuote = trimmed.startsWith('"') && trimmed.endsWith('"');
+  const startsAndEndsWithSingleQuote = trimmed.startsWith("'") && trimmed.endsWith("'");
+  const startsAndEndsWithBackticks = trimmed.startsWith("`") && trimmed.endsWith("`");
+  const startsAndEndsWithBrackets = trimmed.startsWith("[") && trimmed.endsWith("]");
+  if (startsAndEndsWithDoubleQuote || startsAndEndsWithSingleQuote || startsAndEndsWithBackticks || startsAndEndsWithBrackets) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function normalizeIdentifier(identifier) {
+  return unwrapIdentifier(identifier).toLowerCase();
+}
+function hasRowFieldWithIdentifier(row, normalizedField) {
+  if (!row || !normalizedField) {
+    return false;
+  }
+  return Object.keys(row).some(
+    (fieldName) => normalizeIdentifier(fieldName) === normalizedField
+  );
+}
+function reportReferencesField(report, field, table) {
+  const normalizedField = normalizeIdentifier(field);
+  if (!normalizedField) {
+    return false;
+  }
+  const referencedColumns = report?.referencedColumns ?? {};
+  let entries = Object.entries(referencedColumns);
+  if (entries.length === 0) {
+    return false;
+  }
+  const normalizedTable = normalizeIdentifier(table);
+  if (normalizedTable) {
+    entries = entries.filter(
+      ([tableName]) => normalizeIdentifier(tableName) === normalizedTable
+    );
+  }
+  const referencedFields = entries.flatMap(([, fields]) => fields ?? []);
+  if (referencedFields.length === 0) {
+    return false;
+  }
+  return referencedFields.some((referencedField) => {
+    const normalizedReferencedField = normalizeIdentifier(referencedField);
+    return normalizedReferencedField === normalizedField || normalizedReferencedField === "*";
+  });
+}
+function isDateFieldMissingInReport(report) {
+  if (!report?.dateField?.field || !report.dateField.table) {
+    return false;
+  }
+  const dateField = report.dateField;
+  if (!reportReferencesField(report, dateField.field, dateField.table)) {
+    return true;
+  }
+  const firstRow = report.rows?.[0];
+  if (!firstRow) {
+    return false;
+  }
+  const normalizedDateField = normalizeIdentifier(dateField.field);
+  const dateFieldExistsInFirstRow = hasRowFieldWithIdentifier(
+    firstRow,
+    normalizedDateField
+  );
+  return !dateFieldExistsInFirstRow;
+}
+function hasLimitClause(query) {
+  if (!query) {
+    return false;
+  }
+  const sanitizedQuery = query.replace(SQL_CONTENT_TO_IGNORE_REGEX, " ");
+  const finalStatement = getFinalSqlStatement(sanitizedQuery);
+  if (!finalStatement) {
+    return false;
+  }
+  return hasTopLevelLimitClause(finalStatement);
+}
+function reportUsesLimitClause(report) {
+  const queriesToInspect = report?.itemQuery && report.itemQuery.length > 0 ? report.itemQuery : report?.queryString ? [report.queryString] : [];
+  return queriesToInspect.some(hasLimitClause);
+}
+function getMissingDashboardFilterFields({
+  rows = [],
+  dashboardFilters = []
+}) {
+  const dateIndex = dashboardFilters.findIndex(
+    (filter) => filter.filterType === "date_range"
+  );
+  const requiredFields = dashboardFilters.flatMap((filter, index) => {
+    if (index === dateIndex || !filter.field) {
+      return [];
+    }
+    const normalizedField = normalizeIdentifier(filter.field);
+    if (!normalizedField) {
+      return [];
+    }
+    return [
+      {
+        displayField: unwrapIdentifier(filter.field),
+        normalizedField
+      }
+    ];
+  });
+  const dedupedRequiredFields = requiredFields.filter(
+    (field, index, fields) => fields.findIndex(
+      (candidate) => candidate.normalizedField === field.normalizedField
+    ) === index
+  );
+  return dedupedRequiredFields.filter(
+    ({ normalizedField }) => rows.some((row) => !hasRowFieldWithIdentifier(row, normalizedField))
+  ).map(({ displayField }) => displayField);
+}
+
 // src/components/Dashboard/MetricComponent.tsx
 init_dateRangePickerUtils();
 import { useContext as useContext12 } from "react";
@@ -32766,7 +35117,7 @@ function QuillMetricComponent({
                       width: "100%"
                     }
                   }
-                ) : !report?.rows || report?.rows?.length === 0 || report.rows[0]?.[report.xAxisField] === null || report.rows[0]?.[report.xAxisField] === void 0 ? /* @__PURE__ */ jsx44(
+                ) : !report?.rows || report?.rows?.length === 0 ? /* @__PURE__ */ jsx44(
                   "div",
                   {
                     style: {
@@ -36285,6 +38636,7 @@ function QuillTableDashboardComponent({
 }
 
 // src/Chart.tsx
+init_valueFormatter();
 import { Fragment as Fragment5, jsx as jsx49, jsxs as jsxs37 } from "react/jsx-runtime";
 var MAX_ROWS_FOR_GENERIC_TABLE = 500;
 function sumByKey(arr, key) {
@@ -36321,7 +38673,8 @@ function Chart({
   filters,
   onClickChartElement,
   dateBucket,
-  propagateChanges
+  propagateChanges,
+  isAdmin = false
 }) {
   const [schemaData] = useContext16(SchemaDataContext);
   const { reload } = useReportInternal(reportId);
@@ -36443,6 +38796,25 @@ function Chart({
     }
   }, [report, theme]);
   const [client, clientLoading] = useContext16(ClientContext);
+  const cloudCacheEnabled = useMemo13(() => {
+    return !!client?.features?.cloudCache;
+  }, [client]);
+  const shouldShowCloudCacheValidationErrors = isAdmin && cloudCacheEnabled;
+  const isMissingDateField = useMemo13(() => {
+    if (!shouldShowCloudCacheValidationErrors) return false;
+    return isDateFieldMissingInReport(report);
+  }, [report, shouldShowCloudCacheValidationErrors]);
+  const usesLimitInQuery = useMemo13(() => {
+    if (!shouldShowCloudCacheValidationErrors) return false;
+    return reportUsesLimitClause(report);
+  }, [report, shouldShowCloudCacheValidationErrors]);
+  const missingDashboardFilterFields = useMemo13(() => {
+    if (!shouldShowCloudCacheValidationErrors || !report) return [];
+    return getMissingDashboardFilterFields({
+      rows: report.rows,
+      dashboardFilters
+    });
+  }, [report, dashboardFilters, shouldShowCloudCacheValidationErrors]);
   const [error, setError] = useState19(void 0);
   const updateFilter = (filter, value, comparison) => {
     let filterValue = {};
@@ -36583,6 +38955,30 @@ function Chart({
   if (report?.error || error) {
     return /* @__PURE__ */ jsx49("div", { style: containerStyle, className, children: /* @__PURE__ */ jsx49(ChartError, { errorMessage: report?.error ?? error }) });
   }
+  if (isMissingDateField) {
+    return /* @__PURE__ */ jsx49("div", { style: containerStyle, className, children: /* @__PURE__ */ jsx49(
+      ChartError,
+      {
+        errorMessage: `The query for this report is missing dashboard date filter field ${report?.dateField?.field}, which is necessary for date filtering on this dashboard when the cache is enabled.`
+      }
+    ) });
+  }
+  if (usesLimitInQuery) {
+    return /* @__PURE__ */ jsx49("div", { style: containerStyle, className, children: /* @__PURE__ */ jsx49(
+      ChartError,
+      {
+        errorMessage: `The query for this report uses the LIMIT keyword, which is not supported when the cache is enabled.`
+      }
+    ) });
+  }
+  if (missingDashboardFilterFields.length) {
+    return /* @__PURE__ */ jsx49("div", { style: containerStyle, className, children: /* @__PURE__ */ jsx49(
+      ChartError,
+      {
+        errorMessage: `The query for this report is missing dashboard filter fields: ${missingDashboardFilterFields.join(", ")}`
+      }
+    ) });
+  }
   return /* @__PURE__ */ jsxs37(
     "div",
     {
@@ -36913,7 +39309,7 @@ var ChartDisplay = ({
     );
   }
   if (config?.chartType?.toLowerCase() === "metric") {
-    if (!config?.rows || config?.rows?.length === 0 || config?.rows[0]?.[config?.xAxisField] === null || config?.rows[0]?.[config?.xAxisField] === void 0) {
+    if (!config?.rows || config?.rows?.length === 0) {
       return /* @__PURE__ */ jsx49(
         "div",
         {
@@ -36951,6 +39347,36 @@ var ChartDisplay = ({
         }
       );
     }
+    if (config?.pivotRows && config?.pivotRows?.length > 0) {
+      return /* @__PURE__ */ jsx49(
+        "div",
+        {
+          style: {
+            fontFamily: theme?.fontFamily,
+            fontSize: 32,
+            color: theme?.primaryTextColor,
+            fontWeight: "600",
+            textOverflow: "ellipsis",
+            margin: 0,
+            whiteSpace: "nowrap",
+            boxSizing: "content-box",
+            maxWidth: "100%",
+            textAlign: "left",
+            overflow: "hidden",
+            height: containerStyle?.height || "100%",
+            display: "flex",
+            width: "100%",
+            flexDirection: "row",
+            ...containerStyle
+          },
+          className,
+          children: /* @__PURE__ */ jsx49(QuillMetricComponent, { report: config ?? EMPTY_REPORT, children: quillFormat({
+            value: config?.pivotRows?.[0]?.[config?.xAxisField],
+            format: config?.xAxisFormat
+          }) ?? "No results" })
+        }
+      );
+    }
     return /* @__PURE__ */ jsx49(
       "div",
       {
@@ -37899,7 +40325,7 @@ init_Filter();
 import { useState as useState22, useEffect as useEffect18, useMemo as useMemo15 } from "react";
 init_textProcessing();
 init_filterProcessing();
-import { format as format8, isValid as isValid5, parse as parse4, startOfToday as startOfToday2 } from "date-fns";
+import { format as format8, isValid as isValid6, parse as parse4, startOfToday as startOfToday2 } from "date-fns";
 import { Fragment as Fragment8, jsx as jsx55, jsxs as jsxs41 } from "react/jsx-runtime";
 function FilterModal({
   schema,
@@ -38100,7 +40526,7 @@ function FilterModal({
       DateOperator.LessThan,
       DateOperator.LessThanOrEqualTo,
       DateOperator.NotEqualTo
-    ].includes(operator2) && !isValid5(parse4(value, "yyyy-mm-dd", /* @__PURE__ */ new Date())) && (filterInitialized || !filter)) {
+    ].includes(operator2) && !isValid6(parse4(value, "yyyy-mm-dd", /* @__PURE__ */ new Date())) && (filterInitialized || !filter)) {
       setValue(startOfToday2().toISOString().substring(0, 10));
     } else if (type === FieldType.Date && [
       DateOperator.InTheLast,
@@ -38290,7 +40716,7 @@ function FilterModal({
           case DateOperator.GreaterThanOrEqualTo:
           case DateOperator.LessThanOrEqualTo: {
             const parsedDate = parse4(value, "yyyy-mm-dd", /* @__PURE__ */ new Date());
-            if (!isValid5(parsedDate)) {
+            if (!isValid6(parsedDate)) {
               alert("Please specify a valid date in yyyy-mm-dd");
               return;
             }
@@ -38818,6 +41244,9 @@ function validateTemplatesAgainstFilters(filters, templates) {
 }
 async function addTemplatesToDashboard(name2, newTemplates, client, dashboardData, getToken, eventTracking) {
   try {
+    if (!newTemplates?.length) {
+      return null;
+    }
     const { publicKey, tenants } = client;
     if (tenants) {
       throw new Error("Adding from template not yet supported for tenants");
@@ -38870,6 +41299,7 @@ async function addTemplatesToDashboard(name2, newTemplates, client, dashboardDat
         function: "addTemplatesToDashboard"
       }
     });
+    return null;
   }
 }
 
@@ -40366,7 +42796,7 @@ import {
   useEffect as useEffect25,
   useRef as useRef20,
   useMemo as useMemo22,
-  useCallback as useCallback4
+  useCallback as useCallback5
 } from "react";
 import MonacoEditor from "@monaco-editor/react";
 
@@ -40377,7 +42807,7 @@ import {
   useState as useState30,
   useContext as useContext26,
   useMemo as useMemo21,
-  useCallback as useCallback3
+  useCallback as useCallback4
 } from "react";
 import {
   closestCenter,
@@ -40398,7 +42828,7 @@ import { CSS as DND_CSS } from "@dnd-kit/utilities";
 
 // src/internals/ReportBuilder/PivotModal.tsx
 import {
-  useCallback as useCallback2,
+  useCallback as useCallback3,
   useContext as useContext23,
   useMemo as useMemo18,
   useState as useState27,
@@ -40793,7 +43223,7 @@ import {
   eachMonthOfInterval,
   eachWeekOfInterval,
   eachYearOfInterval,
-  isValid as isValid6,
+  isValid as isValid7,
   parseISO as parseISO3
 } from "date-fns";
 init_pivotProcessing();
@@ -41281,7 +43711,7 @@ var PivotModal = ({
     setIsOpen(false);
     setPopUpTitle("Add pivot");
   };
-  const onCommitPivot = useCallback2(() => {
+  const onCommitPivot = useCallback3(() => {
     const errors2 = [];
     if ((pivotAggregations?.length ?? 0) === 0) {
       errors2.push("You must have at least one aggregation");
@@ -41423,7 +43853,7 @@ var PivotModal = ({
   const onEditRecommendedPivot = (pivot) => {
     onEditPivot(pivot, null);
   };
-  const refreshPivots = useCallback2(async () => {
+  const refreshPivots = useCallback3(async () => {
     if (!client) {
       return;
     }
@@ -44474,7 +46904,7 @@ function ChartBuilder({
     template: true,
     referenceLines: []
   };
-  const updateDashboardFilters = async (dashboardName) => {
+  const updateDashboardFilters2 = async (dashboardName) => {
     if (dashboardConfig && dashboardConfig[dashboardName]) {
       return dashboardConfig[dashboardName];
     }
@@ -44796,7 +47226,7 @@ function ChartBuilder({
       if (destinationDashboardName) {
         dashboardName = destinationDashboardName;
       }
-      const curDashboard = await updateDashboardFilters(dashboardName);
+      const curDashboard = await updateDashboardFilters2(dashboardName);
       setDashboardOptions(dashboardOptions2);
       curFormData.dashboardName = dashboardName;
       const curSchemaData = schemaData.schemaWithCustomFields;
@@ -44940,7 +47370,7 @@ function ChartBuilder({
     ) ?? {};
   }, [client?.allTenantTypes]);
   const [selectedPivotTable, setSelectedPivotTable] = useState30(pivotData);
-  const getDefaultXAxisFormat = useCallback3(
+  const getDefaultXAxisFormat = useCallback4(
     (form) => {
       if (form.pivot?.rowField) {
         if (isDateField(form.pivot.rowFieldType ?? "")) {
@@ -46083,7 +48513,7 @@ function ChartBuilder({
                             value: formData.dashboardName || "",
                             onChange: async (e) => {
                               handleChange(e.target.value, "dashboardName");
-                              await updateDashboardFilters(e.target.value);
+                              await updateDashboardFilters2(e.target.value);
                             },
                             options: dashboardOptions.map((elem) => ({
                               label: elem.label,
@@ -48316,7 +50746,7 @@ function SQLEditor({
       onCloseChartBuilder && onCloseChartBuilder();
     }
   }, [isChartBuilderOpen]);
-  const handleRunSqlPrompt = useCallback4(async () => {
+  const handleRunSqlPrompt = useCallback5(async () => {
     if (!client || sqlResponseLoading) {
       return;
     }
@@ -48335,7 +50765,7 @@ function SQLEditor({
     setQuery(resp.message);
     setSqlResponseLoading(false);
   }, [sqlPrompt, sqlResponseLoading]);
-  const debounceRunSqlPrompt = useCallback4(
+  const debounceRunSqlPrompt = useCallback5(
     createDebounce(handleRunSqlPrompt, 500),
     [handleRunSqlPrompt]
   );
@@ -54450,7 +56880,7 @@ function StaticChart(props) {
     pageLoading,
     nextPage,
     prevPage,
-    sortRows
+    sortRows: sortRows2
   } = useDashboardReportInternal(reportId);
   const baseStyle = report?.chartType && CHART_TYPE_STYLES[report.chartType] ? CHART_TYPE_STYLES[report.chartType] : DEFAULT_STYLE;
   const mergedStyle = className ? { ...containerStyle ?? {} } : { ...baseStyle, ...containerStyle ?? {} };
@@ -54470,7 +56900,7 @@ function StaticChart(props) {
     }
   };
   const onSortChange = (sort) => {
-    sortRows({
+    sortRows2({
       field: sort.field,
       direction: sort.direction
     });