@quillsql/react 2.15.4 → 2.15.6

package/dist/index.js

@@ -1,3 +1,387 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/pluralize/pluralize.js
+var require_pluralize = __commonJS({
+  "../../node_modules/pluralize/pluralize.js"(exports, module) {
+    "use strict";
+    (function(root, pluralize2) {
+      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
+        module.exports = pluralize2();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize2();
+        });
+      } else {
+        root.pluralize = pluralize2();
+      }
+    })(exports, 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/Dashboard.tsx
 import {
   useContext as useContext20,
@@ -632,6 +1016,7 @@ async function fetchSqlQuery(ast, client, getToken, formData) {
 import equal from "fast-deep-equal";
 import {
   createContext,
+  useCallback,
   useEffect,
   useMemo,
   useReducer,
@@ -1347,6 +1732,7 @@ var DashboardFilterType = /* @__PURE__ */ ((DashboardFilterType4) => {
   DashboardFilterType4["Select"] = "select";
   DashboardFilterType4["MultiSelect"] = "multiselect";
   DashboardFilterType4["Date"] = "date";
+  DashboardFilterType4["Tenant"] = "tenant";
   return DashboardFilterType4;
 })(DashboardFilterType || {});
 var convertCustomFilter = (filter) => {
@@ -1600,6 +1986,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
@@ -17479,7 +17875,7 @@ async function generatePivotWithSQL({
     if (!itemQuery) {
       throw Error("No item query found in report");
     }
-    sqlQuery = pivotQuery ?? generatePivotQuery(
+    sqlQuery = generatePivotQuery(
       pivot,
       itemQuery,
       databaseType,
@@ -18797,10 +19193,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
       };
     }
@@ -21281,7 +21682,19 @@ var DashboardFiltersContext = createContext({
   loadFiltersForDashboard: async () => {
   }
 });
-var TenantContext = createContext({});
+var TenantContext = createContext({
+  childTenantMappings: {},
+  viewerTenants: {},
+  viewerTenantsByOwner: {},
+  isLoadingMappedTenants: false,
+  isLoadingViewerTenants: false,
+  fetchViewerTenantsForDashboard: async () => {
+  },
+  fetchMappedTenantsForDashboard: async () => {
+  },
+  getMappedTenantsForDashboard: async () => void 0,
+  getViewerTenantsByOwner: async () => []
+});
 var FetchContext = createContext({
   getToken: async () => "",
   quillFetchWithToken: async () => ({ data: null })
@@ -21371,6 +21784,15 @@ var ContextProvider = ({
   const fetchSchemaProcessId = useRef(0);
   const currentTenant = useRef(null);
   const currentPublicKey = useRef(null);
+  const [childTenantMappings, setChildTenantMappings] = useState({});
+  const [viewerTenants, setViewerTenants] = useState({});
+  const [viewerTenantsByOwner, setViewerTenantsByOwner] = useState({});
+  const [isLoadingMappedTenants, setIsLoadingMappedTenants] = useState(false);
+  const [isLoadingViewerTenants, setIsLoadingViewerTenants] = useState(false);
+  const prevTenants = useRef(null);
+  const viewerTenantsRequests = useRef(/* @__PURE__ */ new Set());
+  const viewerTenantsByOwnerRequests = useRef(/* @__PURE__ */ new Set());
+  const mappedTenantsRequests = useRef(/* @__PURE__ */ new Set());
   const loadDashboardProcessId = useRef({});
   useEffect(() => {
     if (!theme) {
@@ -21719,7 +22141,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,
@@ -21743,6 +22165,10 @@ var ContextProvider = ({
           });
           return null;
         }
+        if (filter.filterType === "tenant") {
+          await fetchTenantFilterOptions(dashboardName, filter);
+          return null;
+        }
         const filterOptionsAbortController = new AbortController();
         filterOptionsAbortControllers.current.add(filterOptionsAbortController);
         try {
@@ -22104,7 +22530,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,
@@ -22193,6 +22620,14 @@ var ContextProvider = ({
               loading: true
             };
           });
+          dashboard2.tenantFilters?.forEach(
+            (filter) => {
+              acc[dashboard2.name][filter.label] = {
+                filter: { ...filter, options: void 0 },
+                loading: true
+              };
+            }
+          );
           return acc;
         }, {})
       });
@@ -22268,6 +22703,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 = 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 = useCallback(
+    async (dashboardName) => {
+      if (!populatedClient || !tenants) return void 0;
+      const tenantsChanged = !equal(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 = 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
+      }
+    });
+  };
   useEffect(() => {
     async function updateClientAndSchema(publicKey2) {
       if (!publicKey2 || populatedClient?.clientId === publicKey2 && populatedClient?.allTenantTypes?.length)
@@ -22426,7 +23035,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
                             }
@@ -22514,7 +23133,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;
     }
@@ -22531,6 +23150,9 @@ var useDashboardInternal = (dashboardName, customFilters) => {
         ...updatedDashboard?.filters?.map((filter) => ({
           ...filter,
           query: void 0
+        })) ?? [],
+        ...updatedDashboard?.tenantFilters?.map((filter) => ({
+          ...filter
         })) ?? []
       ],
       void 0,
@@ -22721,8 +23343,10 @@ var useDashboards = () => {
       (a, b) => (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0)
     );
   }, [dashboardConfig]);
+  const { getMappedTenantsForDashboard } = useContext(TenantContext);
   const createDashboard = async ({
     name: name2,
+    tenantFilters,
     filters,
     dateFilter,
     dashboardOwners
@@ -22739,6 +23363,7 @@ var useDashboards = () => {
           tenantKeys: dashboardOwners,
           dashboardId: name2,
           name: name2,
+          allTenantFilters: tenantFilters ?? [],
           filters,
           dateFilter
         },
@@ -22747,6 +23372,7 @@ var useDashboards = () => {
     });
     const body = {
       newDashboardName: name2.trim(),
+      tenantFilters,
       filters,
       dateFilter,
       name: name2.trim(),
@@ -22799,6 +23425,7 @@ var useDashboards = () => {
   const updateDashboard = async (name2, {
     newName,
     filters,
+    tenantFilters,
     dateFilter,
     customFilters,
     tenantKeys
@@ -22820,6 +23447,7 @@ var useDashboards = () => {
     const body = {
       newDashboardName: newName.trim(),
       filters,
+      tenantFilters,
       dateFilter: dateFilter ?? null,
       name: name2.trim(),
       task: "edit-dashboard",
@@ -22849,6 +23477,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(
@@ -22943,6 +23572,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(
@@ -22952,14 +23583,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 {
@@ -23101,6 +23740,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;
     });
@@ -23367,7 +24020,7 @@ async function getExportData(client, dashboardFilters, reportId, getToken, event
 }
 var useExport = (reportId, {
   CustomDocumentComponent = QuillCustomDocumentComponent,
-  maximumRowsPerPage = 20,
+  maximumRowsPerPage = 39,
   // if sectionKeyField is passed, then we will group by that field
   sectionField
 } = {}) => {
@@ -23485,7 +24138,7 @@ var useExport = (reportId, {
       let html = "";
       let currentPage = {};
       let currentCount = 0;
-      let pageNumber = 1;
+      let pageNumber = 0;
       if (sectionField) {
         for (const groupKey in groupedRows) {
           const rows = groupedRows[groupKey];
@@ -23560,7 +24213,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;
@@ -23585,7 +24238,7 @@ var useExport = (reportId, {
             currentCount = 0;
           }
         }
-        if (currentCount < maximumRowsPerPage) {
+        if (currentCount > 0 && currentCount < maximumRowsPerPage) {
           pageNumber++;
           const div = document.createElement("div");
           const root = createRoot(div);
@@ -23619,81 +24272,138 @@ var useExport = (reportId, {
     isPDFLoading
   };
 };
-function QuillCustomDocumentComponent({ report }) {
-  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", margin: "2rem" }, children: [
-    /* @__PURE__ */ jsx2(
-      "div",
-      {
-        style: { display: "flex", flexDirection: "row", alignItems: "center" },
-        children: /* @__PURE__ */ jsx2(
-          "h2",
-          {
-            style: {
-              fontSize: 18,
-              fontWeight: "600",
-              textAlign: "left",
-              paddingLeft: 10
-              // color: theme?.primaryTextColor,
-            },
-            children: report.name
-          }
-        )
-      }
-    ),
-    /* @__PURE__ */ jsx2("div", { style: { paddingLeft: 20, paddingRight: 20 }, children: /* @__PURE__ */ jsx2(
-      "div",
-      {
-        style: {
-          border: "1px solid",
-          borderRadius: "4px",
-          borderStyle: "none"
-        },
-        children: /* @__PURE__ */ jsxs(
-          "table",
-          {
-            style: {
-              fontFamily: "sans-serif",
-              width: "100%",
-              borderCollapse: "collapse",
-              borderStyle: "none"
-            },
-            children: [
-              /* @__PURE__ */ jsx2(
-                "thead",
-                {
-                  style: {
-                    textAlign: "left",
-                    textOverflow: "ellipsis",
-                    whiteSpace: "nowrap",
-                    overflow: "hidden"
-                  },
-                  children: /* @__PURE__ */ jsx2("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ jsx2(
-                    "th",
-                    {
-                      style: { padding: "2px", paddingLeft: "3px" },
-                      children: col.label
+function QuillCustomDocumentComponent({
+  report,
+  pageNumber,
+  numberOfPages,
+  maximumRowsPerPage
+}) {
+  const rowStartIndex = (pageNumber - 1) * maximumRowsPerPage;
+  const rowEndIndex = pageNumber * maximumRowsPerPage;
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      style: {
+        // height: 794,
+        // minHeight: 794,
+        // maxHeight: 794,
+        height: 595,
+        minHeight: 595,
+        maxHeight: 595
+      },
+      children: /* @__PURE__ */ jsx2("div", { style: { paddingLeft: 10, paddingRight: 20 }, children: /* @__PURE__ */ jsx2(
+        "div",
+        {
+          style: {
+            border: "none",
+            borderRadius: "4px"
+          },
+          children: /* @__PURE__ */ jsxs(
+            "table",
+            {
+              style: {
+                fontFamily: "sans-serif",
+                width: "100%",
+                borderCollapse: "collapse",
+                borderStyle: "none",
+                fontSize: 8
+              },
+              children: [
+                /* @__PURE__ */ jsxs(
+                  "thead",
+                  {
+                    style: {
+                      textAlign: "left",
+                      textOverflow: "ellipsis",
+                      whiteSpace: "nowrap",
+                      overflow: "hidden"
                     },
-                    "head" + colIndex
-                  )) })
-                }
-              ),
-              /* @__PURE__ */ jsx2("tbody", { children: report.rows.map((row, rowIndex) => /* @__PURE__ */ jsx2("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ jsx2(
-                "td",
-                {
-                  style: { padding: "2px", paddingLeft: "3px" },
-                  children: quillFormat({
-                    value: row[col.field],
-                    format: col.format
-                  })
-                },
-                "cell" + col.field + colIndex + rowIndex
-              )) }, "row" + rowIndex)) })
-            ]
-          }
-        )
-      }
-    ) })
-  ] });
+                    children: [
+                      /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsx2("td", { colSpan: report.columns.length, children: "\xA0" }) }),
+                      /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsx2(
+                        "th",
+                        {
+                          style: {
+                            fontSize: "12px",
+                            fontWeight: "bold",
+                            textAlign: "left",
+                            whiteSpace: "nowrap",
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            width: "100%",
+                            margin: 0
+                          },
+                          colSpan: report.columns.length,
+                          children: report.name
+                        }
+                      ) }),
+                      /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsx2("td", { colSpan: report.columns.length, children: "\xA0" }) }),
+                      /* @__PURE__ */ jsx2("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ jsx2(
+                        "th",
+                        {
+                          style: { padding: "2px", paddingLeft: "3px", fontSize: 8 },
+                          children: col.label
+                        },
+                        "head" + colIndex
+                      )) })
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ jsxs("tbody", { children: [
+                  report.rows.slice(rowStartIndex, rowEndIndex).map((row, rowIndex) => {
+                    return [
+                      // Title and header at the top of every page
+                      /* @__PURE__ */ jsx2("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ jsx2(
+                        "td",
+                        {
+                          style: {
+                            padding: "2px",
+                            paddingLeft: "3px",
+                            fontSize: 8,
+                            whiteSpace: "nowrap",
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            width: "100%"
+                          },
+                          children: quillFormat({
+                            value: row[col.field],
+                            format: col.format
+                          })
+                        },
+                        "cell" + col.field + colIndex + rowIndex
+                      )) }, "row" + rowIndex)
+                    ];
+                  }),
+                  /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsx2("td", { colSpan: report.columns.length, children: "\xA0" }) }),
+                  /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsxs(
+                    "td",
+                    {
+                      style: {
+                        fontSize: "8px",
+                        textAlign: "left",
+                        whiteSpace: "nowrap",
+                        overflow: "hidden",
+                        textOverflow: "ellipsis",
+                        width: "100%",
+                        margin: 0
+                      },
+                      colSpan: report.columns.length,
+                      children: [
+                        "Page ",
+                        pageNumber,
+                        " of ",
+                        numberOfPages
+                      ]
+                    }
+                  ) })
+                ] })
+              ]
+            }
+          )
+        }
+      ) })
+    }
+  );
 }
 
 // src/Chart.tsx
@@ -25071,7 +25781,7 @@ var MemoizedButton = ({
 }) => {
   const [theme] = useContext4(ThemeContext);
   return /* @__PURE__ */ jsx26(
-    QuillToolTip,
+    QuillToolTipPortal,
     {
       enabled: !!tooltipText && tooltipText !== "",
       text: tooltipText ?? "",
@@ -26308,6 +27018,140 @@ var QuillToolTip = ({
     /* @__PURE__ */ jsx26("div", { className: "tooltip-text", style: { ...textStyle }, children: text })
   ] }) : children;
 };
+var QuillToolTipPortal = ({
+  children,
+  text,
+  enabled = true,
+  containerStyle = {},
+  textStyle = {},
+  mirror = false
+}) => {
+  const [theme] = useContext4(ThemeContext);
+  const [isOpen, setIsOpen] = useState6(false);
+  const tooltipRef = useRef3(null);
+  const triggerRef = useRef3(null);
+  const [tooltipPosition, setTooltipPosition] = useState6(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 });
+    }
+  };
+  useEffect6(() => {
+    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__ */ jsx26(Fragment2, { children });
+  }
+  return /* @__PURE__ */ jsxs18(
+    "div",
+    {
+      ref: triggerRef,
+      style: {
+        display: "inline-block",
+        position: "relative",
+        ...containerStyle
+      },
+      onMouseEnter: () => setIsOpen(true),
+      onMouseLeave: () => setIsOpen(false),
+      children: [
+        children,
+        isOpen && createPortal(
+          /* @__PURE__ */ jsxs18(
+            "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__ */ jsx26(
+                  "div",
+                  {
+                    style: {
+                      position: "absolute",
+                      top: "100%",
+                      left: "50%",
+                      marginLeft: -6,
+                      borderWidth: 6,
+                      borderStyle: "solid",
+                      borderColor: "transparent",
+                      borderTopColor: "#e7e7e7"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ jsx26(
+                  "div",
+                  {
+                    style: {
+                      position: "absolute",
+                      top: "100%",
+                      left: "50%",
+                      marginLeft: -5,
+                      borderWidth: 5,
+                      borderStyle: "solid",
+                      borderColor: "transparent",
+                      borderTopColor: "#ffffff"
+                    }
+                  }
+                )
+              ]
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  );
+};
 var QuillChartBuilderCheckboxComponent = ({
   isChecked,
   label,
@@ -29410,7 +30254,7 @@ function QuillMultiSelectComponentWithCombo({
   );
   const potentialOptions = useMemo8(() => {
     return value.filter((opt) => !optionValues.has(opt ?? "")).map((opt) => ({
-      label: opt === "" ? "-" : opt ?? "-",
+      label: opt === "" ? "-" : opt?.toString() ?? "-",
       value: opt ?? ""
     })).concat(options);
   }, [value, options]);
@@ -29427,7 +30271,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] = useState10(
     (() => {
@@ -30158,7 +31004,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
                 }
@@ -30500,6 +31346,51 @@ function DashboardFilter2({
         ]
       }
     ) });
+  } else if (filter.filterType === "tenant") {
+    if (filter.multiSelect) {
+      return /* @__PURE__ */ jsx42("div", { style: containerStyle, children: /* @__PURE__ */ jsx42(
+        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__ */ jsx42("div", { style: containerStyle, children: /* @__PURE__ */ jsx42(
+      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;
 }
@@ -33989,11 +34880,13 @@ function Chart({
   useEffect15(() => {
     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;
       }, {})
@@ -34117,6 +35010,10 @@ function Chart({
           }
         };
       }
+    } else if (filter.filterType === "tenant" /* Tenant */) {
+      filterValue = {
+        values: value ? Array.isArray(value) ? value : [value] : []
+      };
     }
     setFilterValues((filterValues2) => ({
       ...filterValues2,
@@ -36770,11 +37667,13 @@ function Dashboard({
   useEffect18(() => {
     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;
       }, {})
@@ -36919,6 +37818,10 @@ function Dashboard({
           }
         };
       }
+    } else if (filter.filterType === "tenant" /* Tenant */) {
+      filterValue = {
+        values: value ? Array.isArray(value) ? value : [value] : []
+      };
     }
     setFilterValues((filterValues2) => ({
       ...filterValues2,
@@ -37905,7 +38808,7 @@ import {
   useEffect as useEffect24,
   useRef as useRef18,
   useMemo as useMemo22,
-  useCallback as useCallback2
+  useCallback as useCallback3
 } from "react";
 import MonacoEditor from "@monaco-editor/react";
 
@@ -37920,7 +38823,7 @@ import {
 
 // src/internals/ReportBuilder/PivotModal.tsx
 import {
-  useCallback,
+  useCallback as useCallback2,
   useContext as useContext23,
   useMemo as useMemo18,
   useState as useState24,
@@ -38776,7 +39679,7 @@ var PivotModal = ({
     setIsOpen(false);
     setPopUpTitle("Add pivot");
   };
-  const onCommitPivot = useCallback(() => {
+  const onCommitPivot = useCallback2(() => {
     const errors2 = [];
     if ((pivotAggregations?.length ?? 0) === 0) {
       errors2.push("You must have at least one aggregation");
@@ -38914,7 +39817,7 @@ var PivotModal = ({
   const onEditRecommendedPivot = (pivot) => {
     onEditPivot(pivot, null);
   };
-  const refreshPivots = useCallback(async () => {
+  const refreshPivots = useCallback2(async () => {
     if (!client) {
       return;
     }
@@ -40330,6 +41233,10 @@ function InternalChart({
           }
         };
       }
+    } else if (filter.filterType === "tenant" /* Tenant */) {
+      filterValue = {
+        values: value ? Array.isArray(value) ? value : [value] : []
+      };
     }
     setFilterValues((filterValues2) => ({
       ...filterValues2,
@@ -41156,6 +42063,7 @@ var ListboxTextInput2 = ({
 };
 
 // src/ChartBuilder.tsx
+var import_pluralize = __toESM(require_pluralize(), 1);
 import { Fragment as Fragment13, jsx as jsx65, jsxs as jsxs47 } from "react/jsx-runtime";
 var CHART_TYPES = [
   "column",
@@ -41602,7 +42510,7 @@ function ChartBuilder({
   const validFilter = useMemo21(() => {
     return specificDashboardFilters.reduce(
       (acc, filter) => {
-        if (filter.filterType === "date_range") {
+        if (filter.filterType === "date_range" || filter.filterType === "tenant") {
           acc[filter.label] = true;
           return acc;
         }
@@ -42745,6 +43653,30 @@ function ChartBuilder({
     setIsSubmitting(false);
     setTriggeredEditChart(false);
   };
+  const memoizedTooltipText = useMemo21(() => {
+    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__ */ jsx65("div", { children: "No schema" });
@@ -43834,7 +44766,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,
@@ -43859,7 +44791,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,
@@ -43964,7 +44896,7 @@ function ChartBuilder({
                                   gap: 6
                                 },
                                 children: specificDashboardFilters.filter((f) => {
-                                  return f.filterType !== "date_range";
+                                  return f.filterType === "string";
                                 }).map((filter, index) => /* @__PURE__ */ jsxs47(ChartBuilderInputRowContainer, { children: [
                                   /* @__PURE__ */ jsx65(
                                     TextInputComponent,
@@ -44142,6 +45074,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"
                                         }
                                       )
@@ -44988,7 +45921,7 @@ function SQLEditor({
       onCloseChartBuilder && onCloseChartBuilder();
     }
   }, [isChartBuilderOpen]);
-  const handleRunSqlPrompt = useCallback2(async () => {
+  const handleRunSqlPrompt = useCallback3(async () => {
     if (!client || sqlResponseLoading) {
       return;
     }
@@ -45006,7 +45939,7 @@ function SQLEditor({
     setQuery(resp.message);
     setSqlResponseLoading(false);
   }, [sqlPrompt, sqlResponseLoading]);
-  const debounceRunSqlPrompt = useCallback2(
+  const debounceRunSqlPrompt = useCallback3(
     createDebounce(handleRunSqlPrompt, 500),
     [handleRunSqlPrompt]
   );
@@ -50140,7 +51073,8 @@ var SaveReport = ({
       reportBuilder,
       setIsOpen
     }
-  )
+  ),
+  submitButtonLabel
 }) => {
   return /* @__PURE__ */ jsxs59("div", { children: [
     SaveTrigger,
@@ -50183,7 +51117,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
       }
@@ -50282,7 +51216,8 @@ function ReportBuilder({
   hideCopySQL = true,
   isChartBuilderHorizontalView = true,
   onClickChartElement,
-  onRequestAddVirtualTable
+  onRequestAddVirtualTable,
+  submitButtonLabel
 }) {
   const [theme] = useContext32(ThemeContext);
   const parentRef = useRef20(null);
@@ -50670,7 +51605,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
                           }
                         )
@@ -50716,7 +51651,8 @@ function ReportBuilder({
             ErrorMessageComponent,
             PivotRowContainer,
             PivotColumnContainer,
-            onClickChartElement
+            onClickChartElement,
+            submitButtonLabel
           }
         ),
         isSaveQueryModalOpen && /* @__PURE__ */ jsx81(
@@ -50999,27 +51935,65 @@ function StaticChart({
   );
 }
 
+// src/hooks/useTenants.ts
+import { useContext as useContext34, useEffect as useEffect30 } from "react";
+var useTenants = (dashboardName) => {
+  const {
+    tenants,
+    flags,
+    childTenantMappings,
+    viewerTenants,
+    isLoadingMappedTenants,
+    isLoadingViewerTenants,
+    fetchViewerTenantsForDashboard,
+    fetchMappedTenantsForDashboard,
+    getMappedTenantsForDashboard,
+    getViewerTenantsByOwner
+  } = useContext34(TenantContext);
+  useEffect30(() => {
+    if (dashboardName) {
+      fetchViewerTenantsForDashboard(dashboardName);
+    }
+  }, [dashboardName, fetchViewerTenantsForDashboard]);
+  useEffect30(() => {
+    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
-import { useContext as useContext34, useEffect as useEffect30, useMemo as useMemo27, useState as useState37 } from "react";
+import { useContext as useContext35, useEffect as useEffect31, useMemo as useMemo27, useState as useState37 } from "react";
 var useQuill = (reportId, pagination) => {
-  const { reports, reportsDispatch, fetchIndividualReport } = useContext34(ReportsContext);
+  const { reports, reportsDispatch, fetchIndividualReport } = useContext35(ReportsContext);
   const { allReportsById } = useAllReports();
-  const { getToken } = useContext34(FetchContext);
+  const { getToken } = useContext35(FetchContext);
   const dashboardReport = useMemo27(() => {
     return allReportsById[reportId ?? ""];
   }, [allReportsById[reportId ?? ""]]);
-  const { dashboardFilters, dashboardCustomFilters } = useContext34(
+  const { dashboardFilters, dashboardCustomFilters } = useContext35(
     DashboardFiltersContext
   );
-  const { reportFilters, customReportFilters, reportFiltersDispatch } = useContext34(ReportFiltersContext);
+  const { reportFilters, customReportFilters, reportFiltersDispatch } = useContext35(ReportFiltersContext);
   const specificReportFilters = useMemo27(() => {
     if (!reportId) return null;
     return Object.values(reportFilters[reportId] ?? []).map((f) => f.filter);
   }, [reportFilters, reportId]);
-  const [schemaData] = useContext34(SchemaDataContext);
-  const [client, isClientLoading] = useContext34(ClientContext);
-  const { tenants } = useContext34(TenantContext);
-  const { eventTracking } = useContext34(EventTrackingContext);
+  const [schemaData] = useContext35(SchemaDataContext);
+  const [client, isClientLoading] = useContext35(ClientContext);
+  const { tenants } = useContext35(TenantContext);
+  const { eventTracking } = useContext35(EventTrackingContext);
   const [loading, setLoading] = useState37(true);
   const [error, setError] = useState37(void 0);
   const [previousPage, setPreviousPage] = useState37(0);
@@ -51180,7 +52154,7 @@ var useQuill = (reportId, pagination) => {
       setLoading(false);
     }
   };
-  useEffect30(() => {
+  useEffect31(() => {
     if (isClientLoading) return;
     if (reportId && specificReportFilters) {
       fetchReportHelper(reportId, {
@@ -51246,7 +52220,7 @@ var useMemoizedRows = (reportId) => {
 };
 
 // src/hooks/useAskQuill.tsx
-import { useContext as useContext35, useEffect as useEffect31, useState as useState38 } from "react";
+import { useContext as useContext36, useEffect as useEffect32, useState as useState38 } from "react";
 function convertColumnInternalToAskQuillColumn(columns) {
   return columns.map((column) => {
     let convertedFieldType = FieldType.String;
@@ -51270,11 +52244,11 @@ function convertColumnInternalToAskQuillColumn(columns) {
   });
 }
 var useAskQuill = (dashboardName) => {
-  const [client] = useContext35(ClientContext);
-  const [schemaData] = useContext35(SchemaDataContext);
-  const { tenants } = useContext35(TenantContext);
-  const { getToken } = useContext35(FetchContext);
-  const { eventTracking } = useContext35(EventTrackingContext);
+  const [client] = useContext36(ClientContext);
+  const [schemaData] = useContext36(SchemaDataContext);
+  const { tenants } = useContext36(TenantContext);
+  const { getToken } = useContext36(FetchContext);
+  const { eventTracking } = useContext36(EventTrackingContext);
   const [astInfo, setAstInfo] = useState38(void 0);
   const [data, setData] = useState38({
     rows: [],
@@ -51488,7 +52462,7 @@ var useAskQuill = (dashboardName) => {
     });
     setLoading(false);
   };
-  useEffect31(() => {
+  useEffect32(() => {
     setAsk(() => askHelper);
   }, [schemaData.schema]);
   return {
@@ -51502,12 +52476,12 @@ var useAskQuill = (dashboardName) => {
 };
 
 // src/hooks/useVirtualTables.tsx
-import { useContext as useContext36, useState as useState39 } from "react";
+import { useContext as useContext37, useState as useState39 } from "react";
 var useVirtualTables = () => {
-  const [schemaData, setSchemaData] = useContext36(SchemaDataContext);
-  const { tenants } = useContext36(TenantContext);
-  const { getToken, quillFetchWithToken } = useContext36(FetchContext);
-  const { eventTracking } = useContext36(EventTrackingContext);
+  const [schemaData, setSchemaData] = useContext37(SchemaDataContext);
+  const { tenants } = useContext37(TenantContext);
+  const { getToken, quillFetchWithToken } = useContext37(FetchContext);
+  const { eventTracking } = useContext37(EventTrackingContext);
   const [loadingTables, setLoadingTables] = useState39({});
   const handleReload = async (client, caller) => {
     setSchemaData({ ...schemaData, isSchemaLoading: true });
@@ -51676,5 +52650,6 @@ export {
   useQuill,
   useReportBuilder,
   useReports,
+  useTenants,
   useVirtualTables
 };