@quillsql/react 2.16.10 → 2.16.12

package/dist/index.cjs

@@ -1401,6 +1401,9 @@ var init_dateRangePickerUtils = __esm({
         value: 12,
         unit: "months"
       },
+      {
+        type: "previous_month"
+      },
       {
         type: "relative",
         value: 1,
@@ -1440,11 +1443,33 @@ var init_dateRangePickerUtils = __esm({
             })
           };
         }
-        case "relative":
+        case "relative": {
+          if (interval2.unit === "months" && interval2.value === 1 && (!interval2.label || interval2.label === "Last month")) {
+            const lastMonth = (0, import_date_fns2.subMonths)((0, import_date_fns2.startOfToday)(), 1);
+            return {
+              startDate: (0, import_date_fns2.startOfMonth)(lastMonth),
+              endDate: (0, import_date_fns2.endOfMonth)(lastMonth)
+            };
+          }
           return {
             startDate: (0, import_date_fns2.sub)((0, import_date_fns2.startOfToday)(), { [interval2.unit]: interval2.value }),
             endDate: (0, import_date_fns2.endOfToday)()
           };
+        }
+        case "previous_month": {
+          const lastMonth = (0, import_date_fns2.subMonths)((0, import_date_fns2.startOfToday)(), 1);
+          return {
+            startDate: (0, import_date_fns2.startOfMonth)(lastMonth),
+            endDate: (0, import_date_fns2.endOfMonth)(lastMonth)
+          };
+        }
+        case "previous_quarter": {
+          const lastQuarter = (0, import_date_fns2.subQuarters)((0, import_date_fns2.startOfToday)(), 1);
+          return {
+            startDate: (0, import_date_fns2.startOfQuarter)(lastQuarter),
+            endDate: (0, import_date_fns2.endOfQuarter)(lastQuarter)
+          };
+        }
         case "repeating": {
           const currentDate = /* @__PURE__ */ new Date();
           const currentYear = currentDate.getFullYear();
@@ -1489,24 +1514,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 },
@@ -1586,9 +1626,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 },
@@ -1602,42 +1644,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 = [];
@@ -1679,8 +1748,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: (0, import_date_fns2.set)(/* @__PURE__ */ new Date(), {
                 year: currentYear,
@@ -1712,9 +1792,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,
@@ -1771,6 +1854,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 = [
@@ -1845,6 +1929,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",
@@ -15335,7 +15425,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 ? {
@@ -16224,6 +16317,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";
@@ -17797,6 +18012,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;
@@ -17805,11 +18036,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 = {};
@@ -19745,10 +19989,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 ?? [
             {
@@ -19759,18 +20007,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?.({
@@ -20178,6 +20448,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,
@@ -20192,14 +20500,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,
@@ -20219,7 +20528,7 @@ async function fetchReport({
     });
     const resp = await parseFetchResponse(
       client,
-      useReportTask ? "report" : "item",
+      usePivotTask ? "pivot-template" : useReportTask ? "report" : "item",
       fetchResp,
       getToken
     );
@@ -20227,12 +20536,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") {
@@ -20281,8 +20591,10 @@ async function processReportResponse({
   customFields,
   getToken,
   eventTracking,
-  tenants
+  tenants,
+  skipPivotFetch = false
 }) {
+  const shouldSkipPivotFetch = skipPivotFetch || !!resp?.pivotRows && !!resp?.fields;
   const dashboardItem = {
     ...resp,
     filtersApplied: filters?.filter(
@@ -20312,7 +20624,8 @@ async function processReportResponse({
     customFields,
     getToken,
     tenants,
-    eventTracking
+    eventTracking,
+    skipPivotFetch: shouldSkipPivotFetch
   });
   if (additionalProcessing) {
     reportInfo.pagination = additionalProcessing.page;
@@ -22341,6 +22654,34 @@ var ContextProvider = ({
       );
       if (currentProcessId === loadDashboardProcessId.current[dashboardName]) {
         if (!(0, import_fast_deep_equal.default)(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,
@@ -23156,11 +23497,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({
@@ -23182,11 +23524,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) {
@@ -23444,7 +23799,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,
@@ -23504,7 +23860,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,
@@ -23622,6 +23979,7 @@ var useDashboard = (dashboardName, config) => {
   const { customReportFilters } = (0, import_react2.useContext)(ReportFiltersContext);
   const { eventTracking } = (0, import_react2.useContext)(EventTrackingContext);
   const customFiltersRef = (0, import_react2.useRef)(customReportFilters);
+  const reportRequestIds = (0, import_react2.useRef)({});
   (0, import_react2.useEffect)(() => {
     customFiltersRef.current = customReportFilters;
   }, [customReportFilters]);
@@ -23764,6 +24122,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,
@@ -23781,6 +24141,7 @@ var useDashboard = (dashboardName, config) => {
         const additionalProcessing = {
           page: pagination
         };
+        const usePivotTask = !!reportInfo.pivot;
         const { report, error } = await fetchReport({
           reportId,
           client,
@@ -23789,12 +24150,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,
@@ -23808,6 +24173,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;
       })
     );
@@ -28108,6 +28507,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":
@@ -28172,6 +28573,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) {
@@ -28180,6 +28587,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,
@@ -32253,6 +32663,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({
@@ -32268,18 +32680,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({
@@ -32336,6 +32792,9 @@ function DataLoader({
       if (fetchRowsRequestId === rowsRequestId.current) {
         rowsAbortController.current = null;
         setLoading(false);
+        if (backgroundFetch) {
+          backgroundFetch();
+        }
       }
     }
   };
@@ -32400,7 +32859,11 @@ var ChartDataLoader = ({
   dashboardName,
   propagateChanges
 }) => {
-  const { dashboardReports: dashboard, addReport } = useDashboardReports(dashboardName);
+  const {
+    dashboardReports: dashboard,
+    addReport,
+    updateReport
+  } = useDashboardReports(dashboardName);
   const { dashboardFilters } = (0, import_react25.useContext)(DashboardFiltersContext);
   const { reports, fetchIndividualReport } = (0, import_react25.useContext)(ReportsContext);
   const { getToken } = (0, import_react25.useContext)(FetchContext);
@@ -32450,6 +32913,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({
@@ -32467,16 +32932,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({
@@ -32532,6 +33041,9 @@ var ChartDataLoader = ({
       if (fetchRowsRequestId === rowsRequestId.current) {
         fetchReportAbortController.current = null;
         setLoading(false);
+        if (backgroundFetch) {
+          backgroundFetch();
+        }
       }
     }
   };
@@ -38697,7 +39209,7 @@ function Dashboard({
                   filters: populatedDashboardFilters ?? [],
                   userFilters: dataLoaderUserFilters,
                   additionalProcessing: {
-                    page: DEFAULT_PAGINATION,
+                    page: pagination,
                     last: additionalProcessing?.last
                   },
                   dashboardName: name2,
@@ -40990,7 +41502,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
                                                     ),
@@ -41403,6 +41915,7 @@ init_Filter();
 init_filterProcessing();
 init_dateRangePickerUtils();
 var import_jsx_runtime63 = require("react/jsx-runtime");
+var MULTISELECT_REQUEST_DEBOUNCE_MS = 1e3;
 var TogglePrimitive = ({
   value,
   onClick,
@@ -41542,6 +42055,20 @@ function InternalChart({
     ) : defaultOptionsV2;
   }, [reportDateFilter]);
   const [filterValues, setFilterValues] = (0, import_react42.useState)({});
+  const multiselectDebounceRef = (0, import_react42.useRef)({});
+  const latestMultiselectValueRef = (0, import_react42.useRef)({});
+  const [lockedFilters, setLockedFilters] = (0, import_react42.useState)(
+    {}
+  );
+  (0, import_react42.useEffect)(() => {
+    return () => {
+      Object.values(multiselectDebounceRef.current).forEach((timer2) => {
+        if (timer2) {
+          clearTimeout(timer2);
+        }
+      });
+    };
+  }, []);
   (0, import_react42.useEffect)(() => {
     if (reportDateFilter) {
       const customDateFilter = filters?.find(
@@ -41648,6 +42175,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] = (0, import_react42.useState)(false);
@@ -41805,7 +42372,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"
@@ -43666,6 +44233,7 @@ function ChartBuilder({
           client,
           uniqueValues,
           dashboardName: destinationDashboardName,
+          dashboardFilters: dashboardFilters2,
           tenants,
           additionalProcessing: baseProcessing,
           getToken,
@@ -43777,7 +44345,7 @@ function ChartBuilder({
       }
       return filter;
     });
-    loadFiltersForReport(
+    return loadFiltersForReport(
       report?.id ?? TEMP_REPORT_ID,
       "ChartBuilder",
       updatedFilters,
@@ -43787,7 +44355,7 @@ function ChartBuilder({
     ).then(() => {
       setCurrentPage(0);
       setMaxPage(0);
-      handleRunQuery(baseProcessing, updatedFilters);
+      return handleRunQuery(baseProcessing, updatedFilters);
     });
   };
   const filtersEnabledRef = (0, import_react44.useRef)(filtersEnabled);
@@ -44346,12 +44914,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 {
@@ -48768,6 +49345,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;
     }
@@ -48775,8 +49360,8 @@ var useReportBuilderInternal = ({
       state,
       pivot: state.pivot,
       previousReport: report,
-      requiresNewFilteredUniqueValues: filtersChanged || limitChanged,
-      requiresNewUnfilteredUniqueValues: tablesChanged,
+      requiresNewFilteredUniqueValues: needsFilteredUniqueValues,
+      requiresNewUnfilteredUniqueValues: haveTablesChanged,
       skipPivotColumnFetch
     });
   };
@@ -49387,18 +49972,10 @@ var useReportBuilderInternal = ({
   }, [client]);
   (0, import_react48.useEffect)(() => {
     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,
@@ -52692,15 +53269,20 @@ function ChartEditor({
   const parentRef = (0, import_react55.useRef)(null);
   const [modalWidth, setModalWidth] = (0, import_react55.useState)(200);
   const [modalHeight, setModalHeight] = (0, import_react55.useState)(200);
-  const { addReport } = useDashboardReports(destinationDashboard);
   const { allReportsById } = useAllReports();
+  const report = allReportsById[reportId];
+  const resolvedDashboard = (0, import_react55.useMemo)(
+    () => destinationDashboard ?? report?.dashboardName ?? null,
+    [destinationDashboard, report?.dashboardName]
+  );
+  const { addReport } = useDashboardReports(resolvedDashboard ?? void 0);
   const { tenants, flags } = (0, import_react55.useContext)(TenantContext);
   const { getToken } = (0, import_react55.useContext)(FetchContext);
-  const report = allReportsById[reportId];
   const [client, isClientLoading] = (0, import_react55.useContext)(ClientContext);
   const [schemaData] = (0, import_react55.useContext)(SchemaDataContext);
   const { dashboardFilters } = (0, import_react55.useContext)(DashboardFiltersContext);
   const { eventTracking } = (0, import_react55.useContext)(EventTrackingContext);
+  const { reload } = useDashboardInternal(resolvedDashboard);
   const specificDashboardFilters = (0, import_react55.useMemo)(() => {
     if (!report) {
       return [];
@@ -52708,7 +53290,7 @@ function ChartEditor({
     return Object.values(dashboardFilters[report.dashboardName] || {}).map(
       (f) => f.filter
     );
-  }, [dashboardFilters]);
+  }, [dashboardFilters, report?.dashboardName]);
   const [filtersEnabled, setFiltersEnabled] = (0, import_react55.useState)(true);
   const [chartBuilderKey, setChartBuilderKey] = (0, import_react55.useState)(0);
   const dateFilter = Object.values(specificDashboardFilters).find(
@@ -52734,7 +53316,7 @@ function ChartEditor({
     };
   }, []);
   const fetchReportHelper = async (processing) => {
-    if (!client) {
+    if (!client || !reportId) {
       return;
     }
     const minimalFilters = Object.values(specificDashboardFilters).length ? Object.values(specificDashboardFilters).map((filter) => {
@@ -52766,10 +53348,13 @@ function ChartEditor({
     addReport(report2);
   };
   (0, import_react55.useEffect)(() => {
+    if (!isOpen || !reportId) {
+      return;
+    }
     if (!isClientLoading && !report) {
       fetchReportHelper();
     }
-  }, [reportId, isClientLoading, allReportsById]);
+  }, [reportId, isClientLoading, allReportsById, isOpen]);
   return /* @__PURE__ */ (0, import_jsx_runtime82.jsx)("div", { ref: parentRef, style: { height: "100%" }, children: /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(
     ModalComponent,
     {
@@ -52783,7 +53368,7 @@ function ChartEditor({
       title: chartBuilderTitle || "Add to dashboard",
       width: isHorizontalView ? modalWidth : void 0,
       height: isHorizontalView ? modalHeight : void 0,
-      children: allReportsById[reportId] ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(
+      children: reportId && allReportsById[reportId] ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(
         ChartBuilder,
         {
           reportId,
@@ -52798,8 +53383,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,