@quillsql/react 2.15.5 → 2.15.7

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, { get: all[name2], enumerable: true });
@@ -27,6 +30,358 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/pluralize/pluralize.js
+var require_pluralize = __commonJS({
+  "../../node_modules/pluralize/pluralize.js"(exports2, module2) {
+    "use strict";
+    (function(root, pluralize2) {
+      if (typeof require === "function" && typeof exports2 === "object" && typeof module2 === "object") {
+        module2.exports = pluralize2();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize2();
+        });
+      } else {
+        root.pluralize = pluralize2();
+      }
+    })(exports2, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token) return token;
+        if (word === word.toLowerCase()) return token.toLowerCase();
+        if (word === word.toUpperCase()) return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
+        return token.toLowerCase();
+      }
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word)) return replace(word, rule);
+        }
+        return word;
+      }
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
+      }
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) return true;
+          if (replaceMap.hasOwnProperty(token)) return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize2(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize2.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize2.addPluralRule(word, "$0");
+        pluralize2.addSingularRule(word, "$0");
+      };
+      pluralize2.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
+      };
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["passerby", "passersby"]
+      ].forEach(function(rule) {
+        return pluralize2.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize2.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize2.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        /pok[eé]mon$/i,
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize2.addUncountableRule);
+      return pluralize2;
+    });
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -70,6 +425,7 @@ __export(index_exports, {
   useQuill: () => useQuill,
   useReportBuilder: () => useReportBuilder,
   useReports: () => useReports,
+  useTenants: () => useTenants,
   useVirtualTables: () => useVirtualTables
 });
 module.exports = __toCommonJS(index_exports);
@@ -1379,6 +1735,7 @@ var DashboardFilterType = /* @__PURE__ */ ((DashboardFilterType4) => {
   DashboardFilterType4["Select"] = "select";
   DashboardFilterType4["MultiSelect"] = "multiselect";
   DashboardFilterType4["Date"] = "date";
+  DashboardFilterType4["Tenant"] = "tenant";
   return DashboardFilterType4;
 })(DashboardFilterType || {});
 var convertCustomFilter = (filter) => {
@@ -1632,6 +1989,16 @@ var convertInternalDashboardFilterToDashboardFilter = (filter) => {
       },
       options
     };
+  } else if (filter.filterType === "tenant" /* Tenant */) {
+    return {
+      label: filter.label,
+      type: "tenant" /* Tenant */,
+      value: filter.multiSelect ? filter.values ?? [] : filter.values?.[0] ?? null,
+      options: (filter.options ?? []).map((opt) => ({
+        label: opt.label,
+        value: opt.value
+      }))
+    };
   }
   throw new Error(
     "Unknown InternalDashboardFilterType: " + filter.filterType
@@ -17496,7 +17863,7 @@ async function generatePivotWithSQL({
     if (!itemQuery) {
       throw Error("No item query found in report");
     }
-    sqlQuery = pivotQuery ?? generatePivotQuery(
+    sqlQuery = generatePivotQuery(
       pivot,
       itemQuery,
       databaseType,
@@ -18814,10 +19181,15 @@ async function getPivotTable(report, dashboardFilters, dashboardName, getToken,
           });
         }
       }
+      const pivotQuery = generatePivotQuery(
+        pivot,
+        report.itemQuery?.[0],
+        client.databaseType
+      );
       return {
         rows: [],
         rowCount: 0,
-        pivotQuery: "",
+        pivotQuery: pivotQuery ?? "",
         columns
       };
     }
@@ -20129,6 +20501,8 @@ function extractAllReportValuesFromQuillInternalReport(reportInternal) {
     name: reportInternal.name,
     dashboardName: reportInternal.dashboardName,
     // section: reportInternal.section,
+    pagination: reportInternal.pagination,
+    sort: reportInternal.sort,
     rows: reportInternal.rows,
     columns: reportInternal.columns,
     chartType: reportInternal.chartType,
@@ -21298,7 +21672,19 @@ var DashboardFiltersContext = (0, import_react.createContext)({
   loadFiltersForDashboard: async () => {
   }
 });
-var TenantContext = (0, import_react.createContext)({});
+var TenantContext = (0, import_react.createContext)({
+  childTenantMappings: {},
+  viewerTenants: {},
+  viewerTenantsByOwner: {},
+  isLoadingMappedTenants: false,
+  isLoadingViewerTenants: false,
+  fetchViewerTenantsForDashboard: async () => {
+  },
+  fetchMappedTenantsForDashboard: async () => {
+  },
+  getMappedTenantsForDashboard: async () => void 0,
+  getViewerTenantsByOwner: async () => []
+});
 var FetchContext = (0, import_react.createContext)({
   getToken: async () => "",
   quillFetchWithToken: async () => ({ data: null })
@@ -21388,6 +21774,15 @@ var ContextProvider = ({
   const fetchSchemaProcessId = (0, import_react.useRef)(0);
   const currentTenant = (0, import_react.useRef)(null);
   const currentPublicKey = (0, import_react.useRef)(null);
+  const [childTenantMappings, setChildTenantMappings] = (0, import_react.useState)({});
+  const [viewerTenants, setViewerTenants] = (0, import_react.useState)({});
+  const [viewerTenantsByOwner, setViewerTenantsByOwner] = (0, import_react.useState)({});
+  const [isLoadingMappedTenants, setIsLoadingMappedTenants] = (0, import_react.useState)(false);
+  const [isLoadingViewerTenants, setIsLoadingViewerTenants] = (0, import_react.useState)(false);
+  const prevTenants = (0, import_react.useRef)(null);
+  const viewerTenantsRequests = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  const viewerTenantsByOwnerRequests = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  const mappedTenantsRequests = (0, import_react.useRef)(/* @__PURE__ */ new Set());
   const loadDashboardProcessId = (0, import_react.useRef)({});
   (0, import_react.useEffect)(() => {
     if (!theme) {
@@ -21736,7 +22131,7 @@ var ContextProvider = ({
     });
     await Promise.allSettled(
       filters.map(async (filter) => {
-        if (filter.filterType !== "string") {
+        if (filter.filterType === "date_range") {
           dashboardFiltersDispatch({
             type: "UPDATE_DASHBOARD_FILTER",
             dashboardName,
@@ -21760,6 +22155,10 @@ var ContextProvider = ({
           });
           return null;
         }
+        if (filter.filterType === "tenant") {
+          await fetchTenantFilterOptions(dashboardName, filter);
+          return null;
+        }
         const filterOptionsAbortController = new AbortController();
         filterOptionsAbortControllers.current.add(filterOptionsAbortController);
         try {
@@ -22121,7 +22520,8 @@ var ContextProvider = ({
         },
         task: "dashboards",
         metadata: {
-          clientId: publicKey2
+          clientId: publicKey2,
+          tenants
           // getSections: true, // skip fetching reports since 'dashboard' always does anyway
         },
         abortSignal: fetchDashboardsAbortController.current.signal,
@@ -22210,6 +22610,14 @@ var ContextProvider = ({
               loading: true
             };
           });
+          dashboard2.tenantFilters?.forEach(
+            (filter) => {
+              acc[dashboard2.name][filter.label] = {
+                filter: { ...filter, options: void 0 },
+                loading: true
+              };
+            }
+          );
           return acc;
         }, {})
       });
@@ -22285,6 +22693,180 @@ var ContextProvider = ({
       return { error: "Failed to fetch data" };
     }
   }
+  const getDashboardViewerTenants = async (dashboardName) => {
+    if (!populatedClient) {
+      return [];
+    }
+    const { data } = await quillFetchWithToken({
+      client: populatedClient,
+      task: "viewer-tenants",
+      metadata: {
+        dashboardName
+      }
+    });
+    return data?.viewerTenants || [];
+  };
+  const getOwnerViewerTenants = async (ownerTenant) => {
+    if (!populatedClient) {
+      return [];
+    }
+    const { data } = await quillFetchWithToken({
+      client: populatedClient,
+      task: "viewer-tenants-by-owner",
+      metadata: {
+        tenantField: ownerTenant
+      }
+    });
+    return data?.viewerTenants || [];
+  };
+  const getMappedTenants = async (tenantsParam, dashboardName) => {
+    if (!populatedClient) {
+      return {};
+    }
+    const { data, queries } = await quillFetchWithToken({
+      client: populatedClient,
+      task: "mapped-tenants",
+      metadata: {
+        tenants: tenantsParam,
+        dashboardName
+      }
+    });
+    const childTenants = data.queryOrder;
+    const queryResults = queries.queryResults.map((result) => {
+      return result?.rows?.map((row) => ({
+        value: row["flag"],
+        label: row["label"]
+      })) ?? null;
+    });
+    const mappedTenants = {};
+    await Promise.all(
+      childTenants.map(
+        async (tenant, index) => {
+          mappedTenants[tenant.tenantField] = queryResults[index];
+        }
+      )
+    );
+    return mappedTenants;
+  };
+  const fetchViewerTenantsForDashboard = (0, import_react.useCallback)(
+    async (dashboardName) => {
+      if (!populatedClient) return;
+      if (viewerTenantsRequests.current.has(dashboardName)) {
+        return;
+      }
+      if (viewerTenants[dashboardName]) {
+        return;
+      }
+      viewerTenantsRequests.current.add(dashboardName);
+      setIsLoadingViewerTenants(true);
+      try {
+        const viewerTenantsData = await getDashboardViewerTenants(dashboardName);
+        setViewerTenants((prev) => ({
+          ...prev,
+          [dashboardName]: viewerTenantsData
+        }));
+      } catch (error) {
+        console.error("Error fetching viewer tenants:", error);
+      } finally {
+        viewerTenantsRequests.current.delete(dashboardName);
+        setIsLoadingViewerTenants(false);
+      }
+    },
+    [populatedClient]
+  );
+  const fetchMappedTenantsForDashboard = async (dashboardName) => {
+    await getMappedTenantsForDashboard(dashboardName);
+    return;
+  };
+  const getMappedTenantsForDashboard = (0, import_react.useCallback)(
+    async (dashboardName) => {
+      if (!populatedClient || !tenants) return void 0;
+      const tenantsChanged = !(0, import_fast_deep_equal.default)(prevTenants.current, tenants);
+      if (childTenantMappings[dashboardName] && !tenantsChanged) {
+        return childTenantMappings[dashboardName];
+      }
+      if (mappedTenantsRequests.current.has(dashboardName) && !tenantsChanged) {
+        return new Promise((resolve) => {
+          const checkInterval = setInterval(() => {
+            if (!mappedTenantsRequests.current.has(dashboardName)) {
+              clearInterval(checkInterval);
+              resolve(childTenantMappings[dashboardName]);
+            }
+          }, 100);
+        });
+      }
+      prevTenants.current = tenants;
+      mappedTenantsRequests.current.add(dashboardName);
+      setIsLoadingMappedTenants(true);
+      try {
+        const mappedTenants = await getMappedTenants(tenants, dashboardName);
+        setChildTenantMappings((prev) => ({
+          ...prev,
+          [dashboardName]: mappedTenants
+        }));
+        return mappedTenants;
+      } catch (error) {
+        console.error("Error fetching mapped tenants:", error);
+        setChildTenantMappings((prev) => ({
+          ...prev,
+          [dashboardName]: {}
+        }));
+        return void 0;
+      } finally {
+        mappedTenantsRequests.current.delete(dashboardName);
+        setIsLoadingMappedTenants(false);
+      }
+    },
+    [populatedClient, tenants, childTenantMappings]
+  );
+  const getViewerTenantsByOwner = (0, import_react.useCallback)(
+    async (ownerTenant) => {
+      if (!populatedClient) return [];
+      if (viewerTenantsByOwner[ownerTenant]) {
+        return viewerTenantsByOwner[ownerTenant];
+      }
+      if (viewerTenantsByOwnerRequests.current.has(ownerTenant)) {
+        return new Promise((resolve) => {
+          const checkInterval = setInterval(() => {
+            if (!viewerTenantsByOwnerRequests.current.has(ownerTenant)) {
+              clearInterval(checkInterval);
+              resolve(viewerTenantsByOwner[ownerTenant] || []);
+            }
+          }, 100);
+        });
+      }
+      viewerTenantsByOwnerRequests.current.add(ownerTenant);
+      setIsLoadingViewerTenants(true);
+      try {
+        const viewerTenantsData = await getOwnerViewerTenants(ownerTenant);
+        setViewerTenantsByOwner((prev) => ({
+          ...prev,
+          [ownerTenant]: viewerTenantsData
+        }));
+        return viewerTenantsData;
+      } catch (error) {
+        console.error("Error fetching viewer tenants by owner:", error);
+        return [];
+      } finally {
+        viewerTenantsByOwnerRequests.current.delete(ownerTenant);
+        setIsLoadingViewerTenants(false);
+      }
+    },
+    [populatedClient, viewerTenantsByOwner]
+  );
+  const fetchTenantFilterOptions = async (dashboardName, filter) => {
+    const mappings = await getMappedTenantsForDashboard(dashboardName);
+    const options = mappings?.[filter.field] ?? [];
+    dashboardFiltersDispatch({
+      type: "UPDATE_DASHBOARD_FILTER",
+      dashboardName,
+      filterName: filter.label,
+      data: {
+        filter: { ...filter, options },
+        loading: false
+      }
+    });
+  };
   (0, import_react.useEffect)(() => {
     async function updateClientAndSchema(publicKey2) {
       if (!publicKey2 || populatedClient?.clientId === publicKey2 && populatedClient?.allTenantTypes?.length)
@@ -22443,7 +23025,17 @@ var ContextProvider = ({
                             {
                               value: {
                                 tenants: populatedClient?.currentTenants ?? tenants,
-                                flags: populatedClient?.currentFlags ?? flags
+                                flags: populatedClient?.currentFlags ?? flags,
+                                childTenantMappings,
+                                viewerTenants,
+                                viewerTenantsByOwner,
+                                isLoadingMappedTenants,
+                                isLoadingViewerTenants,
+                                fetchViewerTenantsForDashboard,
+                                // fetchViewerTenantsByOwner,
+                                fetchMappedTenantsForDashboard,
+                                getMappedTenantsForDashboard,
+                                getViewerTenantsByOwner
                               },
                               children
                             }
@@ -22531,7 +23123,7 @@ var useDashboardInternal = (dashboardName, customFilters) => {
     );
     if (!fetchFromServer && Object.keys(dashboardFilters[dashboardName] ?? {}).length && // there exists no non date filter that has undefined options
     Object.values(dashboardFilters[dashboardName] ?? {}).every(
-      (filter) => filter.filter.filterType === "date_range" /* Date */ || filter.filter.options
+      (filter) => filter.filter.filterType === "date_range" /* Date */ || filter.filter.filterType === "tenant" /* Tenant */ || filter.filter.options
     )) {
       return;
     }
@@ -22548,6 +23140,9 @@ var useDashboardInternal = (dashboardName, customFilters) => {
         ...updatedDashboard?.filters?.map((filter) => ({
           ...filter,
           query: void 0
+        })) ?? [],
+        ...updatedDashboard?.tenantFilters?.map((filter) => ({
+          ...filter
         })) ?? []
       ],
       void 0,
@@ -22738,8 +23333,10 @@ var useDashboards = () => {
       (a, b) => (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0)
     );
   }, [dashboardConfig]);
+  const { getMappedTenantsForDashboard } = (0, import_react2.useContext)(TenantContext);
   const createDashboard = async ({
     name: name2,
+    tenantFilters,
     filters,
     dateFilter,
     dashboardOwners
@@ -22756,6 +23353,7 @@ var useDashboards = () => {
           tenantKeys: dashboardOwners,
           dashboardId: name2,
           name: name2,
+          allTenantFilters: tenantFilters ?? [],
           filters,
           dateFilter
         },
@@ -22764,6 +23362,7 @@ var useDashboards = () => {
     });
     const body = {
       newDashboardName: name2.trim(),
+      tenantFilters,
       filters,
       dateFilter,
       name: name2.trim(),
@@ -22816,6 +23415,7 @@ var useDashboards = () => {
   const updateDashboard = async (name2, {
     newName,
     filters,
+    tenantFilters,
     dateFilter,
     customFilters,
     tenantKeys
@@ -22837,6 +23437,7 @@ var useDashboards = () => {
     const body = {
       newDashboardName: newName.trim(),
       filters,
+      tenantFilters,
       dateFilter: dateFilter ?? null,
       name: name2.trim(),
       task: "edit-dashboard",
@@ -22866,6 +23467,7 @@ var useDashboards = () => {
           config: {
             ...dashboard,
             ...updated.data.dashboard,
+            allTenantFilters: tenantFilters ?? [],
             dateFilter: updated.data.dashboard.dateFilter ? {
               ...updated.data.dashboard.dateFilter,
               presetOptions: updated.data.dashboard.dateFilter.presetOptions?.map(
@@ -22960,6 +23562,8 @@ var useDashboards = () => {
         endDate: !range.endDate || range.endDate instanceof Date ? range.endDate : new Date(range.endDate)
         // when range.endDate is a string
       } : void 0;
+      const mappedTenants = await getMappedTenantsForDashboard(newName);
+      const mappedTenantKeys = Object.keys(mappedTenants ?? {});
       const newFilters = [
         ...updatedDateFilter ? [updatedDateFilter] : [],
         ...updated.data.dashboard.filters.map(
@@ -22969,14 +23573,22 @@ var useDashboards = () => {
             values: oldFilters?.[f.label]?.filter?.values,
             operator: oldFilters?.[f.label]?.filter?.operator
           })
-        ) ?? []
+        ) ?? [],
+        ...(updated.data.dashboard.tenantFilters?.map(
+          (f) => ({
+            ...f,
+            values: oldFilters?.[f.label]?.filter?.values
+          })
+        ) ?? []).filter((filter) => {
+          return mappedTenantKeys.includes(filter.field);
+        })
       ].map((f) => {
         if (f.filterType === "date_range" /* Date */) {
           return {
             ...f,
-            startDate: dashboardFilters[name2]?.[f.label]?.filter?.startDate,
-            endDate: dashboardFilters[name2]?.[f.label]?.filter?.endDate,
-            preset: dashboardFilters[name2]?.[f.label]?.filter?.preset
+            startDate: dashboardFilters[name2]?.[f.label]?.filter?.startDate ?? f.startDate,
+            endDate: dashboardFilters[name2]?.[f.label]?.filter?.endDate ?? f.endDate,
+            preset: dashboardFilters[name2]?.[f.label]?.filter?.preset ?? f.preset
           };
         } else {
           return {
@@ -23035,7 +23647,7 @@ var useDashboards = () => {
     deleteDashboard
   };
 };
-var useDashboard = (dashboardName) => {
+var useDashboard = (dashboardName, config) => {
   const { data, dashboardFilters, reload, isLoading } = useDashboardInternal(dashboardName);
   const { customFilterDispatch } = (0, import_react2.useContext)(DashboardFiltersContext);
   const { reportsDispatch, reportsLoadingStateDispatch } = (0, import_react2.useContext)(ReportsContext);
@@ -23076,7 +23688,7 @@ var useDashboard = (dashboardName) => {
   (0, import_react2.useEffect)(() => {
     if (!fetchedInitialReports.current && data) {
       fetchedInitialReports.current = true;
-      fetchReports([], dashboardFilters ?? []);
+      fetchReports([], dashboardFilters ?? [], config?.pageSize);
     }
   }, [fetchedInitialReports, data, dashboardFilters]);
   const applyDashboardFilters = (filtersToUpdate) => {
@@ -23118,6 +23730,20 @@ var useDashboard = (dashboardName) => {
             endDate: value.endDate
           };
         }
+      } else if (f.filterType === "tenant" /* Tenant */) {
+        const value = update.value;
+        let values;
+        if (Array.isArray(value)) {
+          values = value;
+        } else if (typeof value === "string") {
+          values = [value];
+        } else {
+          values = [];
+        }
+        return {
+          ...f,
+          values
+        };
       }
       return f;
     });
@@ -23169,24 +23795,39 @@ var useDashboard = (dashboardName) => {
     }
     return [];
   };
-  const fetchReports = async (customFilters, dashboardFilters2) => {
+  const fetchReports = async (customFilters, dashboardFilters2, pageSize) => {
     if (!client || !sections) return;
-    const allReportIds = Object.values(sections).flatMap(
-      (reports) => reports.map((report) => report.id)
-    );
+    const allReports = Object.values(sections).flat();
     await Promise.all(
-      allReportIds.map(async (reportId) => {
+      allReports.map(async (reportInfo) => {
+        const reportId = reportInfo.id;
         reportsLoadingStateDispatch({
           type: "SET_REPORT_LOADING",
           id: reportId,
           data: true
         });
         const customReportFiltersArray = await waitForCustomFilters(reportId);
+        let rowsPerRequest = pageSize || 600;
+        if (!pageSize) {
+          if (reportInfo.chartType === "table") {
+            rowsPerRequest = 10;
+          } else if (reportInfo.chartType === "metric") {
+            rowsPerRequest = 1;
+          }
+        }
+        const pagination = {
+          rowsPerRequest,
+          rowsPerPage: rowsPerRequest
+        };
+        const additionalProcessing = rowsPerRequest ? {
+          page: pagination
+        } : void 0;
         const { report, error } = await fetchReport({
           reportId,
           client,
           tenants,
           flags,
+          additionalProcessing,
           filters: dashboardFilters2.concat(customFilters).concat(customReportFiltersArray),
           getToken,
           eventTracking
@@ -23198,7 +23839,10 @@ var useDashboard = (dashboardName) => {
         reportsDispatch({
           type: "UPDATE_REPORT",
           id: reportId,
-          data: report
+          data: {
+            ...report,
+            pagination
+          }
         });
         reportsLoadingStateDispatch({
           type: "SET_REPORT_LOADING",
@@ -23216,7 +23860,7 @@ var useDashboard = (dashboardName) => {
     applyFilters
   };
 };
-var useDashboardReport = (reportId, config) => {
+var useDashboardReportInternal = (reportId, config) => {
   const {
     reports,
     reportsLoadingState,
@@ -23228,13 +23872,15 @@ var useDashboardReport = (reportId, config) => {
   const [client] = (0, import_react2.useContext)(ClientContext);
   const { getToken } = (0, import_react2.useContext)(FetchContext);
   const { eventTracking } = (0, import_react2.useContext)(EventTrackingContext);
-  const { customReportFiltersDispatch } = (0, import_react2.useContext)(ReportFiltersContext);
+  const { customReportFilters, customReportFiltersDispatch } = (0, import_react2.useContext)(ReportFiltersContext);
   const { dashboardCustomFilters } = (0, import_react2.useContext)(DashboardFiltersContext);
   const {
     data: dashboardData,
     dashboardFilters: dashboardFiltersInternal,
     reload: reloadDashboard
   } = useDashboardInternal(reports[reportId]?.dashboardName ?? null);
+  const [pageLoading, setPageLoading] = (0, import_react2.useState)(false);
+  const [maxPage, setMaxPage] = (0, import_react2.useState)(0);
   (0, import_react2.useEffect)(() => {
     if (config?.initialFilters) {
       customReportFiltersDispatch({
@@ -23272,11 +23918,16 @@ var useDashboardReport = (reportId, config) => {
     const dashboardFiltersArray = dashboardFiltersInternal ?? [];
     const dashboardCustomFiltersArray = dashboardCustomFilters[processedReport?.dashboardName ?? ""] ?? [];
     const requestFilters = filters.map(convertCustomFilter).concat(dashboardCustomFiltersArray).concat(dashboardFiltersArray);
+    const pagination = processedReport?.pagination;
+    const additionalProcessing = {
+      page: pagination
+    };
     const { report, error } = await fetchReport({
       reportId,
       client,
       tenants,
       flags,
+      additionalProcessing,
       filters: requestFilters,
       getToken,
       eventTracking
@@ -23332,11 +23983,138 @@ var useDashboardReport = (reportId, config) => {
       });
     }
   };
+  const updateReportTableRows = async (processing, appendRows) => {
+    if (!client) {
+      return;
+    }
+    setPageLoading(true);
+    const dashboardFiltersArray = dashboardFiltersInternal ?? [];
+    const dashboardCustomFiltersArray = dashboardCustomFilters[processedReport?.dashboardName ?? ""] ?? [];
+    const reportCustomFiltersArray = customReportFilters[reportId] ?? [];
+    const filters = reportCustomFiltersArray.concat(dashboardFiltersArray).concat(dashboardCustomFiltersArray);
+    const pivot = processedReport?.pivot;
+    const pivotQuery = reports[reportId]?.pivotQuery;
+    const { rows } = await fetchResultsByReport({
+      reportId,
+      client,
+      tenants,
+      processing,
+      filters,
+      getToken,
+      eventTracking,
+      pivot,
+      pivotQuery
+    });
+    if (pivot && pivotQuery) {
+      const currRows = reports[reportId]?.pivotRows || [];
+      const updatedRows = appendRows ? [...currRows, ...rows] : rows;
+      reportsDispatch({
+        type: "UPDATE_REPORT",
+        id: reportId,
+        data: {
+          pivotRows: updatedRows,
+          pagination: processing.page,
+          sort: processing.sort
+        }
+      });
+    } else {
+      const currRows = reports[reportId]?.rows || [];
+      const updatedRows = appendRows ? [...currRows, ...rows] : rows;
+      reportsDispatch({
+        type: "UPDATE_REPORT",
+        id: reportId,
+        data: {
+          rows: updatedRows,
+          pagination: processing.page,
+          sort: processing.sort
+        }
+      });
+    }
+    setMaxPage(processing.page?.page || 0);
+    setPageLoading(false);
+  };
+  const handleNextPage = async () => {
+    if (!processedReport?.pagination) {
+      return;
+    }
+    const currPage = processedReport.pagination.page || 0;
+    const updatedPage = {
+      ...processedReport.pagination,
+      page: currPage + 1
+    };
+    if (shouldFetchMore(updatedPage, currPage + 1, maxPage)) {
+      const sort = processedReport?.sort;
+      updateReportTableRows({ page: updatedPage, sort }, true);
+    } else {
+      reportsDispatch({
+        type: "UPDATE_REPORT",
+        id: reportId,
+        data: {
+          pagination: updatedPage
+        }
+      });
+    }
+  };
+  const handlePrevPage = async () => {
+    if (!processedReport?.pagination) {
+      return;
+    }
+    const currPage = processedReport.pagination.page || 0;
+    const updatedPage = {
+      ...processedReport.pagination,
+      page: currPage - 1
+    };
+    reportsDispatch({
+      type: "UPDATE_REPORT",
+      id: reportId,
+      data: {
+        pagination: updatedPage
+      }
+    });
+  };
+  const handleSort = async (sort) => {
+    const currSort = processedReport?.sort;
+    const currPagination = processedReport?.pagination;
+    const newPagination = currPagination ? { ...currPagination, page: 0 } : void 0;
+    if (currSort?.field !== sort.field || currSort?.direction?.toLowerCase() !== sort?.direction?.toLowerCase()) {
+      updateReportTableRows({ page: newPagination, sort }, false);
+    }
+  };
   return {
     report: reportsLoadingState[reportId] ? null : processedReport,
     loading: !!reportsLoadingState[reportId],
     applyFilters: setReportFilters,
-    deleteReport
+    deleteReport,
+    pageNumber: processedReport?.pagination?.page || 0,
+    pageLoading,
+    nextPage: handleNextPage,
+    prevPage: handlePrevPage,
+    sortRows: handleSort
+  };
+};
+var useDashboardReport = (reportId, config) => {
+  const { report, loading, applyFilters, deleteReport, nextPage } = useDashboardReportInternal(reportId, config);
+  const fetchingRef = (0, import_react2.useRef)(false);
+  const fetchNextPage = async () => {
+    if (fetchingRef.current) {
+      return;
+    }
+    try {
+      fetchingRef.current = true;
+      await nextPage();
+    } catch (error) {
+      console.error("Error fetching page:", error.message);
+    } finally {
+      fetchingRef.current = false;
+    }
+  };
+  return {
+    report,
+    isLoading: loading || fetchingRef.current,
+    loading: loading || fetchingRef.current,
+    applyFilters,
+    deleteReport,
+    fetchNextPage
   };
 };
 
@@ -23577,7 +24355,7 @@ var useExport = (reportId, {
       } else {
         const rows = report.rows;
         for (let i = 0; i < rows.length; i += maximumRowsPerPage) {
-          const remainingRows = (rows.length - i) * maximumRowsPerPage;
+          const remainingRows = rows.length - i;
           const availableSpace = maximumRowsPerPage - currentCount;
           const rowsToAdd = Math.min(remainingRows, availableSpace);
           currentCount += rowsToAdd;
@@ -25139,7 +25917,7 @@ var MemoizedButton = ({
 }) => {
   const [theme] = (0, import_react11.useContext)(ThemeContext);
   return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
-    QuillToolTip,
+    QuillToolTipPortal,
     {
       enabled: !!tooltipText && tooltipText !== "",
       text: tooltipText ?? "",
@@ -26376,6 +27154,140 @@ var QuillToolTip = ({
     /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("div", { className: "tooltip-text", style: { ...textStyle }, children: text })
   ] }) : children;
 };
+var QuillToolTipPortal = ({
+  children,
+  text,
+  enabled = true,
+  containerStyle = {},
+  textStyle = {},
+  mirror = false
+}) => {
+  const [theme] = (0, import_react11.useContext)(ThemeContext);
+  const [isOpen, setIsOpen] = (0, import_react11.useState)(false);
+  const tooltipRef = (0, import_react11.useRef)(null);
+  const triggerRef = (0, import_react11.useRef)(null);
+  const [tooltipPosition, setTooltipPosition] = (0, import_react11.useState)(void 0);
+  const updatePosition = () => {
+    if (triggerRef.current && tooltipRef.current) {
+      const rect = triggerRef.current.getBoundingClientRect();
+      const tooltipRect = tooltipRef.current.getBoundingClientRect();
+      const viewportWidth = window.innerWidth;
+      let top = rect.top + window.scrollY - tooltipRect.height - 8;
+      let left = rect.left + window.scrollX;
+      if (!mirror) {
+        left = rect.left + rect.width / 2 - tooltipRect.width / 2 + window.scrollX;
+      } else {
+        left = rect.right - tooltipRect.width + window.scrollX;
+      }
+      if (left + tooltipRect.width > viewportWidth) {
+        left = viewportWidth - tooltipRect.width - 16;
+      }
+      if (left < 16) {
+        left = 16;
+      }
+      if (top < window.scrollY + 16) {
+        top = rect.bottom + window.scrollY + 8;
+      }
+      setTooltipPosition({ top, left });
+    }
+  };
+  (0, import_react11.useEffect)(() => {
+    if (isOpen) {
+      const timer2 = setTimeout(() => {
+        updatePosition();
+      }, 0);
+      window.addEventListener("resize", updatePosition, { passive: true });
+      window.addEventListener("scroll", updatePosition, { passive: true });
+      return () => {
+        clearTimeout(timer2);
+        window.removeEventListener("resize", updatePosition);
+        window.removeEventListener("scroll", updatePosition);
+      };
+    }
+  }, [isOpen]);
+  if (!enabled) {
+    return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(import_jsx_runtime26.Fragment, { children });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+    "div",
+    {
+      ref: triggerRef,
+      style: {
+        display: "inline-block",
+        position: "relative",
+        ...containerStyle
+      },
+      onMouseEnter: () => setIsOpen(true),
+      onMouseLeave: () => setIsOpen(false),
+      children: [
+        children,
+        isOpen && (0, import_react_dom2.createPortal)(
+          /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+            "div",
+            {
+              ref: tooltipRef,
+              style: {
+                visibility: tooltipPosition ? "visible" : "hidden",
+                position: "absolute",
+                top: `${tooltipPosition?.top ?? 0}px`,
+                left: `${tooltipPosition?.left ?? 0}px`,
+                backgroundColor: "#ffffff",
+                color: "#212121",
+                textAlign: "center",
+                borderRadius: 5,
+                zIndex: 100,
+                padding: 10,
+                fontFamily: theme?.fontFamily,
+                fontWeight: 600,
+                fontSize: "small",
+                whiteSpace: "nowrap",
+                borderWidth: 1,
+                borderStyle: "solid",
+                borderColor: "#e7e7e7",
+                boxShadow: "0px 1px 8px rgba(0, 0, 0, 0.07)",
+                ...textStyle
+              },
+              children: [
+                text,
+                /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+                  "div",
+                  {
+                    style: {
+                      position: "absolute",
+                      top: "100%",
+                      left: "50%",
+                      marginLeft: -6,
+                      borderWidth: 6,
+                      borderStyle: "solid",
+                      borderColor: "transparent",
+                      borderTopColor: "#e7e7e7"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+                  "div",
+                  {
+                    style: {
+                      position: "absolute",
+                      top: "100%",
+                      left: "50%",
+                      marginLeft: -5,
+                      borderWidth: 5,
+                      borderStyle: "solid",
+                      borderColor: "transparent",
+                      borderTopColor: "#ffffff"
+                    }
+                  }
+                )
+              ]
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  );
+};
 var QuillChartBuilderCheckboxComponent = ({
   isChecked,
   label,
@@ -29428,7 +30340,7 @@ function QuillMultiSelectComponentWithCombo({
   );
   const potentialOptions = (0, import_react20.useMemo)(() => {
     return value.filter((opt) => !optionValues.has(opt ?? "")).map((opt) => ({
-      label: opt === "" ? "-" : opt ?? "-",
+      label: opt === "" ? "-" : opt?.toString() ?? "-",
       value: opt ?? ""
     })).concat(options);
   }, [value, options]);
@@ -29445,7 +30357,9 @@ function QuillMultiSelectComponentWithCombo({
     if (matchingOptions.length === options.length && allSelectedLabel) {
       return allSelectedLabel;
     }
-    return matchingOptions.map((elem) => elem.label ?? "-").join(", ");
+    return matchingOptions.map(
+      (elem) => elem.label ?? "-"
+    ).join(", ");
   }, [options, value]);
   const [selectAllCheckboxState, setSelectAllCheckboxState] = (0, import_react20.useState)(
     (() => {
@@ -30171,7 +31085,7 @@ function QuillSelectComponentWithCombo({
                     textOverflow: "ellipsis",
                     whiteSpace: "nowrap",
                     overflow: "hidden",
-                    fontWeight: value?.length || isLoading ? void 0 : 300
+                    fontWeight: value?.toString()?.length || isLoading ? void 0 : 300
                   },
                   children: selectedLabel
                 }
@@ -30513,6 +31427,51 @@ function DashboardFilter2({
         ]
       }
     ) });
+  } else if (filter.filterType === "tenant") {
+    if (filter.multiSelect) {
+      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("div", { style: containerStyle, children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+        QuillMultiSelectComponentWithCombo,
+        {
+          label: filter.label,
+          value: filter.values ?? [],
+          onChange: (e) => {
+            if (Array.isArray(e.target.value) && e.target.value.length === 0) {
+              onChangeFilter(filter, void 0);
+              return;
+            }
+            onChangeFilter(filter, e.target.value);
+          },
+          options: [
+            ...filter.options ? filter.options.map((elem) => ({
+              label: elem.label,
+              value: elem.value
+            })) : []
+          ],
+          width: 200,
+          isLoading,
+          disabled
+        }
+      ) });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("div", { style: containerStyle, children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+      QuillSelectComponentWithCombo,
+      {
+        label: filter.label,
+        value: filter.values?.[0] ?? "",
+        onChange: (e) => {
+          onChangeFilter(filter, e.target.value);
+        },
+        options: [
+          ...filter.options ? filter.options.map((elem) => ({
+            label: elem.label,
+            value: elem.value
+          })) : []
+        ],
+        width: 200,
+        isLoading,
+        disabled
+      }
+    ) });
   }
   return null;
 }
@@ -33997,11 +34956,13 @@ function Chart({
   (0, import_react29.useEffect)(() => {
     setFilterValues(
       Object.values(reportFilters[reportId] ?? {}).reduce((acc, f) => {
-        acc[f.filter.label] = f.filter.filterType === "string" ? f.filter.stringFilterType === "multiselect" ? { values: f.filter.values, operator: "IN" } : { selectedValue: f.filter.selectedValue } : {
+        acc[f.filter.label] = f.filter.filterType === "string" ? f.filter.stringFilterType === "multiselect" ? { values: f.filter.values, operator: "IN" } : { selectedValue: f.filter.selectedValue } : f.filter.filterType === "date_range" ? {
           startDate: f.filter.startDate,
           endDate: f.filter.endDate,
           preset: f.filter.preset,
           comparisonRange: f.filter.comparisonRange
+        } : {
+          values: f.filter.values
         };
         return acc;
       }, {})
@@ -34125,6 +35086,10 @@ function Chart({
           }
         };
       }
+    } else if (filter.filterType === "tenant" /* Tenant */) {
+      filterValue = {
+        values: value ? Array.isArray(value) ? value : [value] : []
+      };
     }
     setFilterValues((filterValues2) => ({
       ...filterValues2,
@@ -34355,7 +35320,8 @@ var ChartDisplay = ({
   onClickChartElement,
   overrideTheme,
   referenceLines,
-  showLegend = false
+  showLegend = false,
+  tableRowsLoading = false
 }) => {
   const { downloadCSV: downloadCSV2 } = useExport(reportId);
   const [theme] = (0, import_react29.useContext)(ThemeContext);
@@ -34450,7 +35416,8 @@ var ChartDisplay = ({
         },
         onSortChange: (sort) => {
           onSortChange && onSortChange(sort);
-        }
+        },
+        isLoading: tableRowsLoading
       }
     );
   }
@@ -36771,11 +37738,13 @@ function Dashboard({
   (0, import_react37.useEffect)(() => {
     setFilterValues(
       Object.values(populatedDashboardFilters ?? {}).reduce((acc, f) => {
-        acc[f.label] = f.filterType === "string" ? f.stringFilterType === "multiselect" ? { values: f.values, operator: "IN" } : { selectedValue: f.selectedValue } : {
+        acc[f.label] = f.filterType === "string" ? f.stringFilterType === "multiselect" ? { values: f.values, operator: "IN" } : { selectedValue: f.selectedValue } : f.filterType === "date_range" ? {
           startDate: f.startDate,
           endDate: f.endDate,
           preset: f.preset,
           comparisonRange: f.comparisonRange
+        } : {
+          values: f.values
         };
         return acc;
       }, {})
@@ -36920,6 +37889,10 @@ function Dashboard({
           }
         };
       }
+    } else if (filter.filterType === "tenant" /* Tenant */) {
+      filterValue = {
+        values: value ? Array.isArray(value) ? value : [value] : []
+      };
     }
     setFilterValues((filterValues2) => ({
       ...filterValues2,
@@ -40291,6 +41264,10 @@ function InternalChart({
           }
         };
       }
+    } else if (filter.filterType === "tenant" /* Tenant */) {
+      filterValue = {
+        values: value ? Array.isArray(value) ? value : [value] : []
+      };
     }
     setFilterValues((filterValues2) => ({
       ...filterValues2,
@@ -41112,6 +42089,7 @@ var ListboxTextInput2 = ({
 };
 
 // src/ChartBuilder.tsx
+var import_pluralize = __toESM(require_pluralize(), 1);
 var import_jsx_runtime65 = require("react/jsx-runtime");
 var CHART_TYPES = [
   "column",
@@ -41558,7 +42536,7 @@ function ChartBuilder({
   const validFilter = (0, import_react43.useMemo)(() => {
     return specificDashboardFilters.reduce(
       (acc, filter) => {
-        if (filter.filterType === "date_range") {
+        if (filter.filterType === "date_range" || filter.filterType === "tenant") {
           acc[filter.label] = true;
           return acc;
         }
@@ -42701,6 +43679,30 @@ function ChartBuilder({
     setIsSubmitting(false);
     setTriggeredEditChart(false);
   };
+  const memoizedTooltipText = (0, import_react43.useMemo)(() => {
+    const getTooltipText = () => {
+      if (formData.name === "") {
+        return "Please enter a name for the chart";
+      }
+      if (formData.dashboardName === "") {
+        return "Please select a dashboard";
+      }
+      if (formData.chartType === "") {
+        return "Please select a chart type";
+      }
+      if (filterIssues.length !== 0) {
+        return "Please fix the filter issues";
+      }
+      if (Object.values(validFilter).includes(false)) {
+        return "Please fix the filter issues";
+      }
+      if (currentDashboard?.tenantKeys && customTenantAccess && Object.values(formFlags ?? {}).every((value) => !value.length)) {
+        return "Please fix the tenant issues";
+      }
+      return "";
+    };
+    return getTooltipText();
+  }, [formData, filterIssues, validFilter, formFlags, currentDashboard]);
   isHorizontalView = windowWidth < 1200 ? false : isHorizontalView;
   if (!schemaData.schema) {
     return /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("div", { children: "No schema" });
@@ -43790,7 +44792,7 @@ function ChartBuilder({
                                           })) ?? [],
                                           width: 200,
                                           emptyLabel: dashboardOwner.scope === "database" ? "No tags supplied" : void 0,
-                                          allSelectedLabel: "All " + dashboardOwner.name + "s",
+                                          allSelectedLabel: "All " + (0, import_pluralize.default)(dashboardOwner.name),
                                           style: {
                                             display: customTenantAccess || containsCustomFields ? "inline" : "none",
                                             marginTop: -1,
@@ -43815,7 +44817,7 @@ function ChartBuilder({
                                             {}
                                           ) ?? {},
                                           width: 200,
-                                          allSelectedLabel: "All " + dashboardOwner.name + "s",
+                                          allSelectedLabel: "All " + (0, import_pluralize.default)(dashboardOwner.name),
                                           style: {
                                             display: customTenantAccess || containsCustomFields ? "inline" : "none",
                                             marginTop: -1,
@@ -43920,7 +44922,7 @@ function ChartBuilder({
                                   gap: 6
                                 },
                                 children: specificDashboardFilters.filter((f) => {
-                                  return f.filterType !== "date_range";
+                                  return f.filterType === "string";
                                 }).map((filter, index) => /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(ChartBuilderInputRowContainer, { children: [
                                   /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
                                     TextInputComponent,
@@ -44098,6 +45100,7 @@ function ChartBuilder({
                                           disabled: formData.name === "" || formData.dashboardName === "" || formData.chartType === "" || filterIssues.length !== 0 || Object.values(validFilter).includes(false) || currentDashboard?.tenantKeys && customTenantAccess && Object.values(formFlags ?? {}).every(
                                             (value) => !value.length
                                           ),
+                                          tooltipText: memoizedTooltipText,
                                           label: buttonLabel ? buttonLabel : report ? "Save changes" : "Add to dashboard"
                                         }
                                       )
@@ -50066,7 +51069,8 @@ var SaveReport = ({
       reportBuilder,
       setIsOpen
     }
-  )
+  ),
+  submitButtonLabel
 }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime79.jsxs)("div", { children: [
     SaveTrigger,
@@ -50109,7 +51113,7 @@ var SaveReport = ({
         FormContainer: ChartBuilderFormContainer,
         hideDateRangeFilter: true,
         hideDeleteButton: true,
-        buttonLabel: !!reportBuilder.reportId ? "Save changes" : "Add to dashboard",
+        buttonLabel: submitButtonLabel ?? (!!reportBuilder.reportId ? "Save changes" : "Add to dashboard"),
         onClickChartElement,
         isEditingMode: true
       }
@@ -50208,7 +51212,8 @@ function ReportBuilder({
   hideCopySQL = true,
   isChartBuilderHorizontalView = true,
   onClickChartElement,
-  onRequestAddVirtualTable
+  onRequestAddVirtualTable,
+  submitButtonLabel
 }) {
   const [theme] = (0, import_react53.useContext)(ThemeContext);
   const parentRef = (0, import_react53.useRef)(null);
@@ -50596,7 +51601,7 @@ function ReportBuilder({
                               setIsChartBuilderOpen(true);
                             },
                             disabled: !!errorMessage || !!pivotError || tableLoading || loading || !!unresolvedReportMessage,
-                            label: reportId ? "Save changes" : "Add to dashboard",
+                            label: submitButtonLabel ?? (reportId ? "Save changes" : "Add to dashboard"),
                             tooltipText: unresolvedReportMessage
                           }
                         )
@@ -50642,7 +51647,8 @@ function ReportBuilder({
             ErrorMessageComponent,
             PivotRowContainer,
             PivotColumnContainer,
-            onClickChartElement
+            onClickChartElement,
+            submitButtonLabel
           }
         ),
         isSaveQueryModalOpen && /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(
@@ -50898,11 +51904,32 @@ function StaticChart({
   containerStyle,
   showLegend = false
 }) {
-  const { report, loading } = useDashboardReport(reportId);
+  const {
+    report,
+    loading,
+    pageNumber,
+    pageLoading,
+    nextPage,
+    prevPage,
+    sortRows
+  } = useDashboardReportInternal(reportId);
   const mergedStyle = {
     ...report?.chartType ? CHART_TYPE_STYLES[report.chartType] || DEFAULT_STYLE : DEFAULT_STYLE,
     ...containerStyle
   };
+  const onPageChange = (page) => {
+    if (page == pageNumber - 1) {
+      prevPage();
+    } else if (page == pageNumber + 1) {
+      nextPage();
+    }
+  };
+  const onSortChange = (sort) => {
+    sortRows({
+      field: sort.field,
+      direction: sort.direction
+    });
+  };
   return /* @__PURE__ */ (0, import_jsx_runtime83.jsx)(
     ChartDisplay,
     {
@@ -50914,36 +51941,77 @@ function StaticChart({
       onClickChartElement,
       loading,
       containerStyle: mergedStyle,
-      showLegend
+      showLegend,
+      onPageChange,
+      tableRowsLoading: pageLoading,
+      onSortChange
     }
   );
 }
 
-// src/hooks/useQuill.ts
+// src/hooks/useTenants.ts
 var import_react55 = require("react");
+var useTenants = (dashboardName) => {
+  const {
+    tenants,
+    flags,
+    childTenantMappings,
+    viewerTenants,
+    isLoadingMappedTenants,
+    isLoadingViewerTenants,
+    fetchViewerTenantsForDashboard,
+    fetchMappedTenantsForDashboard,
+    getMappedTenantsForDashboard,
+    getViewerTenantsByOwner
+  } = (0, import_react55.useContext)(TenantContext);
+  (0, import_react55.useEffect)(() => {
+    if (dashboardName) {
+      fetchViewerTenantsForDashboard(dashboardName);
+    }
+  }, [dashboardName, fetchViewerTenantsForDashboard]);
+  (0, import_react55.useEffect)(() => {
+    if (dashboardName) {
+      fetchMappedTenantsForDashboard(dashboardName);
+    }
+  }, [dashboardName, fetchMappedTenantsForDashboard]);
+  return {
+    tenants,
+    flags,
+    childTenantMappings: dashboardName ? childTenantMappings[dashboardName] || {} : {},
+    mappedTenants: dashboardName ? childTenantMappings[dashboardName] || {} : {},
+    viewerTenants: dashboardName ? viewerTenants[dashboardName] || [] : [],
+    isLoadingMappedTenants,
+    isLoadingViewerTenants,
+    getMappedTenantsForDashboard,
+    getViewerTenantsByOwner
+  };
+};
+
+// src/hooks/useQuill.ts
+var import_react56 = require("react");
 var useQuill = (reportId, pagination) => {
-  const { reports, reportsDispatch, fetchIndividualReport } = (0, import_react55.useContext)(ReportsContext);
+  const { reports, reportsDispatch, fetchIndividualReport } = (0, import_react56.useContext)(ReportsContext);
   const { allReportsById } = useAllReports();
-  const { getToken } = (0, import_react55.useContext)(FetchContext);
-  const dashboardReport = (0, import_react55.useMemo)(() => {
+  const { getToken } = (0, import_react56.useContext)(FetchContext);
+  const dashboardReport = (0, import_react56.useMemo)(() => {
     return allReportsById[reportId ?? ""];
   }, [allReportsById[reportId ?? ""]]);
-  const { dashboardFilters, dashboardCustomFilters } = (0, import_react55.useContext)(
+  const { dashboardFilters, dashboardCustomFilters } = (0, import_react56.useContext)(
     DashboardFiltersContext
   );
-  const { reportFilters, customReportFilters, reportFiltersDispatch } = (0, import_react55.useContext)(ReportFiltersContext);
-  const specificReportFilters = (0, import_react55.useMemo)(() => {
+  const { reportFilters, customReportFilters, reportFiltersDispatch } = (0, import_react56.useContext)(ReportFiltersContext);
+  const specificReportFilters = (0, import_react56.useMemo)(() => {
     if (!reportId) return null;
     return Object.values(reportFilters[reportId] ?? []).map((f) => f.filter);
   }, [reportFilters, reportId]);
-  const [schemaData] = (0, import_react55.useContext)(SchemaDataContext);
-  const [client, isClientLoading] = (0, import_react55.useContext)(ClientContext);
-  const { tenants } = (0, import_react55.useContext)(TenantContext);
-  const { eventTracking } = (0, import_react55.useContext)(EventTrackingContext);
-  const [loading, setLoading] = (0, import_react55.useState)(true);
-  const [error, setError] = (0, import_react55.useState)(void 0);
-  const [previousPage, setPreviousPage] = (0, import_react55.useState)(0);
-  const processedReport = (0, import_react55.useMemo)(() => {
+  const [schemaData] = (0, import_react56.useContext)(SchemaDataContext);
+  const [client, isClientLoading] = (0, import_react56.useContext)(ClientContext);
+  const { tenants } = (0, import_react56.useContext)(TenantContext);
+  const { eventTracking } = (0, import_react56.useContext)(EventTrackingContext);
+  const [loading, setLoading] = (0, import_react56.useState)(true);
+  const [error, setError] = (0, import_react56.useState)(void 0);
+  const [previousPage, setPreviousPage] = (0, import_react56.useState)(0);
+  const processedReport = (0, import_react56.useMemo)(() => {
     return reportId && allReportsById[reportId] ? convertInternalReportToReport(
       mergeComparisonRange(allReportsById[reportId]),
       specificReportFilters ?? [],
@@ -50951,7 +52019,7 @@ var useQuill = (reportId, pagination) => {
       "useQuill"
     ) : void 0;
   }, [reportId, reportId && allReportsById[reportId], specificReportFilters]);
-  const [additionalProcessing, setAdditionProcessing] = (0, import_react55.useState)(
+  const [additionalProcessing, setAdditionProcessing] = (0, import_react56.useState)(
     pagination ? {
       page: pagination
     } : void 0
@@ -51100,7 +52168,7 @@ var useQuill = (reportId, pagination) => {
       setLoading(false);
     }
   };
-  (0, import_react55.useEffect)(() => {
+  (0, import_react56.useEffect)(() => {
     if (isClientLoading) return;
     if (reportId && specificReportFilters) {
       fetchReportHelper(reportId, {
@@ -51139,10 +52207,10 @@ var useQuill = (reportId, pagination) => {
 };
 
 // src/hooks/useFormat.ts
-var import_react56 = require("react");
+var import_react57 = require("react");
 var useMemoizedRows = (reportId) => {
   const { data } = useQuill(reportId);
-  const formattedRows = (0, import_react56.useMemo)(() => {
+  const formattedRows = (0, import_react57.useMemo)(() => {
     if (!data || !data.rows || !data.columns)
       return { rows: [], loading: true };
     return {
@@ -51166,7 +52234,7 @@ var useMemoizedRows = (reportId) => {
 };
 
 // src/hooks/useAskQuill.tsx
-var import_react57 = require("react");
+var import_react58 = require("react");
 function convertColumnInternalToAskQuillColumn(columns) {
   return columns.map((column) => {
     let convertedFieldType = FieldType.String;
@@ -51190,13 +52258,13 @@ function convertColumnInternalToAskQuillColumn(columns) {
   });
 }
 var useAskQuill = (dashboardName) => {
-  const [client] = (0, import_react57.useContext)(ClientContext);
-  const [schemaData] = (0, import_react57.useContext)(SchemaDataContext);
-  const { tenants } = (0, import_react57.useContext)(TenantContext);
-  const { getToken } = (0, import_react57.useContext)(FetchContext);
-  const { eventTracking } = (0, import_react57.useContext)(EventTrackingContext);
-  const [astInfo, setAstInfo] = (0, import_react57.useState)(void 0);
-  const [data, setData] = (0, import_react57.useState)({
+  const [client] = (0, import_react58.useContext)(ClientContext);
+  const [schemaData] = (0, import_react58.useContext)(SchemaDataContext);
+  const { tenants } = (0, import_react58.useContext)(TenantContext);
+  const { getToken } = (0, import_react58.useContext)(FetchContext);
+  const { eventTracking } = (0, import_react58.useContext)(EventTrackingContext);
+  const [astInfo, setAstInfo] = (0, import_react58.useState)(void 0);
+  const [data, setData] = (0, import_react58.useState)({
     rows: [],
     columns: [],
     pivot: null,
@@ -51206,9 +52274,9 @@ var useAskQuill = (dashboardName) => {
     pivotColumnFields: [],
     pivotValueFields: []
   });
-  const [loading, setLoading] = (0, import_react57.useState)(false);
-  const [error, setError] = (0, import_react57.useState)(void 0);
-  const [ask, setAsk] = (0, import_react57.useState)(
+  const [loading, setLoading] = (0, import_react58.useState)(false);
+  const [error, setError] = (0, import_react58.useState)(void 0);
+  const [ask, setAsk] = (0, import_react58.useState)(
     async () => void 0
   );
   const askHelper = async (query) => {
@@ -51408,7 +52476,7 @@ var useAskQuill = (dashboardName) => {
     });
     setLoading(false);
   };
-  (0, import_react57.useEffect)(() => {
+  (0, import_react58.useEffect)(() => {
     setAsk(() => askHelper);
   }, [schemaData.schema]);
   return {
@@ -51422,13 +52490,13 @@ var useAskQuill = (dashboardName) => {
 };
 
 // src/hooks/useVirtualTables.tsx
-var import_react58 = require("react");
+var import_react59 = require("react");
 var useVirtualTables = () => {
-  const [schemaData, setSchemaData] = (0, import_react58.useContext)(SchemaDataContext);
-  const { tenants } = (0, import_react58.useContext)(TenantContext);
-  const { getToken, quillFetchWithToken } = (0, import_react58.useContext)(FetchContext);
-  const { eventTracking } = (0, import_react58.useContext)(EventTrackingContext);
-  const [loadingTables, setLoadingTables] = (0, import_react58.useState)({});
+  const [schemaData, setSchemaData] = (0, import_react59.useContext)(SchemaDataContext);
+  const { tenants } = (0, import_react59.useContext)(TenantContext);
+  const { getToken, quillFetchWithToken } = (0, import_react59.useContext)(FetchContext);
+  const { eventTracking } = (0, import_react59.useContext)(EventTrackingContext);
+  const [loadingTables, setLoadingTables] = (0, import_react59.useState)({});
   const handleReload = async (client, caller) => {
     setSchemaData({ ...schemaData, isSchemaLoading: true });
     setLoadingTables(
@@ -51597,5 +52665,6 @@ var useVirtualTables = () => {
   useQuill,
   useReportBuilder,
   useReports,
+  useTenants,
   useVirtualTables
 });