@quillsql/react 2.16.10 → 2.16.12

package/dist/index.js

@@ -1292,6 +1292,8 @@ import {
   addDays,
   differenceInDays,
   endOfDay,
+  endOfMonth,
+  endOfQuarter,
   endOfToday,
   format as format2,
   isEqual,
@@ -1300,9 +1302,13 @@ import {
   min,
   set,
   startOfDay,
+  startOfMonth,
+  startOfQuarter,
   startOfToday,
   startOfWeek as startOfWeek2,
-  sub
+  sub,
+  subMonths,
+  subQuarters
 } from "date-fns";
 var primaryRangeCustomIntervals, adjustForLeapYear, convertCustomIntervalToDateRange, getLabelForCustomInterval, convertPresetOptionsToSelectableList, PRIMARY_RANGE, COMPARISON_OPTIONS, COMPARISON_RANGE, defaultOptionsV2, reportBuilderOptions, getRangeFromPresetOptions;
 var init_dateRangePickerUtils = __esm({
@@ -1430,6 +1436,9 @@ var init_dateRangePickerUtils = __esm({
         value: 12,
         unit: "months"
       },
+      {
+        type: "previous_month"
+      },
       {
         type: "relative",
         value: 1,
@@ -1469,11 +1478,33 @@ var init_dateRangePickerUtils = __esm({
             })
           };
         }
-        case "relative":
+        case "relative": {
+          if (interval2.unit === "months" && interval2.value === 1 && (!interval2.label || interval2.label === "Last month")) {
+            const lastMonth = subMonths(startOfToday(), 1);
+            return {
+              startDate: startOfMonth(lastMonth),
+              endDate: endOfMonth(lastMonth)
+            };
+          }
           return {
             startDate: sub(startOfToday(), { [interval2.unit]: interval2.value }),
             endDate: endOfToday()
           };
+        }
+        case "previous_month": {
+          const lastMonth = subMonths(startOfToday(), 1);
+          return {
+            startDate: startOfMonth(lastMonth),
+            endDate: endOfMonth(lastMonth)
+          };
+        }
+        case "previous_quarter": {
+          const lastQuarter = subQuarters(startOfToday(), 1);
+          return {
+            startDate: startOfQuarter(lastQuarter),
+            endDate: endOfQuarter(lastQuarter)
+          };
+        }
         case "repeating": {
           const currentDate = /* @__PURE__ */ new Date();
           const currentYear = currentDate.getFullYear();
@@ -1518,24 +1549,39 @@ var init_dateRangePickerUtils = __esm({
     getLabelForCustomInterval = (interval2) => {
       switch (interval2.type) {
         case "week":
-          return "This week";
+          return interval2.label ?? "This week";
         case "static":
           return interval2.label ?? "Custom";
         case "relative":
           return interval2.label ?? `Last ${interval2.value === 1 ? "" : interval2.value + " "}${interval2.value === 1 ? interval2.unit.slice(0, -1) : interval2.unit}`;
+        case "previous_month":
+          return interval2.label ?? "Last month";
+        case "previous_quarter":
+          return interval2.label ?? "Last quarter";
         case "repeating":
-          return "This " + interval2.label.toLowerCase();
+          if (interval2.label === "Month") return "This month";
+          if (interval2.label === "Year") return "This year";
+          return interval2.label;
       }
     };
     convertPresetOptionsToSelectableList = (customIntervals, defaultIntervals) => {
-      const defaultCustomIntervals = defaultIntervals.map(
-        (interval2) => {
-          if (interval2.label === "This week") {
-            return {
+      const customLabelMap = /* @__PURE__ */ new Map();
+      defaultIntervals.forEach((interval2) => {
+        if (interval2.customLabel) {
+          customLabelMap.set(interval2.label, interval2.customLabel);
+        }
+      });
+      const defaultCustomIntervals = defaultIntervals.flatMap((interval2) => {
+        let createdIntervals = [];
+        if (interval2.label === "This week") {
+          createdIntervals = [
+            {
               type: "week"
-            };
-          } else if (interval2.label === "This month" || interval2.label === "Monthly") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "This month" || interval2.label === "Monthly") {
+          createdIntervals = [
+            {
               type: "repeating",
               label: "Month",
               loopDate: { day: 1, month: 1 },
@@ -1615,9 +1661,11 @@ var init_dateRangePickerUtils = __esm({
                   endDate: { day: 31, month: 12 }
                 }
               ]
-            };
-          } else if (interval2.label === "This year" || interval2.label === "Yearly") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "This year" || interval2.label === "Yearly") {
+          createdIntervals = [
+            {
               type: "repeating",
               label: "Year",
               loopDate: { day: 1, month: 1 },
@@ -1631,42 +1679,69 @@ var init_dateRangePickerUtils = __esm({
                   endDate: { day: 31, month: 12 }
                 }
               ]
-            };
-          } else if (interval2.label === "Last 7 days") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "Last 7 days") {
+          createdIntervals = [
+            {
               type: "relative",
               value: 7,
               unit: "days"
-            };
-          } else if (interval2.label === "Last 30 days") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "Last 30 days") {
+          createdIntervals = [
+            {
               type: "relative",
               value: 30,
               unit: "days"
-            };
-          } else if (interval2.label === "Last 90 days") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "Last 90 days") {
+          createdIntervals = [
+            {
               type: "relative",
               value: 90,
               unit: "days"
-            };
-          } else if (interval2.label === "Last 6 months") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "Last 6 months") {
+          createdIntervals = [
+            {
               type: "relative",
               value: 6,
               unit: "months"
-            };
-          } else if (interval2.label === "Last 12 months") {
-            return {
+            }
+          ];
+        } else if (interval2.label === "Last 12 months") {
+          createdIntervals = [
+            {
               type: "relative",
               value: 12,
               unit: "months"
-            };
-          } else {
-            throw new Error("Invalid interval");
-          }
+            }
+          ];
+        } else if (interval2.label === "Last month") {
+          createdIntervals = [
+            {
+              type: "previous_month"
+            }
+          ];
+        } else if (interval2.label === "Last quarter") {
+          createdIntervals = [
+            {
+              type: "previous_quarter"
+            }
+          ];
         }
-      );
+        if (interval2.customLabel && createdIntervals.length > 0) {
+          return createdIntervals.map((i) => ({
+            ...i,
+            label: interval2.customLabel
+          }));
+        }
+        return createdIntervals;
+      });
       return customIntervals?.length || defaultCustomIntervals?.length ? (defaultCustomIntervals ?? []).concat(customIntervals ?? []).flatMap((option) => {
         if (option.type === "repeating" && option.loopStart) {
           const presets = [];
@@ -1708,8 +1783,19 @@ var init_dateRangePickerUtils = __esm({
               }
             };
             const currentYear = currentDate.getFullYear();
+            const baseLabel = getLabelForSubInterval(currentSubInterval);
+            let customLabel2;
+            if (option.label && option.label !== "Month" && option.label !== "Year") {
+              customLabel2 = option.label;
+            } else {
+              if (option.label === "Month") {
+                customLabel2 = customLabelMap.get("This month") || customLabelMap.get("Monthly");
+              } else if (option.label === "Year") {
+                customLabel2 = customLabelMap.get("This year") || customLabelMap.get("Yearly");
+              }
+            }
             presets.push({
-              label: getLabelForSubInterval(currentSubInterval),
+              label: customLabel2 || baseLabel,
               value: getLabelForSubInterval(currentSubInterval).toUpperCase().replace(/ /g, "_") ?? "",
               startDate: set(/* @__PURE__ */ new Date(), {
                 year: currentYear,
@@ -1741,9 +1827,12 @@ var init_dateRangePickerUtils = __esm({
           return presets;
         }
         const dateRange = convertCustomIntervalToDateRange(option);
+        const generatedLabel = getLabelForCustomInterval(option);
+        const customLabel = customLabelMap.get(generatedLabel);
+        const finalLabel = customLabel || generatedLabel;
         return [
           {
-            label: getLabelForCustomInterval(option),
+            label: finalLabel,
             // Value is option label in uppercase with spaces replaced by underscores
             value: getLabelForCustomInterval(option).toUpperCase().replace(/ /g, "_") ?? "",
             startDate: dateRange.startDate,
@@ -1800,6 +1889,7 @@ var init_dateRangePickerUtils = __esm({
       LAST_12_MONTHS: convertCustomIntervalToDateRange(
         primaryRangeCustomIntervals[7]
       ),
+      LAST_MONTH: convertCustomIntervalToDateRange(primaryRangeCustomIntervals[8]),
       ALL_TIME: { startDate: void 0, endDate: void 0 }
     };
     COMPARISON_OPTIONS = [
@@ -1874,6 +1964,12 @@ var init_dateRangePickerUtils = __esm({
         startDate: PRIMARY_RANGE["LAST_30_DAYS"].startDate,
         endDate: PRIMARY_RANGE["LAST_30_DAYS"].endDate
       },
+      {
+        value: "LAST_MONTH",
+        label: "Last month",
+        startDate: PRIMARY_RANGE["LAST_MONTH"].startDate,
+        endDate: PRIMARY_RANGE["LAST_MONTH"].endDate
+      },
       {
         value: "LAST_90_DAYS",
         label: "Last 90 days",
@@ -2439,7 +2535,7 @@ import {
   parse as parse2,
   subDays,
   subHours,
-  subMonths,
+  subMonths as subMonths2,
   subWeeks,
   subYears
 } from "date-fns";
@@ -2565,7 +2661,7 @@ function parseStartEndDate(operatorLeft, operatorRight, valueLeft, valueRight, u
       leftDate = format3(subYears(currentDate, valueLeft), "yyyy-MM-dd");
       break;
     case "month":
-      leftDate = format3(subMonths(currentDate, valueLeft), "yyyy-MM-dd");
+      leftDate = format3(subMonths2(currentDate, valueLeft), "yyyy-MM-dd");
       break;
     case "week":
       leftDate = format3(subWeeks(currentDate, valueLeft), "yyyy-MM-dd");
@@ -2588,7 +2684,7 @@ function parseStartEndDate(operatorLeft, operatorRight, valueLeft, valueRight, u
       rightDate = format3(subYears(currentDate, valueRight), "yyyy-MM-dd");
       break;
     case "month":
-      rightDate = format3(subMonths(currentDate, valueRight), "yyyy-MM-dd");
+      rightDate = format3(subMonths2(currentDate, valueRight), "yyyy-MM-dd");
       break;
     case "week":
       rightDate = format3(subWeeks(currentDate, valueRight), "yyyy-MM-dd");
@@ -15372,7 +15468,10 @@ var init_filterProcessing = __esm({
             })
           ).values()
         ],
-        options: defaultOptionsV2,
+        options: filter.presetOptions || filter.defaultPresetRanges ? convertPresetOptionsToSelectableList(
+          filter.presetOptions ?? [],
+          filter.defaultPresetRanges ?? []
+        ) : defaultOptionsV2,
         preset: filter.primaryRange,
         dashboardName,
         comparisonRange: filter.comparison && comparisonRangeStart && comparisonRangeEnd ? {
@@ -16261,6 +16360,128 @@ async function generatePivotTable({
   }
   throw Error("Failed to generate pivot table: invalid report");
 }
+function processPivotData({
+  rows: responseRows,
+  fields: responseFields,
+  pivot,
+  dateBucket,
+  dateFilter,
+  client,
+  rowCount
+}) {
+  const databaseType = client.databaseType || "postgresql";
+  const rows = pivot.rowField ? responseRows.map(
+    (row) => !row[pivot.rowField] ? { ...row, [pivot.rowField]: "-" } : row
+  ) : responseRows;
+  if (pivot.columnField && client.databaseType?.toLowerCase() === "bigquery") {
+    rows.forEach((row) => {
+      Object.keys(row).forEach((key) => {
+        const processedKey = processColumnName(key);
+        if (processedKey !== key) {
+          row[processedKey] = row[key];
+          delete row[key];
+        }
+      });
+    });
+  }
+  const columns = responseFields?.map((field) => ({
+    field: processColumnName(field.field || field.name),
+    label: snakeCaseToTitleCase(
+      processColumnName(
+        (field.field || field.name).replace("comparison_", "comparison ")
+      )
+    ),
+    format: (field.field || field.name) === pivot.rowField ? "string" : pivot.aggregations?.find(
+      (agg) => agg.valueField === (field.field || field.name) || `${agg.valueField}_percentage` === (field.field || field.name) || !agg.valueField && agg.aggregationType === "percentage" && (field.field || field.name)?.endsWith("percentage")
+    )?.aggregationType === "percentage" ? "percent" : "whole_number",
+    fieldType: field.fieldType,
+    jsType: field.jsType,
+    dataTypeID: field.dataTypeID
+  })).filter(
+    (field, index) => field.field !== "comparison_" + pivot.rowField || index === 0
+  ).sort((a, b) => {
+    if (a.field === pivot.rowField) {
+      return -1;
+    }
+    if (b.field === pivot.rowField) {
+      return 1;
+    }
+    return 0;
+  });
+  if (pivot.rowField && !isStringType(pivot.rowFieldType || "")) {
+    rows.forEach((row) => {
+      row.__quillRawDate = typeof row[pivot.rowField || ""] === "object" ? row[pivot.rowField || ""].value : row[pivot.rowField || ""];
+      let value = typeof row[pivot.rowField || ""] === "object" ? row[pivot.rowField || ""].value : row[pivot.rowField || ""];
+      if (dateBucket === "week" && dateFilter?.startDate && dateFilter?.endDate) {
+        const rowDate = new Date(value);
+        if (rowDate < dateFilter.startDate) {
+          value = dateFilter.startDate.toISOString();
+        } else if (rowDate > dateFilter.endDate) {
+          value = dateFilter.endDate.toISOString();
+        }
+      }
+      const dateString = getDateString(
+        value,
+        dateFilter?.startDate && dateFilter?.endDate ? { start: dateFilter.startDate, end: dateFilter.endDate } : void 0,
+        dateBucket,
+        databaseType
+      );
+      row[pivot.rowField || ""] = dateString;
+    });
+    if (pivot.rowField && pivot.rowFieldType && !isStringType(pivot.rowFieldType) && dateFilter?.startDate && dateFilter?.endDate) {
+      const dateSet = new Set(
+        rows.map((row) => row[pivot.rowField || ""])
+      );
+      for (let date = dateFilter.startDate; date <= dateFilter.endDate; date = new Date(date.getTime() + 24 * 60 * 60 * 1e3)) {
+        const formattedDate = getDateString(
+          date.toISOString(),
+          { start: dateFilter.startDate, end: dateFilter.endDate },
+          dateBucket,
+          databaseType
+        );
+        if (!dateSet.has(formattedDate)) {
+          const newRow = {};
+          newRow[pivot.rowField] = formattedDate;
+          newRow.__quillRawDate = date.toISOString();
+          rows.push(newRow);
+          dateSet.add(formattedDate);
+        }
+      }
+    }
+    if (!pivot.sort || pivot.sortField === pivot.rowField) {
+      rows.sort((a, b) => {
+        const direction = pivot.sort && pivot.sortDirection === "DESC" ? -1 : 1;
+        if (a.__quillRawDate < b.__quillRawDate) {
+          return -1 * direction;
+        }
+        if (a.__quillRawDate > b.__quillRawDate) {
+          return 1 * direction;
+        }
+        return 0;
+      });
+    }
+  }
+  columns?.forEach((column, index) => {
+    if (column.label && ["null", "undefined"].includes(column.label.toLowerCase()) && !pivot.columnField && !pivot.aggregations?.[index]?.valueField && pivot.aggregations?.[index]?.aggregationType === "count") {
+      column.label = "Count";
+    }
+  });
+  const numericColumns = columns?.filter(
+    (column) => column.format === "whole_number" || column.format === "percentage"
+  );
+  rows.forEach((row) => {
+    numericColumns?.forEach((column) => {
+      row[column.field] = row[column.field] ?? 0;
+    });
+  });
+  return {
+    rows,
+    columns: columns ?? [],
+    rowCount: rowCount || rows.length,
+    pivotQuery: "",
+    comparisonPivotQuery: ""
+  };
+}
 var init_pivotConstructor = __esm({
   "src/utils/pivotConstructor.ts"() {
     "use strict";
@@ -17833,6 +18054,22 @@ var init_tableProcessing = __esm({
           return {};
         }
         let uniqueValuesByColumn = {};
+        const aliasToField = {};
+        const fieldToAlias = {};
+        columns.forEach((col) => {
+          if (col.alias) {
+            aliasToField[col.alias] = col.field;
+            fieldToAlias[col.field] = col.alias;
+          }
+        });
+        reportBuilderState?.columns?.forEach((col) => {
+          if (col.alias) {
+            aliasToField[col.alias] = col.field;
+            if (!fieldToAlias[col.field]) {
+              fieldToAlias[col.field] = col.alias;
+            }
+          }
+        });
         let rows = resp?.rows;
         if (!rows && fetchResult.queries?.queryResults?.[0]?.rows) {
           rows = fetchResult.queries.queryResults[0].rows;
@@ -17841,11 +18078,24 @@ var init_tableProcessing = __esm({
           uniqueValuesByColumn = resp.uniqueValues;
         } else if (rows && Array.isArray(rows)) {
           rows.forEach((row) => {
-            if (row.field && row.string_values) {
+            if (row?.field && row?.string_values) {
               uniqueValuesByColumn[row.field] = row.string_values;
             }
           });
         }
+        const normalizedUniqueValuesByColumn = {};
+        Object.entries(uniqueValuesByColumn).forEach(([key, values]) => {
+          if (!Array.isArray(values)) {
+            return;
+          }
+          const fieldKey = aliasToField[key] || key;
+          normalizedUniqueValuesByColumn[fieldKey] = values;
+          const aliasKey = fieldToAlias[fieldKey];
+          if (aliasKey) {
+            normalizedUniqueValuesByColumn[aliasKey] = values;
+          }
+        });
+        uniqueValuesByColumn = normalizedUniqueValuesByColumn;
         const uniqueValues2 = {};
         tables.forEach((tableName) => {
           const tableUniqueValues = {};
@@ -19753,10 +20003,14 @@ async function cleanDashboardItem({
     const pivotChartProcessing = {
       page: DEFAULT_PAGINATION
     };
-    pivotTable = await getPivotTable(
-      {
-        ...item,
-        pivot: item.pivot && !skipPivotFetch ? {
+    if (item.pivot && skipPivotFetch && item.rows && item.fields) {
+      const dateFilter = dashboardFilters?.find(
+        (filter) => filter.filterType === "date_range"
+      );
+      pivotTable = processPivotData({
+        rows: item.rows,
+        fields: item.fields,
+        pivot: {
           ...item.pivot,
           aggregations: item.pivot.aggregations ?? [
             {
@@ -19767,18 +20021,40 @@ async function cleanDashboardItem({
               aggregationType: item.pivot.aggregationType
             }
           ]
-        } : void 0
-      },
-      dashboardFilters,
-      item.dashboardName,
-      getToken,
-      client,
-      eventTracking,
-      dateBucket,
-      shouldPaginatePivotAsTable ? additionalProcessing : pivotChartProcessing,
-      tenants,
-      customFields
-    );
+        },
+        dateBucket,
+        dateFilter,
+        client,
+        rowCount: item.rowCount ? parseInt(item.rowCount) : item.rows.length
+      });
+    } else {
+      pivotTable = await getPivotTable(
+        {
+          ...item,
+          pivot: item.pivot && !skipPivotFetch ? {
+            ...item.pivot,
+            aggregations: item.pivot.aggregations ?? [
+              {
+                valueField: item.pivot.valueField,
+                valueFieldType: item.pivot.valueFieldType,
+                valueField2: item.pivot.valueField2,
+                valueField2Type: item.pivot.valueField2Type,
+                aggregationType: item.pivot.aggregationType
+              }
+            ]
+          } : void 0
+        },
+        dashboardFilters,
+        item.dashboardName,
+        getToken,
+        client,
+        eventTracking,
+        dateBucket,
+        shouldPaginatePivotAsTable ? additionalProcessing : pivotChartProcessing,
+        tenants,
+        customFields
+      );
+    }
   } catch (e) {
     pivotTable = void 0;
     eventTracking?.logError?.({
@@ -20186,6 +20462,44 @@ function extractAllReportValuesFromQuillInternalReport(reportInternal) {
     pivotRowCount: reportInternal.pivotRowCount
   };
 }
+async function fetchReportRows({
+  reportId,
+  client,
+  tenants,
+  filters = [],
+  getToken,
+  abortSignal,
+  additionalProcessing
+}) {
+  const fetchResp = await quillFetch({
+    client,
+    task: "report",
+    metadata: {
+      reportId,
+      clientId: client.publicKey,
+      databaseType: client.databaseType,
+      filters: filters.map((filter) => ({ ...filter, options: void 0 })),
+      useNewNodeSql: true,
+      tenants,
+      additionalProcessing
+    },
+    abortSignal,
+    getToken
+  });
+  const resp = await parseFetchResponse(client, "report", fetchResp, getToken);
+  if (client.databaseType?.toLowerCase() === "bigquery") {
+    parseValueFromBigQueryDates(resp.rows, resp.fields);
+  }
+  const columns = (resp.fields || []).map(
+    (field) => convertPostgresColumn(field)
+  );
+  return {
+    rows: resp.rows || [],
+    rowCount: resp.rowCount || 0,
+    columns,
+    fields: resp.fields || []
+  };
+}
 async function fetchReport({
   reportId,
   client,
@@ -20200,14 +20514,15 @@ async function fetchReport({
   rowCountOnly,
   abortSignal,
   getToken,
-  eventTracking
+  eventTracking,
+  usePivotTask = false
 }) {
   let reportInfo = void 0;
   let errorMessage = void 0;
   try {
     const fetchResp = await quillFetch({
       client,
-      task: useReportTask ? "report" : "item",
+      task: usePivotTask ? "pivot-template" : useReportTask ? "report" : "item",
       metadata: {
         reportId,
         dashboardItemId: reportId,
@@ -20227,7 +20542,7 @@ async function fetchReport({
     });
     const resp = await parseFetchResponse(
       client,
-      useReportTask ? "report" : "item",
+      usePivotTask ? "pivot-template" : useReportTask ? "report" : "item",
       fetchResp,
       getToken
     );
@@ -20235,12 +20550,13 @@ async function fetchReport({
       resp,
       client,
       filters,
-      dateBucket,
+      dateBucket: resp.dateBucket ?? dateBucket,
       additionalProcessing,
       customFields,
       getToken,
       eventTracking,
-      tenants
+      tenants,
+      skipPivotFetch: usePivotTask
     });
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
@@ -20289,8 +20605,10 @@ async function processReportResponse({
   customFields,
   getToken,
   eventTracking,
-  tenants
+  tenants,
+  skipPivotFetch = false
 }) {
+  const shouldSkipPivotFetch = skipPivotFetch || !!resp?.pivotRows && !!resp?.fields;
   const dashboardItem = {
     ...resp,
     filtersApplied: filters?.filter(
@@ -20320,7 +20638,8 @@ async function processReportResponse({
     customFields,
     getToken,
     tenants,
-    eventTracking
+    eventTracking,
+    skipPivotFetch: shouldSkipPivotFetch
   });
   if (additionalProcessing) {
     reportInfo.pagination = additionalProcessing.page;
@@ -22349,6 +22668,34 @@ var ContextProvider = ({
       );
       if (currentProcessId === loadDashboardProcessId.current[dashboardName]) {
         if (!equal(resp, curDashboardConfig)) {
+          Object.values(
+            resp.sections ?? {}
+          ).flat().forEach((report) => {
+            const existing = reports[report.id];
+            if (existing) {
+              const merged = {
+                ...report,
+                // prefer fresh server metadata (chartType, flags, etc.)
+                // preserve existing row payload if server response is metadata-only
+                ...existing.rows ? { rows: existing.rows } : {},
+                ...existing.rowCount !== void 0 ? { rowCount: existing.rowCount } : {},
+                ...existing.columns ? { columns: existing.columns } : {},
+                ...existing.columnInternal ? { columnInternal: existing.columnInternal } : {},
+                ...existing.pagination ? { pagination: existing.pagination } : {}
+              };
+              reportsDispatch({
+                type: "UPDATE_REPORT",
+                id: report.id,
+                data: merged
+              });
+            } else {
+              reportsDispatch({
+                type: "ADD_REPORT",
+                id: report.id,
+                data: report
+              });
+            }
+          });
           dashboardConfigDispatch({
             type: "UPDATE_DASHBOARD",
             id: dashboardName,
@@ -23022,7 +23369,7 @@ init_columnType();
 import {
   add,
   startOfDay as startOfDay3,
-  startOfMonth,
+  startOfMonth as startOfMonth2,
   startOfWeek as startOfWeek3,
   startOfYear
 } from "date-fns";
@@ -23170,11 +23517,12 @@ var useDashboardInternal = (dashboardName, customFilters) => {
         dashboardName,
         sectionOrder
       };
-      void quillFetchWithToken({
-        client,
-        task: "set-section-order",
-        metadata: body
-      }).then((response) => {
+      try {
+        const response = await quillFetchWithToken({
+          client,
+          task: "set-section-order",
+          metadata: body
+        });
         Object.entries(response?.data?.newIds ?? {}).forEach(
           ([section, newId2]) => {
             dashboardConfigDispatch({
@@ -23196,11 +23544,24 @@ var useDashboardInternal = (dashboardName, customFilters) => {
             });
           }
         );
-      }).catch((error) => {
-        if (error instanceof Error && error.name === "AbortError") {
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
           return;
         }
-      });
+        eventTracking?.logError?.({
+          type: "bug",
+          // TODO: determine type
+          severity: "high",
+          message: "Error setting section order",
+          errorMessage: e?.message,
+          errorStack: e?.stack,
+          errorData: {
+            caller: "useDashboard",
+            function: "setSectionOrder"
+          }
+        });
+        console.error(e);
+      }
     }
   };
   function isDashboardFilterLoading(filterName) {
@@ -23458,7 +23819,8 @@ var useDashboards = () => {
                 (preset) => ({
                   ...preset,
                   loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
-                  loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
+                  loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0,
+                  customLabel: preset.customLabel
                 })
               )
             } : void 0,
@@ -23518,7 +23880,8 @@ var useDashboards = () => {
           (preset) => ({
             ...preset,
             loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
-            loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
+            loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0,
+            customLabel: preset.customLabel
           })
         ),
         dashboardName: updated.data.dashboard.name,
@@ -23636,6 +23999,7 @@ var useDashboard = (dashboardName, config) => {
   const { customReportFilters } = useContext(ReportFiltersContext);
   const { eventTracking } = useContext(EventTrackingContext);
   const customFiltersRef = useRef2(customReportFilters);
+  const reportRequestIds = useRef2({});
   useEffect2(() => {
     customFiltersRef.current = customReportFilters;
   }, [customReportFilters]);
@@ -23778,6 +24142,8 @@ var useDashboard = (dashboardName, config) => {
     await Promise.all(
       allReports.map(async (reportInfo) => {
         const reportId = reportInfo.id;
+        const requestId = (reportRequestIds.current[reportId] ?? 0) + 1;
+        reportRequestIds.current[reportId] = requestId;
         reportsLoadingStateDispatch({
           type: "SET_REPORT_LOADING",
           id: reportId,
@@ -23795,6 +24161,7 @@ var useDashboard = (dashboardName, config) => {
         const additionalProcessing = {
           page: pagination
         };
+        const usePivotTask = !!reportInfo.pivot;
         const { report, error } = await fetchReport({
           reportId,
           client,
@@ -23803,12 +24170,16 @@ var useDashboard = (dashboardName, config) => {
           additionalProcessing,
           filters: dashboardFilters2.concat(customFilters).concat(customReportFiltersArray),
           getToken,
-          eventTracking
+          eventTracking,
+          usePivotTask
         });
         if (error) {
           console.error(error);
           return null;
         }
+        if (reportRequestIds.current[reportId] !== requestId) {
+          return null;
+        }
         reportsDispatch({
           type: "UPDATE_REPORT",
           id: reportId,
@@ -23822,6 +24193,40 @@ var useDashboard = (dashboardName, config) => {
           id: reportId,
           data: false
         });
+        if (usePivotTask) {
+          fetchReportRows({
+            reportId,
+            client,
+            tenants,
+            filters: dashboardFilters2.concat(customFilters).concat(customReportFiltersArray),
+            getToken,
+            additionalProcessing
+          }).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
+              }
+            });
+          }).catch((e) => {
+            if (e instanceof Error && e.name === "AbortError") return;
+            console.error("Failed to fetch background rows", e);
+          });
+        }
         return report;
       })
     );
@@ -28143,6 +28548,8 @@ var axisFormatter = ({ value, field, fields }) => {
       return formatPercent2(value);
     case "dollar_amount":
       return formatDollarAmount2(value);
+    case "dollar_cents":
+      return formatDollarCents2(value);
     case "whole_number":
       return formatWholeNumber2(value);
     case "two_decimal_places":
@@ -28207,6 +28614,12 @@ var formatterDollar2 = new Intl.NumberFormat("en-US", {
   currency: "USD",
   maximumFractionDigits: 0
 });
+var formatterDollarCents = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
 var formatDollarAmount2 = (value) => {
   const num = Number(value ?? 0);
   if (num >= 1e3 || num === 0) {
@@ -28215,6 +28628,9 @@ var formatDollarAmount2 = (value) => {
     return formatterDollar2.format(num);
   }
 };
+var formatDollarCents2 = (value) => {
+  return formatterDollarCents.format(Number(value ?? 0));
+};
 var formatterBigWholeNumber = new Intl.NumberFormat("en-US", {
   minimumSignificantDigits: 1,
   maximumSignificantDigits: 2,
@@ -29630,11 +30046,11 @@ import {
   useState as useState11
 } from "react";
 import {
-  startOfMonth as startOfMonth2,
-  endOfMonth,
+  startOfMonth as startOfMonth3,
+  endOfMonth as endOfMonth2,
   format as format7,
   eachDayOfInterval,
-  subMonths as subMonths2,
+  subMonths as subMonths3,
   startOfWeek as startOfWeek5,
   endOfWeek as endOfWeek3,
   differenceInDays as differenceInDays3,
@@ -30159,19 +30575,19 @@ function CalendarRow({
 }) {
   const firstMonthDisplayedDates = eachDayOfInterval({
     start: startOfWeek5(anchorStartDate),
-    end: endOfWeek3(endOfMonth(anchorStartDate))
+    end: endOfWeek3(endOfMonth2(anchorStartDate))
   });
   const secondMonthDisplayedDates = eachDayOfInterval({
-    start: startOfWeek5(startOfMonth2(anchorEndDate)),
+    start: startOfWeek5(startOfMonth3(anchorEndDate)),
     end: endOfWeek3(anchorEndDate)
   });
   const incrementAnchorDates = () => {
-    setAnchorStartDate(startOfMonth2(addMonths(anchorStartDate, 1)));
-    setAnchorEndDate(endOfMonth(addMonths(anchorEndDate, 1)));
+    setAnchorStartDate(startOfMonth3(addMonths(anchorStartDate, 1)));
+    setAnchorEndDate(endOfMonth2(addMonths(anchorEndDate, 1)));
   };
   const decrementAnchorDates = () => {
-    setAnchorStartDate(startOfMonth2(subMonths2(anchorStartDate, 1)));
-    setAnchorEndDate(endOfMonth(subMonths2(anchorEndDate, 1)));
+    setAnchorStartDate(startOfMonth3(subMonths3(anchorStartDate, 1)));
+    setAnchorEndDate(endOfMonth2(subMonths3(anchorEndDate, 1)));
   };
   return /* @__PURE__ */ jsx39("div", { style: { position: "absolute", zIndex: 100, marginTop: 12 }, children: /* @__PURE__ */ jsxs29(
     "div",
@@ -30488,31 +30904,31 @@ function DayPicker({
 }
 function getAnchorStartDate(startDate, endDate) {
   if (!startDate && !endDate) {
-    return startOfMonth2(subMonths2(/* @__PURE__ */ new Date(), 1));
+    return startOfMonth3(subMonths3(/* @__PURE__ */ new Date(), 1));
   }
   if (startDate && !endDate) {
-    return startOfMonth2(startDate);
+    return startOfMonth3(startDate);
   }
   if (!startDate && endDate) {
-    return startOfMonth2(subMonths2(endDate, 1));
+    return startOfMonth3(subMonths3(endDate, 1));
   }
   if (startDate && endDate) {
-    return startOfMonth2(startDate);
+    return startOfMonth3(startDate);
   }
   return /* @__PURE__ */ new Date();
 }
 function getAnchorEndDate(startDate, endDate) {
   if (!startDate && !endDate) {
-    return endOfMonth(/* @__PURE__ */ new Date());
+    return endOfMonth2(/* @__PURE__ */ new Date());
   }
   if (startDate && !endDate) {
-    return endOfMonth(addMonths(startDate, 1));
+    return endOfMonth2(addMonths(startDate, 1));
   }
   if (!startDate && endDate) {
-    return endOfMonth(endDate);
+    return endOfMonth2(endDate);
   }
   if (startDate && endDate) {
-    return endOfMonth(addMonths(startDate, 1));
+    return endOfMonth2(addMonths(startDate, 1));
   }
   return /* @__PURE__ */ new Date();
 }
@@ -32333,6 +32749,8 @@ function DataLoader({
     previousUserFilters.current = userFilters;
     rowsAbortController.current?.abort();
     rowsAbortController.current = new AbortController();
+    const usePivotTask = !!item.pivot;
+    let backgroundFetch = null;
     try {
       if (dashboardName) {
         const { report: fetchedReport, error: error2 } = await fetchReport({
@@ -32348,18 +32766,62 @@ function DataLoader({
           rowCountOnly: false,
           abortSignal: rowsAbortController.current.signal,
           getToken,
-          eventTracking
+          eventTracking,
+          usePivotTask
         });
+        const existingReport = dashboard[item.id] ?? reports[item.id];
+        const baseReport = error2 && existingReport ? { ...existingReport, error: error2 } : fetchedReport;
+        const reportToAdd = {
+          ...baseReport,
+          rows: baseReport?.rows ?? [],
+          columns: baseReport?.columns ?? [],
+          columnInternal: baseReport?.columnInternal ?? []
+        };
         addReport({
-          ...fetchedReport,
+          ...reportToAdd,
           id: item.id,
           triggerReload: false,
-          rowCount: fetchedReport.pivot ? fetchedReport.rowCount : 0,
+          rowCount: reportToAdd.pivot ? reportToAdd.rowCount : 0,
           filtersApplied: userFilters,
           loadingRows: false
           // rowCount 0 indicates it's still loading if row length is nonzero
         });
         setError(error2);
+        if (usePivotTask) {
+          const backgroundAbortController = new AbortController();
+          backgroundFetch = () => {
+            fetchReportRows({
+              reportId: item.id,
+              client,
+              tenants,
+              filters: filters.concat(userFilters ?? []),
+              getToken,
+              abortSignal: backgroundAbortController.signal,
+              additionalProcessing: {
+                ...processing,
+                ...{ page: DEFAULT_PAGINATION }
+              }
+            }).then(({ rows, rowCount, columns, fields }) => {
+              updateReport({
+                id: item.id,
+                rows,
+                rowCount,
+                columnInternal: columns,
+                columns: columns.map((col) => ({
+                  field: col.field,
+                  format: col.format,
+                  label: col.label,
+                  inferFormat: col.inferFormat
+                })),
+                // @ts-ignore
+                fields
+              });
+            }).catch((e) => {
+              if (e instanceof Error && e.name === "AbortError") return;
+              console.error("Failed to fetch background rows", e);
+            });
+          };
+        }
       } else {
         try {
           await fetchIndividualReport({
@@ -32416,6 +32878,9 @@ function DataLoader({
       if (fetchRowsRequestId === rowsRequestId.current) {
         rowsAbortController.current = null;
         setLoading(false);
+        if (backgroundFetch) {
+          backgroundFetch();
+        }
       }
     }
   };
@@ -32480,7 +32945,11 @@ var ChartDataLoader = ({
   dashboardName,
   propagateChanges
 }) => {
-  const { dashboardReports: dashboard, addReport } = useDashboardReports(dashboardName);
+  const {
+    dashboardReports: dashboard,
+    addReport,
+    updateReport
+  } = useDashboardReports(dashboardName);
   const { dashboardFilters } = useContext13(DashboardFiltersContext);
   const { reports, fetchIndividualReport } = useContext13(ReportsContext);
   const { getToken } = useContext13(FetchContext);
@@ -32530,6 +32999,8 @@ var ChartDataLoader = ({
     setLoading(true);
     fetchReportAbortController.current?.abort();
     fetchReportAbortController.current = new AbortController();
+    const usePivotTask = !!item.pivot;
+    let backgroundFetch = null;
     try {
       if (dashboardName) {
         const { report, error: error2 } = await fetchReport({
@@ -32547,16 +33018,60 @@ var ChartDataLoader = ({
           customFields: schemaData.customFields,
           abortSignal: fetchReportAbortController.current.signal,
           getToken,
-          eventTracking
+          eventTracking,
+          usePivotTask
         });
+        const existingReport = dashboard[item.id] ?? reports[item.id];
+        const baseReport = error2 && existingReport ? { ...existingReport, error: error2 } : report;
+        const reportToAdd = {
+          ...baseReport,
+          rows: baseReport?.rows ?? [],
+          columns: baseReport?.columns ?? [],
+          columnInternal: baseReport?.columnInternal ?? []
+        };
         addReport({
-          ...report,
+          ...reportToAdd,
           id: item.id,
           triggerReload: false,
           filtersApplied: userFilters,
           loadingRows: false
         });
         setError(error2);
+        if (usePivotTask) {
+          const backgroundAbortController = new AbortController();
+          backgroundFetch = () => {
+            fetchReportRows({
+              reportId: item.id,
+              client,
+              tenants,
+              filters: filters.concat(userFilters ?? []),
+              getToken,
+              abortSignal: backgroundAbortController.signal,
+              additionalProcessing: {
+                ...additionalProcessing,
+                ...{ page: DEFAULT_PAGINATION }
+              }
+            }).then(({ rows, rowCount, columns, fields }) => {
+              updateReport({
+                id: item.id,
+                rows,
+                rowCount,
+                columnInternal: columns,
+                columns: columns.map((col) => ({
+                  field: col.field,
+                  format: col.format,
+                  label: col.label,
+                  inferFormat: col.inferFormat
+                })),
+                // @ts-ignore
+                fields
+              });
+            }).catch((e) => {
+              if (e instanceof Error && e.name === "AbortError") return;
+              console.error("Failed to fetch background rows", e);
+            });
+          };
+        }
       } else {
         try {
           await fetchIndividualReport({
@@ -32612,6 +33127,9 @@ var ChartDataLoader = ({
       if (fetchRowsRequestId === rowsRequestId.current) {
         fetchReportAbortController.current = null;
         setLoading(false);
+        if (backgroundFetch) {
+          backgroundFetch();
+        }
       }
     }
   };
@@ -38789,7 +39307,7 @@ function Dashboard({
                   filters: populatedDashboardFilters ?? [],
                   userFilters: dataLoaderUserFilters,
                   additionalProcessing: {
-                    page: DEFAULT_PAGINATION,
+                    page: pagination,
                     last: additionalProcessing?.last
                   },
                   dashboardName: name2,
@@ -41129,7 +41647,7 @@ var PivotModal = ({
                                                       });
                                                     }
                                                   },
-                                                  options: (samplePivotTable?.columns ?? []).map((column) => ({
+                                                  options: (samplePivotTable?.columns && samplePivotTable.columns.length > 0 ? samplePivotTable.columns : pivotRowField ? [{ field: pivotRowField }] : []).map((column) => ({
                                                     label: snakeAndCamelCaseToTitleCase(
                                                       column.field
                                                     ),
@@ -41549,6 +42067,7 @@ init_Filter();
 init_filterProcessing();
 init_dateRangePickerUtils();
 import { Fragment as Fragment11, jsx as jsx63, jsxs as jsxs45 } from "react/jsx-runtime";
+var MULTISELECT_REQUEST_DEBOUNCE_MS = 1e3;
 var TogglePrimitive = ({
   value,
   onClick,
@@ -41688,6 +42207,20 @@ function InternalChart({
     ) : defaultOptionsV2;
   }, [reportDateFilter]);
   const [filterValues, setFilterValues] = useState27({});
+  const multiselectDebounceRef = useRef16({});
+  const latestMultiselectValueRef = useRef16({});
+  const [lockedFilters, setLockedFilters] = useState27(
+    {}
+  );
+  useEffect22(() => {
+    return () => {
+      Object.values(multiselectDebounceRef.current).forEach((timer2) => {
+        if (timer2) {
+          clearTimeout(timer2);
+        }
+      });
+    };
+  }, []);
   useEffect22(() => {
     if (reportDateFilter) {
       const customDateFilter = filters?.find(
@@ -41794,6 +42327,46 @@ function InternalChart({
       ...filterValues2,
       [filter.label]: filterValue
     }));
+    if (filter.filterType === "string" /* String */ && filter.stringFilterType === "multiselect") {
+      latestMultiselectValueRef.current[filter.label] = filterValue;
+      const existingTimer = multiselectDebounceRef.current[filter.label];
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      multiselectDebounceRef.current[filter.label] = setTimeout(() => {
+        multiselectDebounceRef.current[filter.label] = void 0;
+        setLockedFilters((prev) => ({
+          ...prev,
+          [filter.label]: true
+        }));
+        try {
+          const maybePromise = onDashboardFilterChange(
+            filter.label,
+            latestMultiselectValueRef.current[filter.label]
+          );
+          if (maybePromise && typeof maybePromise.finally === "function") {
+            maybePromise.finally(() => {
+              setLockedFilters((prev) => ({
+                ...prev,
+                [filter.label]: false
+              }));
+            });
+          } else {
+            setLockedFilters((prev) => ({
+              ...prev,
+              [filter.label]: false
+            }));
+          }
+        } catch (e) {
+          setLockedFilters((prev) => ({
+            ...prev,
+            [filter.label]: false
+          }));
+          throw e;
+        }
+      }, MULTISELECT_REQUEST_DEBOUNCE_MS);
+      return;
+    }
     onDashboardFilterChange(filter.label, filterValue);
   };
   const [filtersExpanded, setFiltersExpanded] = useState27(false);
@@ -41951,7 +42524,7 @@ function InternalChart({
                         SelectComponent,
                         MultiSelectComponent,
                         DateRangePickerComponent,
-                        disabled: !filtersEnabled,
+                        disabled: !filtersEnabled || lockedFilters[filter.filter.label],
                         containerStyle: {
                           // display: !filtersExpanded && visibleFilters[index] ? 'none' : 'inline',
                           visibility: !filtersExpanded && visibleFilters[index] ? "hidden" : "visible"
@@ -43817,6 +44390,7 @@ function ChartBuilder({
           client,
           uniqueValues,
           dashboardName: destinationDashboardName,
+          dashboardFilters: dashboardFilters2,
           tenants,
           additionalProcessing: baseProcessing,
           getToken,
@@ -43928,7 +44502,7 @@ function ChartBuilder({
       }
       return filter;
     });
-    loadFiltersForReport(
+    return loadFiltersForReport(
       report?.id ?? TEMP_REPORT_ID,
       "ChartBuilder",
       updatedFilters,
@@ -43938,7 +44512,7 @@ function ChartBuilder({
     ).then(() => {
       setCurrentPage(0);
       setMaxPage(0);
-      handleRunQuery(baseProcessing, updatedFilters);
+      return handleRunQuery(baseProcessing, updatedFilters);
     });
   };
   const filtersEnabledRef = useRef18(filtersEnabled);
@@ -44497,12 +45071,21 @@ function ChartBuilder({
         error: void 0,
         section: formData.section
       };
-      addReport(data);
-      reportsDispatch({
-        type: "ADD_REPORT",
-        id: resp.id,
-        data
-      });
+      const reportFlags = data.flags;
+      const hasRestrictedFlags = reportFlags && Object.values(reportFlags).some(
+        (v) => Array.isArray(v) && v.length > 0
+      );
+      const currentTenantCanSee = !hasRestrictedFlags || flags && Object.values(reportFlags).some(
+        (v) => v === "QUILL_ALL_TENANTS" || Array.isArray(v) && v.some((f) => flags.includes(f))
+      );
+      if (currentTenantCanSee) {
+        addReport(data);
+        reportsDispatch({
+          type: "ADD_REPORT",
+          id: resp.id,
+          data
+        });
+      }
       if (onAddToDashboardComplete) {
         onAddToDashboardComplete(data);
       } else {
@@ -48924,6 +49507,14 @@ var useReportBuilderInternal = ({
     report,
     skipPivotColumnFetch
   }) => {
+    const tablesEqual = (a, b) => {
+      if (a.length !== b.length) return false;
+      const aNames = a.map((t) => t.name).sort();
+      const bNames = b.map((t) => t.name).sort();
+      return aNames.every((name2, idx) => name2 === bNames[idx]);
+    };
+    const haveTablesChanged = tablesChanged ?? !tablesEqual(state.tables, tables);
+    const needsFilteredUniqueValues = !!filtersChanged || !!limitChanged || haveTablesChanged;
     if (!client) {
       return;
     }
@@ -48931,8 +49522,8 @@ var useReportBuilderInternal = ({
       state,
       pivot: state.pivot,
       previousReport: report,
-      requiresNewFilteredUniqueValues: filtersChanged || limitChanged,
-      requiresNewUnfilteredUniqueValues: tablesChanged,
+      requiresNewFilteredUniqueValues: needsFilteredUniqueValues,
+      requiresNewUnfilteredUniqueValues: haveTablesChanged,
       skipPivotColumnFetch
     });
   };
@@ -49543,18 +50134,10 @@ var useReportBuilderInternal = ({
   }, [client]);
   useEffect26(() => {
     const loadChart = async () => {
-      let report;
-      if (!client) {
-        return;
-      }
+      if (!client || !reportId) return;
+      const report = allReportsById[reportId];
+      if (!report) return;
       try {
-        if (!reportId) {
-          throw new Error("Report ID is required");
-        }
-        report = allReportsById[reportId];
-        if (!report) {
-          throw new Error("Report not found");
-        }
         const { ast: newAst, pivot: newPivot } = await fetchASTFromQuillReport(
           report,
           client,
@@ -52879,15 +53462,20 @@ function ChartEditor({
   const parentRef = useRef22(null);
   const [modalWidth, setModalWidth] = useState38(200);
   const [modalHeight, setModalHeight] = useState38(200);
-  const { addReport } = useDashboardReports(destinationDashboard);
   const { allReportsById } = useAllReports();
+  const report = allReportsById[reportId];
+  const resolvedDashboard = useMemo26(
+    () => destinationDashboard ?? report?.dashboardName ?? null,
+    [destinationDashboard, report?.dashboardName]
+  );
+  const { addReport } = useDashboardReports(resolvedDashboard ?? void 0);
   const { tenants, flags } = useContext33(TenantContext);
   const { getToken } = useContext33(FetchContext);
-  const report = allReportsById[reportId];
   const [client, isClientLoading] = useContext33(ClientContext);
   const [schemaData] = useContext33(SchemaDataContext);
   const { dashboardFilters } = useContext33(DashboardFiltersContext);
   const { eventTracking } = useContext33(EventTrackingContext);
+  const { reload } = useDashboardInternal(resolvedDashboard);
   const specificDashboardFilters = useMemo26(() => {
     if (!report) {
       return [];
@@ -52895,7 +53483,7 @@ function ChartEditor({
     return Object.values(dashboardFilters[report.dashboardName] || {}).map(
       (f) => f.filter
     );
-  }, [dashboardFilters]);
+  }, [dashboardFilters, report?.dashboardName]);
   const [filtersEnabled, setFiltersEnabled] = useState38(true);
   const [chartBuilderKey, setChartBuilderKey] = useState38(0);
   const dateFilter = Object.values(specificDashboardFilters).find(
@@ -52921,7 +53509,7 @@ function ChartEditor({
     };
   }, []);
   const fetchReportHelper = async (processing) => {
-    if (!client) {
+    if (!client || !reportId) {
       return;
     }
     const minimalFilters = Object.values(specificDashboardFilters).length ? Object.values(specificDashboardFilters).map((filter) => {
@@ -52953,10 +53541,13 @@ function ChartEditor({
     addReport(report2);
   };
   useEffect30(() => {
+    if (!isOpen || !reportId) {
+      return;
+    }
     if (!isClientLoading && !report) {
       fetchReportHelper();
     }
-  }, [reportId, isClientLoading, allReportsById]);
+  }, [reportId, isClientLoading, allReportsById, isOpen]);
   return /* @__PURE__ */ jsx82("div", { ref: parentRef, style: { height: "100%" }, children: /* @__PURE__ */ jsx82(
     ModalComponent,
     {
@@ -52970,7 +53561,7 @@ function ChartEditor({
       title: chartBuilderTitle || "Add to dashboard",
       width: isHorizontalView ? modalWidth : void 0,
       height: isHorizontalView ? modalHeight : void 0,
-      children: allReportsById[reportId] ? /* @__PURE__ */ jsx82(
+      children: reportId && allReportsById[reportId] ? /* @__PURE__ */ jsx82(
         ChartBuilder,
         {
           reportId,
@@ -52985,8 +53576,15 @@ function ChartEditor({
             } else if (onAddToDashboardComplete) {
               onAddToDashboardComplete(data);
             }
+            const targetDashboard = data?.dashboardName ?? resolvedDashboard;
+            if (targetDashboard) {
+              reload(targetDashboard, true, {
+                report: data,
+                action: "upsert"
+              });
+            }
           },
-          destinationDashboard,
+          destinationDashboard: resolvedDashboard ?? void 0,
           destinationSection,
           dateRange,
           SelectComponent,