autoql-fe-utils 1.0.0

package/dist/index.js

@@ -0,0 +1,1843 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AGG_TYPES: () => AGG_TYPES,
+  CHART_TYPES: () => CHART_TYPES,
+  DATE_ONLY_CHART_TYPES: () => DATE_ONLY_CHART_TYPES,
+  DAYJS_PRECISION_FORMATS: () => DAYJS_PRECISION_FORMATS,
+  DEFAULT_AGG_TYPE: () => DEFAULT_AGG_TYPE,
+  DEFAULT_DATA_PAGE_SIZE: () => DEFAULT_DATA_PAGE_SIZE,
+  DOUBLE_AXIS_CHART_TYPES: () => DOUBLE_AXIS_CHART_TYPES,
+  DOW_STYLES: () => DOW_STYLES,
+  MAX_DATA_PAGE_SIZE: () => MAX_DATA_PAGE_SIZE,
+  MAX_LEGEND_LABELS: () => MAX_LEGEND_LABELS,
+  MIN_HISTOGRAM_SAMPLE: () => MIN_HISTOGRAM_SAMPLE,
+  MONTH_NAMES: () => MONTH_NAMES,
+  NumberColumnTypeDisplayNames: () => NumberColumnTypeDisplayNames,
+  NumberColumnTypes: () => NumberColumnTypes,
+  PrecisionTypes: () => PrecisionTypes,
+  SEASON_NAMES: () => SEASON_NAMES,
+  TABLE_TYPES: () => TABLE_TYPES,
+  TimestampFormats: () => TimestampFormats,
+  WEEKDAY_NAMES_MON: () => WEEKDAY_NAMES_MON,
+  WEEKDAY_NAMES_SUN: () => WEEKDAY_NAMES_SUN,
+  animateInputText: () => animateInputText,
+  authenticationDefault: () => authenticationDefault,
+  autoQLConfigDefault: () => autoQLConfigDefault,
+  capitalizeFirstChar: () => capitalizeFirstChar,
+  currentEventLoopEnd: () => currentEventLoopEnd,
+  dataConfigDefault: () => dataConfigDefault,
+  dataFormattingDefault: () => dataFormattingDefault,
+  dateSortFn: () => dateSortFn,
+  dateStringSortFn: () => dateStringSortFn,
+  deepEqual: () => deepEqual,
+  difference: () => difference,
+  formatChartLabel: () => formatChartLabel,
+  formatDateStringType: () => formatDateStringType,
+  formatDateType: () => formatDateType,
+  formatElement: () => formatElement,
+  formatEpochDate: () => formatEpochDate,
+  formatISODateWithPrecision: () => formatISODateWithPrecision,
+  formatStringDate: () => formatStringDate,
+  formatStringDateWithPrecision: () => formatStringDateWithPrecision,
+  functionsEqual: () => functionsEqual,
+  getAuthentication: () => getAuthentication,
+  getAutoQLConfig: () => getAutoQLConfig,
+  getBBoxFromRef: () => getBBoxFromRef,
+  getColumnTypeAmounts: () => getColumnTypeAmounts,
+  getCurrencySymbol: () => getCurrencySymbol,
+  getDataConfig: () => getDataConfig,
+  getDataFormatting: () => getDataFormatting,
+  getDateColumnIndex: () => getDateColumnIndex,
+  getDayJSObj: () => getDayJSObj,
+  getDayjsObjForStringType: () => getDayjsObjForStringType,
+  getDefaultDisplayType: () => getDefaultDisplayType,
+  getEpochFromDate: () => getEpochFromDate,
+  getFirstChartDisplayType: () => getFirstChartDisplayType,
+  getGroupBys: () => getGroupBys,
+  getGroupBysFromPivotTable: () => getGroupBysFromPivotTable,
+  getGroupBysFromTable: () => getGroupBysFromTable,
+  getGroupableColumns: () => getGroupableColumns,
+  getKeyByValue: () => getKeyByValue,
+  getNumberFormatConfig: () => getNumberFormatConfig,
+  getNumberOfGroupables: () => getNumberOfGroupables,
+  getPadding: () => getPadding,
+  getQueryParams: () => getQueryParams,
+  getSVGBase64: () => getSVGBase64,
+  getStringFromSource: () => getStringFromSource,
+  getSupportedDisplayTypes: () => getSupportedDisplayTypes,
+  getVisibleColumns: () => getVisibleColumns,
+  handleTooltipBoundaryCollision: () => handleTooltipBoundaryCollision,
+  hasData: () => hasData,
+  hasDateColumn: () => hasDateColumn,
+  hasNumberColumn: () => hasNumberColumn,
+  hasStringColumn: () => hasStringColumn,
+  invertArray: () => invertArray,
+  isAggregation: () => isAggregation,
+  isChartType: () => isChartType,
+  isColumnDateType: () => isColumnDateType,
+  isColumnNumberType: () => isColumnNumberType,
+  isColumnStringType: () => isColumnStringType,
+  isDisplayTypeValid: () => isDisplayTypeValid,
+  isListQuery: () => isListQuery,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isSingleValueResponse: () => isSingleValueResponse,
+  isTableType: () => isTableType,
+  makeEmptyArray: () => makeEmptyArray,
+  mergeSources: () => mergeSources,
+  nameValueObject: () => nameValueObject,
+  onlyUnique: () => onlyUnique,
+  removeFromDOM: () => removeFromDOM,
+  rotateArray: () => rotateArray,
+  setCaretPosition: () => setCaretPosition,
+  shouldPlotMultiSeries: () => shouldPlotMultiSeries,
+  sortDataByDate: () => sortDataByDate,
+  supports2DCharts: () => supports2DCharts,
+  supportsDatePivotTable: () => supportsDatePivotTable,
+  supportsPieChart: () => supportsPieChart,
+  supportsRegularPivotTable: () => supportsRegularPivotTable,
+  svgToPng: () => svgToPng
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/HelperFns/objectHelpers.ts
+var nameValueObject = (name, value) => {
+  return {
+    name,
+    value
+  };
+};
+var getKeyByValue = (object, value) => {
+  return Object.keys(object).find((key) => object[key] === value);
+};
+
+// src/HelperFns/columnHelpers.ts
+var isColumnNumberType = (col) => {
+  const type = col == null ? void 0 : col.type;
+  return type === "DOLLAR_AMT" || type === "QUANTITY" || type === "PERCENT" || type === "RATIO";
+};
+var isColumnStringType = (col) => {
+  const type = col == null ? void 0 : col.type;
+  return type === "STRING" || type === "DATE_STRING" || type === "DATE" || type === "UNKNOWN";
+};
+var isColumnDateType = (col) => {
+  try {
+    const isDateType = col.type === "DATE" || col.type === "DATE_STRING";
+    return isDateType;
+  } catch (error) {
+    return false;
+  }
+};
+var hasNumberColumn = (columns) => {
+  var _a;
+  const hasNumberColumn2 = !!((_a = columns.filter((col) => isColumnNumberType(col))) == null ? void 0 : _a.length);
+  return hasNumberColumn2;
+};
+var hasStringColumn = (columns) => {
+  var _a;
+  const hasStringColumn2 = !!((_a = columns.filter((col) => isColumnStringType(col))) == null ? void 0 : _a.length);
+  return hasStringColumn2;
+};
+var hasDateColumn = (columns) => {
+  var _a;
+  const hasDateColumn2 = !!((_a = columns.filter((col) => isColumnDateType(col))) == null ? void 0 : _a.length);
+  return hasDateColumn2;
+};
+var getVisibleColumns = (columns) => {
+  return columns == null ? void 0 : columns.filter((col) => col == null ? void 0 : col.is_visible);
+};
+var getGroupableColumns = (columns) => {
+  const groupableColumns = [];
+  if (columns) {
+    columns.forEach((col, index) => {
+      if (col.groupable) {
+        groupableColumns.push(index);
+      }
+    });
+  }
+  return groupableColumns;
+};
+var getGroupBys = (row, columns) => {
+  if (!(columns == null ? void 0 : columns.length)) {
+    return void 0;
+  }
+  const groupableColumns = getGroupableColumns(columns);
+  const numGroupables = groupableColumns.length;
+  if (!numGroupables) {
+    return { groupBys: void 0, supportedByAPI: false };
+  }
+  const groupBys = [];
+  groupableColumns.forEach((colIndex) => {
+    const groupByName = columns[colIndex].name;
+    const groupByValue = `${row[colIndex]}`;
+    groupBys.push(nameValueObject(groupByName, groupByValue));
+  });
+  return { groupBys, supportedByAPI: true };
+};
+var getGroupBysFromTable = (cell, tableColumns) => {
+  if (!cell || !tableColumns) {
+    return void 0;
+  }
+  const groupableColumns = getGroupableColumns(tableColumns);
+  const numGroupables = groupableColumns.length;
+  if (!numGroupables) {
+    return void 0;
+  }
+  const rowData = cell.getData();
+  const groupByArray = [];
+  groupableColumns.forEach((colIndex) => {
+    const groupByName = tableColumns[colIndex].name;
+    const groupByValue = `${rowData[colIndex]}`;
+    groupByArray.push(nameValueObject(groupByName, groupByValue));
+  });
+  return groupByArray;
+};
+var getGroupBysFromPivotTable = ({
+  cell,
+  rowHeaders,
+  columnHeaders,
+  rowHeaderDefinition,
+  columnHeaderDefinition
+}) => {
+  var _a;
+  try {
+    const columnName = columnHeaderDefinition.name;
+    const columnField = Number(cell.getField()) - 1;
+    const columnValue = getKeyByValue(columnHeaders, columnField);
+    const rowName = rowHeaderDefinition.name;
+    const rowIndex = ((_a = cell == null ? void 0 : cell.getRow()) == null ? void 0 : _a.getPosition()) - 1;
+    const rowValue = getKeyByValue(rowHeaders, rowIndex);
+    if (columnName && rowName && columnValue !== void 0 && rowValue !== void 0) {
+      return [
+        {
+          name: columnName,
+          value: `${columnValue}`
+        },
+        {
+          name: rowName,
+          value: `${rowValue}`
+        }
+      ];
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  return void 0;
+};
+var isAggregation = (columns) => {
+  try {
+    let isAgg = false;
+    if (columns) {
+      isAgg = !!columns.find((col) => col.groupable);
+    }
+    return isAgg;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+};
+var getColumnTypeAmounts = (columns) => {
+  let amountOfStringColumns = 0;
+  let amountOfNumberColumns = 0;
+  columns.forEach((col) => {
+    if (isColumnNumberType(col) && col.is_visible) {
+      amountOfNumberColumns += 1;
+    } else if (isColumnStringType(col) && col.is_visible) {
+      amountOfStringColumns += 1;
+    }
+  });
+  return { amountOfNumberColumns, amountOfStringColumns };
+};
+var getDateColumnIndex = (columns) => {
+  return columns.findIndex((col) => col.is_visible && (col.type === "DATE" || col.type === "DATE_STRING"));
+};
+var getNumberOfGroupables = (columns) => {
+  let numberOfGroupables = 0;
+  if (columns) {
+    columns.forEach((col) => {
+      if (col.groupable) {
+        numberOfGroupables += 1;
+      }
+    });
+  }
+  return numberOfGroupables;
+};
+var isListQuery = (columns) => {
+  return getNumberOfGroupables(columns) === 0;
+};
+
+// src/dayjsWithPlugins.ts
+var import_dayjs = __toESM(require("dayjs"));
+var import_advancedFormat = __toESM(require("dayjs/plugin/advancedFormat"));
+var import_localizedFormat = __toESM(require("dayjs/plugin/localizedFormat"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+var import_timezone = __toESM(require("dayjs/plugin/timezone"));
+var import_isBetween = __toESM(require("dayjs/plugin/isBetween"));
+var import_weekOfYear = __toESM(require("dayjs/plugin/weekOfYear"));
+var import_quarterOfYear = __toESM(require("dayjs/plugin/quarterOfYear"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"));
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"));
+var import_isToday = __toESM(require("dayjs/plugin/isToday"));
+import_dayjs.default.extend(import_utc.default);
+import_dayjs.default.extend(import_isToday.default);
+import_dayjs.default.extend(import_timezone.default);
+import_dayjs.default.extend(import_isBetween.default);
+import_dayjs.default.extend(import_weekOfYear.default);
+import_dayjs.default.extend(import_quarterOfYear.default);
+import_dayjs.default.extend(import_advancedFormat.default);
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_localizedFormat.default);
+import_dayjs.default.extend(import_customParseFormat.default);
+(function applyLocale() {
+  const specificLanguageCode = window.navigator.language || "en";
+  const genericLanguageCode = specificLanguageCode.split("-")[0];
+  try {
+    require(`dayjs/locale/${specificLanguageCode}.js`);
+    import_dayjs.default.locale(specificLanguageCode);
+  } catch (error) {
+    try {
+      require(`dayjs/locale/${genericLanguageCode}.js`);
+      import_dayjs.default.locale(genericLanguageCode);
+    } catch (error2) {
+    }
+  }
+})();
+var dayjsWithPlugins_default = import_dayjs.default;
+
+// src/HelperFns/stringHelpers.ts
+var capitalizeFirstChar = (string) => {
+  let capitalized = string;
+  try {
+    capitalized = string.charAt(0).toUpperCase() + string.slice(1);
+  } catch (error) {
+    console.error(error);
+  }
+  return capitalized;
+};
+var isNumber = (str) => {
+  return /^\d+$/.test(str);
+};
+
+// src/Constants/constants.ts
+var TABLE_TYPES = [
+  "pivot_table",
+  "pivot_column",
+  "date_pivot",
+  "table",
+  "compare_table",
+  "compare_table_budget"
+];
+var CHART_TYPES = [
+  "bar",
+  "bubble",
+  "chart",
+  "column",
+  "heatmap",
+  "line",
+  "pie",
+  "stacked_bar",
+  "stacked_column",
+  "stacked_line",
+  "column_line",
+  "histogram",
+  "scatterplot"
+];
+var DATE_ONLY_CHART_TYPES = ["line", "stacked_line"];
+var DOUBLE_AXIS_CHART_TYPES = ["column_line"];
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var DEFAULT_DATA_PAGE_SIZE = 500;
+var MAX_DATA_PAGE_SIZE = 5e3;
+var WEEKDAY_NAMES_MON = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+var WEEKDAY_NAMES_SUN = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var DOW_STYLES = ["NUM_1_MON", "NUM_1_SUN", "NUM_0_MON", "NUM_0_SUN", "ALPHA_MON", "ALPHA_SUN"];
+var SEASON_NAMES = ["SP", "SU", "FA", "HO"];
+var DAYJS_PRECISION_FORMATS = {
+  DAY: "ll",
+  MONTH: "MMMM YYYY",
+  YEAR: "YYYY",
+  DATE_HOUR: "ll h:00A",
+  DATE_MINUTE: "ll h:mmA"
+};
+var DEFAULT_AGG_TYPE = "sum";
+var AGG_TYPES = [
+  {
+    displayName: "Sum",
+    value: "sum",
+    unit: "inherit",
+    tooltip: "<strong>Sum:</strong> Values that have the same chart axis label will be added up."
+  },
+  {
+    displayName: "Avg",
+    value: "avg",
+    unit: "inherit",
+    tooltip: "<strong>Average:</strong> Values that have the same chart axis label will be averaged."
+  },
+  // {
+  //   displayName: 'Median',
+  //   value: 'median',
+  //   unit: 'inherit',
+  //   tooltip: 'The median (middle) value will be shown for all data points with same label.',
+  // },
+  // {
+  //   displayName: 'Minimum',
+  //   value: 'min',
+  //   unit: 'inherit',
+  //   tooltip: 'The smallest value will be shown for all data points with same label.',
+  // },
+  // {
+  //   displayName: 'Maximum',
+  //   value: 'max',
+  //   unit: 'inherit',
+  //   tooltip: 'The largest value will be shown for all data points with same label.',
+  // },
+  // {
+  //   displayName: 'Standard deviation',
+  //   value: 'deviation',
+  //   unit: 'none',
+  //   tooltip: 'The standard deviation will be shown for all data points with the same label.',
+  // },
+  // {
+  //   displayName: 'Variance',
+  //   value: 'variance',
+  //   unit: 'none',
+  //   tooltip: 'The variance will be shown for all data points with the same label.',
+  // },
+  {
+    displayName: "Count",
+    value: "count",
+    unit: "none",
+    tooltip: "<strong>Count:</strong> The total number of non-blank values will be shown for all data points with the same label."
+  }
+  // {
+  //   displayName: 'Distinct Count',
+  //   value: 'count-distinct',
+  //   unit: 'none',
+  // },
+];
+var MAX_LEGEND_LABELS = 22;
+var MIN_HISTOGRAM_SAMPLE = 20;
+
+// src/Constants/enums.ts
+var TimestampFormats = /* @__PURE__ */ ((TimestampFormats2) => {
+  TimestampFormats2["epoch"] = "EPOCH";
+  TimestampFormats2["iso8601"] = "ISO8601";
+  return TimestampFormats2;
+})(TimestampFormats || {});
+var PrecisionTypes = /* @__PURE__ */ ((PrecisionTypes2) => {
+  PrecisionTypes2["DAY"] = "DAY";
+  PrecisionTypes2["MONTH"] = "MONTH";
+  PrecisionTypes2["YEAR"] = "YEAR";
+  PrecisionTypes2["WEEK"] = "WEEK";
+  PrecisionTypes2["QUARTER"] = "QUARTER";
+  PrecisionTypes2["DATE_HOUR"] = "DATE_HOUR";
+  PrecisionTypes2["DATE_MINUTE"] = "DATE_MINUTE";
+  PrecisionTypes2["HOUR"] = "HOUR";
+  PrecisionTypes2["MINUTE"] = "MINUTE";
+  return PrecisionTypes2;
+})(PrecisionTypes || {});
+var NumberColumnTypes = /* @__PURE__ */ ((NumberColumnTypes2) => {
+  NumberColumnTypes2["CURRENCY"] = "DOLLAR_AMT";
+  NumberColumnTypes2["QUANTITY"] = "QUANTITY";
+  NumberColumnTypes2["RATIO"] = "RATIO";
+  NumberColumnTypes2["PERCENT"] = "PERCENT";
+  return NumberColumnTypes2;
+})(NumberColumnTypes || {});
+var NumberColumnTypeDisplayNames = /* @__PURE__ */ ((NumberColumnTypeDisplayNames2) => {
+  NumberColumnTypeDisplayNames2["DOLLAR_AMT"] = "Currency";
+  NumberColumnTypeDisplayNames2["QUANTITY"] = "Quantity";
+  NumberColumnTypeDisplayNames2["RATIO"] = "Ratio";
+  NumberColumnTypeDisplayNames2["PERCENT"] = "Percent";
+  return NumberColumnTypeDisplayNames2;
+})(NumberColumnTypeDisplayNames || {});
+
+// src/Constants/defaults.ts
+var authenticationDefault = {
+  token: void 0,
+  apiKey: void 0,
+  domain: void 0,
+  dprKey: void 0,
+  dprDomain: void 0
+};
+var dataFormattingDefault = {
+  timestampFormat: "ISO8601" /* iso8601 */,
+  currencyCode: "USD",
+  languageCode: "en-US",
+  currencyDecimals: 2,
+  quantityDecimals: 2,
+  ratioDecimals: 4,
+  comparisonDisplay: "PERCENT",
+  monthYearFormat: "MMMM YYYY",
+  dayMonthYearFormat: "ll"
+};
+var autoQLConfigDefault = {
+  debug: false,
+  test: false,
+  enableAutocomplete: true,
+  enableQueryInterpretation: true,
+  enableQueryValidation: true,
+  enableQuerySuggestions: true,
+  enableColumnVisibilityManager: true,
+  enableDrilldowns: true,
+  enableNotifications: false,
+  enableCSVDownload: true,
+  enableReportProblem: true
+};
+var dataConfigDefault = {
+  stringColumnIndices: [],
+  numberColumnIndices: [],
+  stringColumnIndex: 0,
+  legendColumnIndex: void 0,
+  numberColumnIndex: 1
+};
+var getAuthentication = (prop = {}) => {
+  return {
+    ...authenticationDefault,
+    ...prop
+  };
+};
+var getDataFormatting = (prop = {}) => {
+  return {
+    ...dataFormattingDefault,
+    ...prop
+  };
+};
+var getAutoQLConfig = (prop = {}) => {
+  return {
+    ...autoQLConfigDefault,
+    ...prop
+  };
+};
+var getDataConfig = (prop = {}) => {
+  return {
+    ...dataConfigDefault,
+    ...prop
+  };
+};
+
+// src/HelperFns/dataFormattingHelpers.ts
+var formatStringDateWithPrecision = (value, col) => {
+  if (!value) {
+    return void 0;
+  }
+  let formattedValue = value;
+  try {
+    switch (col.precision) {
+      case "DOW": {
+        formattedValue = formatDOW(value, col);
+        break;
+      }
+      case "HOUR": {
+        const dayjsTime = dayjsWithPlugins_default.utc(value, "THH:mm:ss.SSSZ").utc();
+        if (dayjsTime.isValid()) {
+          formattedValue = dayjsTime.format("h:00A");
+        }
+        break;
+      }
+      case "MINUTE": {
+        const dayjsTime = dayjsWithPlugins_default.utc(value, "THH:mm:ss.SSSZ").utc();
+        if (dayjsTime.isValid()) {
+          formattedValue = dayjsTime.format("h:mmA");
+        }
+        break;
+      }
+      case "MONTH": {
+        formattedValue = value;
+        break;
+      }
+      default: {
+        formattedValue = value;
+        break;
+      }
+    }
+    return formattedValue;
+  } catch (error) {
+    console.error(error);
+    return value;
+  }
+};
+var formatStringDate = (value, config = dataFormattingDefault) => {
+  var _a;
+  if (!value) {
+    return void 0;
+  }
+  if (value && typeof value === "string") {
+    const dateArray = value.split("-");
+    const year = dateArray == null ? void 0 : dateArray[0];
+    const day = dateArray == null ? void 0 : dateArray[2];
+    let month;
+    let week;
+    if ((_a = dateArray == null ? void 0 : dateArray[1]) == null ? void 0 : _a.includes("W")) {
+      week = dateArray == null ? void 0 : dateArray[1];
+    } else {
+      month = dateArray == null ? void 0 : dateArray[1];
+    }
+    const { monthYearFormat, dayMonthYearFormat } = getDataFormatting(config);
+    const dayJSObj = dayjsWithPlugins_default.utc(value).utc();
+    if (!dayJSObj.isValid()) {
+      return value;
+    }
+    let date = value;
+    if (day) {
+      date = dayJSObj.format(dayMonthYearFormat);
+    } else if (month) {
+      date = dayJSObj.format(monthYearFormat);
+    } else if (week) {
+    } else if (year) {
+      date = year;
+    }
+    return date;
+  }
+  return value;
+};
+var formatDateType = (element, column, config = dataFormattingDefault) => {
+  if (isNumber(element)) {
+    return formatEpochDate(element, column, config);
+  }
+  return formatISODateWithPrecision(element, column, config);
+};
+var formatDateStringType = (element, column, config = dataFormattingDefault) => {
+  if (!column) {
+    return element;
+  }
+  if (column.precision) {
+    return formatStringDateWithPrecision(element, column);
+  }
+  return formatStringDate(element, config);
+};
+var formatISODateWithPrecision = (value, col, config = dataFormattingDefault) => {
+  if (!value) {
+    return void 0;
+  }
+  if (!col) {
+    return value;
+  }
+  const precision = col.precision;
+  const { dayMonthYearFormat, monthYearFormat } = getDataFormatting(config);
+  const dateDayJS = dayjsWithPlugins_default.utc(value).utc();
+  if (!dateDayJS.isValid()) {
+    return value;
+  }
+  let date = dateDayJS.format(dayMonthYearFormat);
+  try {
+    switch (precision) {
+      case "DAY" /* DAY */: {
+        break;
+      }
+      case "WEEK" /* WEEK */: {
+        const dateJSStart = dateDayJS.startOf("week").format("MMM D");
+        const dateJSEnd = dateDayJS.endOf("week").format("MMM D");
+        const week = dateDayJS.week();
+        const year = dateDayJS.format("YYYY");
+        date = `${dateJSStart} - ${dateJSEnd}, ${year} (Week ${week})`;
+        break;
+      }
+      case "MONTH" /* MONTH */: {
+        date = dateDayJS.format(monthYearFormat);
+        break;
+      }
+      case "QUARTER" /* QUARTER */: {
+        const quarter = dateDayJS.quarter();
+        const year = dateDayJS.format("YYYY");
+        date = `${year}-Q${quarter}`;
+        break;
+      }
+      case "YEAR" /* YEAR */: {
+        date = dateDayJS.format("YYYY");
+        break;
+      }
+      case "DATE_HOUR" /* DATE_HOUR */: {
+        date = dateDayJS.format(`${dayMonthYearFormat} h:00A`);
+        break;
+      }
+      case "DATE_MINUTE" /* DATE_MINUTE */: {
+        date = dateDayJS.format(`${dayMonthYearFormat} h:mmA`);
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+    return date;
+  } catch (error) {
+    console.error(error);
+  }
+};
+var formatEpochDate = (value, col, config = dataFormattingDefault) => {
+  if (!value) {
+    return void 0;
+  }
+  if (!col) {
+    return value;
+  }
+  try {
+    const { monthYearFormat, dayMonthYearFormat } = getDataFormatting(config);
+    const year = "YYYY";
+    const monthYear = monthYearFormat;
+    const dayMonthYear = dayMonthYearFormat;
+    const title = col.title;
+    let dayJSObj;
+    if (isNaN(parseFloat(value))) {
+      dayJSObj = dayjsWithPlugins_default.utc(value).utc();
+    } else {
+      dayJSObj = dayjsWithPlugins_default.unix(value).utc();
+    }
+    if (!dayJSObj.isValid()) {
+      return value;
+    }
+    let date = dayJSObj.format(dayMonthYear);
+    if (isNaN(parseFloat(value))) {
+      if (title && title.toLowerCase().includes("year")) {
+        date = dayJSObj.format(year);
+      } else if (title && title.toLowerCase().includes("month")) {
+        date = dayJSObj.format(monthYear);
+      }
+      date = dayJSObj.format(dayMonthYear);
+    } else if (title && title.toLowerCase().includes("year")) {
+      date = dayJSObj.format(year);
+    } else if (title && title.toLowerCase().includes("month")) {
+      date = dayJSObj.format(monthYear);
+    }
+    return date;
+  } catch (error) {
+    console.error(error);
+    return value;
+  }
+};
+var formatDOW = (value, col) => {
+  let dowStyle = col.dow_style;
+  if (!dowStyle) {
+    dowStyle = "NUM_1_MON";
+  }
+  let formattedValue = value;
+  let weekdayNumber = Number(value);
+  switch (dowStyle) {
+    case "NUM_1_MON": {
+      const weekdays = WEEKDAY_NAMES_MON;
+      const index = weekdayNumber - 1;
+      if (index >= 0) {
+        formattedValue = weekdays[index];
+      } else {
+        console.warn(`dow style is NUM_1_MON but the value could not be converted to a number: ${value}`);
+      }
+      break;
+    }
+    case "NUM_1_SUN": {
+      const weekdays = WEEKDAY_NAMES_SUN;
+      const index = weekdayNumber - 1;
+      if (index >= 0) {
+        formattedValue = weekdays[index];
+      } else {
+        console.warn(`dow style is NUM_1_SUN but the value could not be converted to a number: ${value}`);
+      }
+      break;
+    }
+    case "NUM_0_MON": {
+      const weekdays = WEEKDAY_NAMES_MON;
+      if (weekdayNumber >= 0) {
+        formattedValue = weekdays[weekdayNumber];
+      } else {
+        console.warn(`dow style is NUM_0_MON but the value could not be converted to a number: ${value}`);
+      }
+      break;
+    }
+    case "NUM_0_SUN": {
+      const weekdays = WEEKDAY_NAMES_SUN;
+      if (weekdayNumber >= 0) {
+        formattedValue = weekdays[weekdayNumber];
+      } else {
+        console.warn(`dow style is NUM_0_SUN but the value could not be converted to a number: ${value}`);
+      }
+      break;
+    }
+    case "ALPHA_MON":
+    case "ALPHA_SUN": {
+      const weekday = WEEKDAY_NAMES_MON.find((weekday2) => weekday2.toLowerCase().includes(value.trim().toLowerCase()));
+      if (weekday) {
+        formattedValue = weekday;
+      } else {
+        console.warn(`dow style is ALPHA but the value could not be matched to a weekday name: ${value}`);
+      }
+      break;
+    }
+    default: {
+      console.warn(`could not format dow value. dow_style was not recognized: ${col.dow_style}`);
+      break;
+    }
+  }
+  return formattedValue;
+};
+var dateStringSortFnWithoutPrecision = (a, b) => {
+  if (a.includes("-W")) {
+    const aDateYear = a.substring(0, 4);
+    const bDateYear = b.substring(0, 4);
+    if (aDateYear !== bDateYear) {
+      return aDateYear - bDateYear;
+    } else {
+      const aDateWeek = a.substring(6, 8);
+      const bDateWeek = b.substring(6, 8);
+      return aDateWeek - bDateWeek;
+    }
+  } else if (WEEKDAY_NAMES_MON.includes(a.trim())) {
+    const aDayIndex = WEEKDAY_NAMES_MON.findIndex((d) => d.toLowerCase().includes(a.trim().toLowerCase()));
+    const bDayIndex = WEEKDAY_NAMES_MON.findIndex((d) => d.toLowerCase().includes(b.trim().toLowerCase()));
+    let sortValue = a - b;
+    if (aDayIndex >= 0 && bDayIndex >= 0) {
+      sortValue = aDayIndex - bDayIndex;
+    }
+    return sortValue;
+  } else if (MONTH_NAMES.includes(a.trim())) {
+    const aMonthIndex = MONTH_NAMES.findIndex((m) => m === a.trim());
+    const bMonthIndex = MONTH_NAMES.findIndex((m) => m === b.trim());
+    if (aMonthIndex >= 0 && bMonthIndex >= 0) {
+      return bMonthIndex - aMonthIndex;
+    }
+    return a - b;
+  } else if (SEASON_NAMES.includes(a.substr(0, 2))) {
+    const aSeasonIndex = SEASON_NAMES.findIndex((s) => s === a.substr(0, 2));
+    const bSeasonIndex = SEASON_NAMES.findIndex((s) => s === b.substr(0, 2));
+    const aYear = Number(a.substr(2));
+    const bYear = Number(b.substr(2));
+    if (aYear === bYear) {
+      return aSeasonIndex - bSeasonIndex;
+    }
+    return aYear - bYear;
+  }
+  return a - b;
+};
+var dateStringSortFn = (a, b, col) => {
+  if (typeof a !== "string" || typeof b !== "string" || !col) {
+    return a - b;
+  }
+  const aTrimmed = a.trim();
+  const bTrimmed = b.trim();
+  switch (col.precision) {
+    case "DOW": {
+      const dowStyle = col.dow_style ?? "ALPHA_MON";
+      let aIndex = WEEKDAY_NAMES_MON.findIndex((dow) => dow.toLowerCase().includes(aTrimmed.toLowerCase()));
+      let bIndex = WEEKDAY_NAMES_MON.findIndex((dow) => dow.toLowerCase().includes(bTrimmed.toLowerCase()));
+      if (dowStyle === "ALPHA_SUN") {
+        aIndex = WEEKDAY_NAMES_SUN.findIndex((dow) => dow.toLowerCase().includes(aTrimmed.toLowerCase()));
+        bIndex = WEEKDAY_NAMES_SUN.findIndex((dow) => dow.toLowerCase().includes(bTrimmed.toLowerCase()));
+      }
+      return aIndex - bIndex;
+    }
+    case "HOUR":
+    case "MINUTE": {
+      const aDayjsTime = dayjsWithPlugins_default.utc(aTrimmed, "THH:mm:ss.SSSZ").utc();
+      const bDayjsTime = dayjsWithPlugins_default.utc(bTrimmed, "THH:mm:ss.SSSZ").utc();
+      return aDayjsTime.unix() - bDayjsTime.unix();
+    }
+    case "MONTH": {
+      MONTH_NAMES;
+      const aMonthIndex = MONTH_NAMES.findIndex((m) => m.toLowerCase() === aTrimmed.toLowerCase());
+      const bMonthIndex = MONTH_NAMES.findIndex((m) => m.toLowerCase() === bTrimmed.toLowerCase());
+      return aMonthIndex - bMonthIndex;
+    }
+    default: {
+      return dateStringSortFnWithoutPrecision(aTrimmed, bTrimmed);
+    }
+  }
+};
+var dateSortFn = (a, b, col, isTable) => {
+  try {
+    if (!a && !b) {
+      return 0;
+    } else if (!a && b) {
+      return 1;
+    } else if (a && !b || !col) {
+      return -1;
+    }
+    let aDate = Number(a);
+    let bDate = Number(b);
+    let sortValue = aDate - bDate;
+    if (isNaN(aDate) || isNaN(bDate)) {
+      if (col.type === "DATE_STRING") {
+        sortValue = dateStringSortFn(a, b, col);
+      } else {
+        sortValue = dayjsWithPlugins_default.utc(a).unix() - dayjsWithPlugins_default.utc(b).unix();
+      }
+    }
+    if (isTable && col.precision === "DOW") {
+      sortValue = -1 * sortValue;
+    }
+    return sortValue;
+  } catch (error) {
+    console.error(error);
+    return -1;
+  }
+};
+var sortDataByDate = (data, tableColumns, sortDirection = "desc", isTable) => {
+  try {
+    if (!data || typeof data !== "object") {
+      throw new Error("Could not sort data by date - no data supplied");
+    }
+    const dateColumnIndex = getDateColumnIndex(tableColumns);
+    const dateColumn = tableColumns[dateColumnIndex];
+    if (dateColumnIndex >= 0) {
+      let multiplier = sortDirection === "desc" ? -1 : 1;
+      const sortedData = [...data].sort(
+        (a, b) => multiplier * dateSortFn(a[dateColumnIndex], b[dateColumnIndex], dateColumn, isTable)
+      );
+      return sortedData;
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  return data;
+};
+var formatElement = ({
+  element,
+  column,
+  config = dataFormattingDefault,
+  htmlElement,
+  isChart = false
+}) => {
+  try {
+    let formattedElement = element;
+    const { currencyCode, languageCode, currencyDecimals, quantityDecimals, ratioDecimals } = getDataFormatting(config);
+    let type = column == null ? void 0 : column.type;
+    if (isChart && ["count", "deviation", "variance"].includes(column == null ? void 0 : column.aggType)) {
+      type = "QUANTITY";
+    }
+    if (column) {
+      switch (type) {
+        case "STRING": {
+          break;
+        }
+        case "DOLLAR_AMT": {
+          const elementNumber = parseFloat(`${element}`);
+          if (!isNaN(elementNumber)) {
+            const currency = currencyCode || "USD";
+            const validatedCurrencyDecimals = currencyDecimals || currencyDecimals === 0 ? currencyDecimals : void 0;
+            try {
+              formattedElement = new Intl.NumberFormat(languageCode, {
+                style: "currency",
+                currency: `${currency}`,
+                minimumFractionDigits: validatedCurrencyDecimals,
+                maximumFractionDigits: validatedCurrencyDecimals
+              }).format(elementNumber);
+            } catch (error) {
+              console.error(error);
+              formattedElement = new Intl.NumberFormat(languageCode, {
+                style: "currency",
+                currency: "USD",
+                minimumFractionDigits: validatedCurrencyDecimals,
+                maximumFractionDigits: validatedCurrencyDecimals
+              }).format(elementNumber);
+            }
+          }
+          break;
+        }
+        case "QUANTITY": {
+          const validatedQuantityDecimals = !isNaN(quantityDecimals) ? quantityDecimals : 2;
+          const elementNumber = parseFloat(`${element}`);
+          if (!isNaN(elementNumber)) {
+            const numDecimals = elementNumber % 1 !== 0 ? validatedQuantityDecimals : 0;
+            formattedElement = new Intl.NumberFormat(languageCode, {
+              minimumFractionDigits: numDecimals,
+              maximumFractionDigits: numDecimals
+            }).format(elementNumber);
+          }
+          break;
+        }
+        case "DATE": {
+          formattedElement = formatDateType(element, column, config);
+          break;
+        }
+        case "DATE_STRING": {
+          formattedElement = formatDateStringType(element, column, config);
+          break;
+        }
+        case "RATIO": {
+          const numDecimals = !isNaN(ratioDecimals) ? ratioDecimals : 4;
+          const elementNumber = parseFloat(`${element}`);
+          if (!isNaN(elementNumber)) {
+            formattedElement = new Intl.NumberFormat(languageCode, {
+              minimumFractionDigits: numDecimals,
+              maximumFractionDigits: numDecimals
+            }).format(elementNumber);
+          }
+          break;
+        }
+        case "PERCENT": {
+          const elementNumber = parseFloat(`${element}`);
+          if (!isNaN(elementNumber)) {
+            const p = elementNumber / 100;
+            formattedElement = new Intl.NumberFormat(languageCode, {
+              style: "percent",
+              minimumFractionDigits: 2,
+              maximumFractionDigits: 2
+            }).format(p);
+            if (htmlElement) {
+              if (elementNumber < 0) {
+                htmlElement.classList.add("comparison-value-negative");
+              } else if (elementNumber > 0) {
+                htmlElement.classList.add("comparison-value-positive");
+              }
+            }
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+    return formattedElement;
+  } catch (error) {
+    console.error(error);
+    return element;
+  }
+};
+var getNumberFormatConfig = (d, scale) => {
+  var _a, _b;
+  let minimumFractionDigits = 0;
+  let maximumFractionDigits = 0;
+  let notation;
+  const domainRange = ((_a = scale == null ? void 0 : scale.domain()) == null ? void 0 : _a[1]) - ((_b = scale == null ? void 0 : scale.domain()) == null ? void 0 : _b[0]);
+  const smallDomain = domainRange && domainRange < 10;
+  const absValue = Math.abs(d);
+  if (smallDomain) {
+    minimumFractionDigits = 2;
+    maximumFractionDigits = 2;
+  } else if (absValue >= 1e3) {
+    notation = "compact";
+    if (absValue > 1e9) {
+      maximumFractionDigits = 3;
+    } else if (absValue > 1e6) {
+      maximumFractionDigits = 2;
+    } else if (absValue > 1e3) {
+      maximumFractionDigits = 1;
+    }
+  }
+  return { minimumFractionDigits, maximumFractionDigits, notation };
+};
+var formatChartLabel = ({ d, scale, column, dataFormatting, maxLabelWidth }) => {
+  if (d === null) {
+    return {
+      fullWidthLabel: "Untitled Category",
+      formattedLabel: "Untitled Category"
+    };
+  }
+  const col = column ?? (scale == null ? void 0 : scale.column);
+  if (!col || !col.type) {
+    return {
+      fullWidthLabel: d,
+      formattedLabel: d
+    };
+  }
+  const config = (scale == null ? void 0 : scale.dataFormatting) ?? dataFormatting;
+  const { currencyCode, languageCode } = config;
+  let type = col.type;
+  if ((scale == null ? void 0 : scale.units) === "none") {
+    type = "QUANTITY";
+  }
+  const { minimumFractionDigits, maximumFractionDigits, notation } = getNumberFormatConfig(d, scale);
+  let formattedLabel = d;
+  if (scale == null ? void 0 : scale.showLabelDecimals) {
+    formattedLabel = formatElement({
+      element: d,
+      column: column ?? (scale == null ? void 0 : scale.column),
+      config: dataFormatting,
+      isChart: true
+    });
+  } else {
+    switch (type) {
+      case "STRING": {
+        break;
+      }
+      case "DOLLAR_AMT": {
+        if (Number(d) || Number(d) === 0) {
+          const style = "currency";
+          const currency = currencyCode || "USD";
+          const currencyConfig = {
+            style,
+            minimumFractionDigits,
+            maximumFractionDigits,
+            notation
+          };
+          try {
+            formattedLabel = new Intl.NumberFormat(languageCode, {
+              ...currencyConfig,
+              currency
+            }).format(d);
+          } catch (error) {
+            console.error(error);
+            formattedLabel = new Intl.NumberFormat(languageCode, {
+              ...currencyConfig,
+              currency: "USD"
+            }).format(d);
+          }
+        }
+        break;
+      }
+      case "QUANTITY": {
+        if (!isNaN(parseFloat(d))) {
+          formattedLabel = new Intl.NumberFormat(languageCode, {
+            minimumFractionDigits,
+            maximumFractionDigits,
+            notation
+          }).format(d);
+        }
+        break;
+      }
+      case "DATE": {
+        formattedLabel = formatDateType(d, col, config);
+        break;
+      }
+      case "DATE_STRING": {
+        formattedLabel = formatDateStringType(d, col, config);
+        break;
+      }
+      case "PERCENT": {
+        if (Number(d) || Number(d) === 0) {
+          const p = Number(d) / 100;
+          formattedLabel = new Intl.NumberFormat(languageCode, {
+            style: "percent",
+            minimumFractionDigits: 1,
+            maximumFractionDigits: 1
+          }).format(p);
+        }
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  const fullWidthLabel = formattedLabel;
+  if (typeof formattedLabel === "string" && maxLabelWidth && formattedLabel.length > maxLabelWidth) {
+    formattedLabel = `${formattedLabel.substring(0, maxLabelWidth)}...`;
+  }
+  return { fullWidthLabel, formattedLabel };
+};
+var getCurrencySymbol = (dataFormatting = dataFormattingDefault) => {
+  var _a;
+  try {
+    const { currencyCode, languageCode } = getDataFormatting(dataFormatting);
+    const formattedParts = new Intl.NumberFormat(languageCode, {
+      style: "currency",
+      currency: currencyCode
+    }).formatToParts(0);
+    const symbol = (_a = formattedParts.find((part) => (part == null ? void 0 : part.type) === "currency")) == null ? void 0 : _a.value;
+    return symbol;
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+};
+var getDayjsObjForStringType = (value, col) => {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    switch (col.precision) {
+      case "DOW": {
+        return void 0;
+      }
+      case "HOUR":
+      case "MINUTE": {
+        return dayjsWithPlugins_default.utc(value, "THH:mm:ss.SSSZ").utc();
+      }
+      case "MONTH": {
+        return void 0;
+      }
+      default: {
+        return void 0;
+      }
+    }
+  } catch (error) {
+    console.error(error);
+    return void 0;
+  }
+};
+var getDayJSObj = ({ value, column }) => {
+  if (column.type === "DATE_STRING") {
+    return getDayjsObjForStringType(value, column);
+  }
+  if (isNumber(value)) {
+    return dayjsWithPlugins_default.unix(value).utc();
+  }
+  return dayjsWithPlugins_default.utc(value).utc();
+};
+var getEpochFromDate = (date, precision, precisionFrame) => {
+  if (date == null ? void 0 : date.getTime) {
+    if (precision && precisionFrame === "start") {
+      return dayjsWithPlugins_default(date).utc().startOf(precision).valueOf();
+    } else if (precision && precisionFrame === "end") {
+      return dayjsWithPlugins_default(date).utc().endOf(precision).valueOf();
+    }
+    return date.getTime();
+  }
+  return;
+};
+
+// src/HelperFns/arrayHelpers.ts
+var import_lodash = __toESM(require("lodash.isequal"));
+var invertArray = (array) => {
+  const numRows = array.length;
+  const numColumns = array[0].length;
+  const invertedArray = [];
+  for (let i = 0; i < numColumns; i++) {
+    invertedArray[i] = [];
+    for (let j = 0; j < numRows; j++) {
+      if (array[j][i])
+        invertedArray[i][j] = array[j][i];
+    }
+  }
+  return invertedArray;
+};
+var functionsEqual = (a, b) => {
+  return (a == null ? void 0 : a.toString()) == (b == null ? void 0 : b.toString());
+};
+var isObject = (obj) => {
+  return typeof obj === "object" && !Array.isArray(obj) && obj !== null && obj !== void 0;
+};
+var deepEqual = (objA, objB) => {
+  const lodashIsEqual = (0, import_lodash.default)(objA, objB);
+  if (lodashIsEqual) {
+    return true;
+  }
+  const objAIsObject = isObject(objA);
+  const objBIsObject = isObject(objB);
+  if (!objAIsObject || !objBIsObject) {
+    return lodashIsEqual;
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    if (typeof objA[keysA[i]] === "function" && typeof objB[keysA[i]] === "function") {
+      if (!functionsEqual(objA[keysA[i]], objB[keysA[i]])) {
+        return false;
+      }
+    } else if (!Object.hasOwnProperty.call(objB, keysA[i]) || !(0, import_lodash.default)(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+};
+var difference = (objA, objB) => {
+  const diff = [];
+  Object.keys(Object.assign({}, objA, objB)).forEach((key) => {
+    if (typeof objA[key] === "function" && typeof objB[key] === "function") {
+      if (!functionsEqual(objA[key], objB[key])) {
+        diff.push({
+          key,
+          objA: objA[key],
+          objB: objB[key]
+        });
+      }
+    } else if (!Object.is(objA[key], objB[key])) {
+      diff.push({
+        key,
+        objA: objA[key],
+        objB: objB[key]
+      });
+    }
+  });
+  return diff;
+};
+var rotateArray = (array, n) => {
+  const rotated = [...array];
+  n = n % array.length;
+  if (n < 0)
+    n = array.length + n;
+  for (let i = 0; i < n; i++) {
+    rotated.unshift(rotated.pop());
+  }
+  return rotated;
+};
+var onlyUnique = (value, index, self) => {
+  return self.indexOf(value) === index;
+};
+var makeEmptyArray = (w, h, value = "") => {
+  var arr = [];
+  for (let i = 0; i < h; i++) {
+    arr[i] = [];
+    for (let j = 0; j < w; j++) {
+      arr[i][j] = value;
+    }
+  }
+  return arr;
+};
+
+// src/HelperFns/displayTypeHelpers.ts
+var isChartType = (type) => CHART_TYPES.includes(type);
+var isTableType = (type) => TABLE_TYPES.includes(type);
+var isDisplayTypeValid = (response, displayType, dataLength, pivotDataLength, columns, isDataLimited) => {
+  var _a, _b;
+  const supportedDisplayTypes = getSupportedDisplayTypes({
+    response,
+    columns: columns ?? ((_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.columns),
+    dataLength,
+    pivotDataLength,
+    isDataLimited
+  });
+  const isValid = displayType && supportedDisplayTypes.includes(displayType);
+  return isValid;
+};
+var shouldPlotMultiSeries = (columns) => {
+  if (isAggregation(columns)) {
+    return false;
+  }
+  const multiSeriesIndex = columns.findIndex((col) => col.multi_series === true);
+  return multiSeriesIndex >= 0;
+};
+var supportsPieChart = (columns, chartData) => {
+  if (shouldPlotMultiSeries(columns)) {
+    return false;
+  }
+  if (chartData) {
+    return chartData.length < 7;
+  }
+  return true;
+};
+var supports2DCharts = (columns, dataLength) => {
+  if (dataLength <= 1) {
+    return false;
+  }
+  const { amountOfNumberColumns, amountOfStringColumns } = getColumnTypeAmounts(columns);
+  return amountOfNumberColumns > 0 && amountOfStringColumns > 0;
+};
+var supportsRegularPivotTable = (columns, dataLength, data) => {
+  var _a, _b;
+  if (dataLength <= 1) {
+    return false;
+  }
+  const groupbyColumns = getGroupableColumns(columns);
+  const hasTwoGroupables = (groupbyColumns == null ? void 0 : groupbyColumns.length) === 2;
+  if (!hasTwoGroupables) {
+    return false;
+  }
+  const visibleColumns = getVisibleColumns(columns);
+  const groupbyColumn1 = columns[groupbyColumns[0]];
+  const groupbyColumn2 = columns[groupbyColumns[1]];
+  if (!groupbyColumn1.is_visible || !groupbyColumn2.is_visible || !((visibleColumns == null ? void 0 : visibleColumns.length) >= 3)) {
+    return false;
+  }
+  const column1Data = (data == null ? void 0 : data.map((row) => {
+    return row[groupbyColumns[0]];
+  })) ?? [];
+  const column2Data = (data == null ? void 0 : data.map((row) => {
+    return row[groupbyColumns[1]];
+  })) ?? [];
+  const uniqueData1Length = ((_a = column1Data == null ? void 0 : column1Data.filter(onlyUnique)) == null ? void 0 : _a.length) ?? 0;
+  const uniqueData2Length = ((_b = column2Data == null ? void 0 : column2Data.filter(onlyUnique)) == null ? void 0 : _b.length) ?? 0;
+  if (uniqueData1Length > MAX_LEGEND_LABELS && uniqueData2Length > MAX_LEGEND_LABELS) {
+    console.debug(
+      `Info: Pivot table will not be supported since there are too many unique fields. The calculated dimensions would be: ${uniqueData1Length} x ${uniqueData2Length}`
+    );
+    return false;
+  }
+  return true;
+};
+var supportsDatePivotTable = (columns) => {
+  var _a;
+  const dateColumnIndex = columns.findIndex((col) => col.type === "DATE" || col.type === "DATE_STRING");
+  const dateColumn = columns[dateColumnIndex];
+  return dateColumn && ((_a = dateColumn == null ? void 0 : dateColumn.display_name) == null ? void 0 : _a.toLowerCase().includes("month")) && (columns == null ? void 0 : columns.length) === 2;
+};
+var isSingleValueResponse = (response) => {
+  var _a, _b, _c, _d, _e, _f;
+  if (!response) {
+    return false;
+  }
+  const rows = (_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.rows;
+  const columns = (_d = (_c = response == null ? void 0 : response.data) == null ? void 0 : _c.data) == null ? void 0 : _d.columns;
+  const referenceID = (_e = response == null ? void 0 : response.data) == null ? void 0 : _e.reference_id;
+  const hasNoData = rows && !(rows == null ? void 0 : rows.length);
+  const hasOneColumn = (columns == null ? void 0 : columns.length) === 1;
+  if (hasNoData && hasOneColumn && referenceID === "1.1.211") {
+    return true;
+  }
+  const oneRowAndColumn = (rows == null ? void 0 : rows.length) === 1 && ((_f = rows[0]) == null ? void 0 : _f.length) === 1;
+  if (oneRowAndColumn) {
+    return true;
+  }
+  return false;
+};
+var getSupportedDisplayTypes = ({
+  response,
+  columns,
+  dataLength,
+  pivotDataLength,
+  isDataLimited
+} = {}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  try {
+    if (!((_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.display_type)) {
+      return [];
+    }
+    const displayType = response.data.data.display_type;
+    if (displayType === "suggestion" || displayType === "help" || displayType === "html") {
+      return [displayType];
+    }
+    const rows = ((_d = (_c = response == null ? void 0 : response.data) == null ? void 0 : _c.data) == null ? void 0 : _d.rows) ?? [];
+    const allColumns = columns || ((_f = (_e = response == null ? void 0 : response.data) == null ? void 0 : _e.data) == null ? void 0 : _f.columns);
+    const visibleColumns = getVisibleColumns(allColumns);
+    if (!(visibleColumns == null ? void 0 : visibleColumns.length)) {
+      return ["text"];
+    }
+    if (isSingleValueResponse(response)) {
+      return ["single-value"];
+    }
+    if (!(rows == null ? void 0 : rows.length)) {
+      return ["table"];
+    }
+    const maxRowsForPieChart = 10;
+    const numRows = dataLength ?? rows.length;
+    let pivotDataHasLength = true;
+    const pivotDataLengthProvided = pivotDataLength !== void 0 && pivotDataLength !== null;
+    if (pivotDataLengthProvided) {
+      pivotDataHasLength = !!pivotDataLength;
+    }
+    if (supportsRegularPivotTable(visibleColumns, numRows, (_h = (_g = response == null ? void 0 : response.data) == null ? void 0 : _g.data) == null ? void 0 : _h.rows)) {
+      const supportedDisplayTypes = ["table"];
+      if (!isDataLimited) {
+        supportedDisplayTypes.push("pivot_table");
+      }
+      if (
+        // Comment out for now so chart row count doesnt change display type
+        // numRows <= maxRowsForPivot &&
+        pivotDataHasLength
+      ) {
+        supportedDisplayTypes.push("stacked_column", "stacked_bar", "column", "bar", "bubble", "heatmap");
+        if (hasDateColumn(visibleColumns)) {
+          supportedDisplayTypes.push("stacked_line", "line");
+        }
+      }
+      return supportedDisplayTypes;
+    } else if (supports2DCharts(visibleColumns, numRows)) {
+      const supportedDisplayTypes = ["table", "column", "bar"];
+      if (numRows > MIN_HISTOGRAM_SAMPLE) {
+        supportedDisplayTypes.push("histogram");
+      }
+      if (hasDateColumn(visibleColumns)) {
+        supportedDisplayTypes.push("line");
+      }
+      if (numRows > 1 && numRows <= maxRowsForPieChart) {
+        supportedDisplayTypes.push("pie");
+      }
+      const { amountOfNumberColumns } = getColumnTypeAmounts(visibleColumns);
+      if (amountOfNumberColumns > 1) {
+        supportedDisplayTypes.push("column_line");
+        supportedDisplayTypes.push("scatterplot");
+      }
+      if (!isDataLimited && supportsDatePivotTable(visibleColumns)) {
+        const dateColumnIndex = visibleColumns.findIndex((col) => col.type === "DATE" || col.type === "DATE_STRING");
+        const dateColumn = visibleColumns[dateColumnIndex];
+        const data = (_j = (_i = response == null ? void 0 : response.data) == null ? void 0 : _i.data) == null ? void 0 : _j.rows;
+        const uniqueYears = [];
+        data.forEach((row) => {
+          const year = formatElement({
+            element: row[dateColumnIndex],
+            column: dateColumn,
+            config: getDataFormatting({ monthYearFormat: "YYYY", dayMonthYearFormat: "YYYY" })
+          });
+          if (!uniqueYears.includes(year)) {
+            uniqueYears.push(year);
+          }
+        });
+        if (uniqueYears.length > 1) {
+          supportedDisplayTypes.push("pivot_table");
+        }
+      }
+      return supportedDisplayTypes;
+    }
+    return ["table"];
+  } catch (error) {
+    console.error(error);
+    return ["table"];
+  }
+};
+var getFirstChartDisplayType = (supportedDisplayTypes, fallback) => {
+  const chartType = supportedDisplayTypes.find((displayType) => isChartType(displayType));
+  if (chartType) {
+    return chartType;
+  }
+  return fallback;
+};
+var getDefaultDisplayType = (response, defaultToChart, columns, dataLength, pivotDataLength, preferredDisplayType, isDataLimited = false) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const supportedDisplayTypes = getSupportedDisplayTypes({
+    response,
+    columns: columns ?? ((_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.columns),
+    dataLength,
+    pivotDataLength,
+    isDataLimited
+  });
+  if (preferredDisplayType && supportedDisplayTypes.includes(preferredDisplayType)) {
+    return preferredDisplayType;
+  }
+  const responseDisplayType = (_d = (_c = response == null ? void 0 : response.data) == null ? void 0 : _c.data) == null ? void 0 : _d.display_type;
+  if (supportedDisplayTypes.includes(preferredDisplayType)) {
+    return preferredDisplayType;
+  }
+  if (responseDisplayType === "suggestion" || responseDisplayType === "help" || responseDisplayType === "html") {
+    return responseDisplayType;
+  }
+  if (supportedDisplayTypes.length === 1) {
+    return supportedDisplayTypes[0];
+  }
+  if (supportedDisplayTypes.includes("pivot_table")) {
+    let displayType = "pivot_table";
+    if (defaultToChart) {
+      displayType = isAggregation((_f = (_e = response == null ? void 0 : response.data) == null ? void 0 : _e.data) == null ? void 0 : _f.columns) ? getFirstChartDisplayType(supportedDisplayTypes, "pivot_table") : "pivot_table";
+    }
+    return displayType;
+  }
+  if (!responseDisplayType && hasData(response) || responseDisplayType === "data") {
+    let displayType = "table";
+    if (defaultToChart) {
+      displayType = isAggregation((_h = (_g = response == null ? void 0 : response.data) == null ? void 0 : _g.data) == null ? void 0 : _h.columns) ? getFirstChartDisplayType(supportedDisplayTypes, "table") : "table";
+    }
+    return displayType;
+  }
+  return "text";
+};
+var hasData = (response) => {
+  var _a, _b, _c;
+  if (!response) {
+    return false;
+  }
+  return (_c = (_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.rows) == null ? void 0 : _c.length;
+};
+
+// src/HelperFns/domHelpers.ts
+var currentEventLoopEnd = () => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+};
+var animateInputText = ({ text = "", inputRef, callback = () => {
+}, totalAnimationTime = 1e3 }) => {
+  if (!text.length || !inputRef || typeof text !== "string") {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const timePerChar = Math.round(totalAnimationTime / text.length);
+    for (let i = 1; i <= text.length; i++) {
+      setTimeout(() => {
+        inputRef.value = text.slice(0, i);
+        if (i === text.length) {
+          setTimeout(() => {
+            callback();
+            resolve();
+          }, 300);
+        }
+      }, i * timePerChar);
+    }
+  });
+};
+var handleTooltipBoundaryCollision = (e, self) => {
+  var _a;
+  const tooltipRef = (_a = self == null ? void 0 : self.reactTooltipRef) == null ? void 0 : _a.tooltipRef;
+  if (!tooltipRef) {
+    return;
+  }
+  const rect = tooltipRef.getBoundingClientRect();
+  const overflownLeft = rect.left < 0;
+  const overflownRight = rect.right > window.innerWidth;
+  if (overflownLeft) {
+    tooltipRef.style.setProperty("left", "10px");
+    tooltipRef.style.setProperty("right", "auto");
+  } else if (overflownRight) {
+    tooltipRef.style.setProperty("left", "auto");
+    tooltipRef.style.setProperty("right", "10px");
+  }
+};
+var removeFromDOM = (elem) => {
+  if (!elem) {
+    return;
+  }
+  try {
+    if (typeof elem.forEach === "function" && (elem == null ? void 0 : elem.length)) {
+      elem.forEach((el) => {
+        if (el && typeof el.remove === "function") {
+          el.remove();
+        }
+      });
+    } else if (typeof elem.remove === "function") {
+      elem.remove();
+    }
+  } catch (error) {
+    console.error(error);
+  }
+};
+var setCaretPosition = (elem, caretPos) => {
+  if (elem !== null) {
+    if (elem.createTextRange) {
+      const range = elem.createTextRange();
+      range.move("character", caretPos);
+      range.select();
+    } else {
+      if (elem.selectionStart) {
+        elem.focus();
+        elem.setSelectionRange(caretPos, caretPos);
+      } else {
+        elem.focus();
+      }
+    }
+  }
+};
+var getPadding = (element) => {
+  const padding = { left: 0, right: 0, top: 0, bottom: 0 };
+  try {
+    const left = parseInt(window.getComputedStyle(element)["padding-left"], 10);
+    const right = parseInt(window.getComputedStyle(element)["padding-right"], 10);
+    const top = parseInt(window.getComputedStyle(element)["padding-top"], 10);
+    const bottom = parseInt(window.getComputedStyle(element)["padding-bottom"], 10);
+    padding.left = left;
+    padding.right = right;
+    padding.top = top;
+    padding.bottom = bottom;
+  } catch (error) {
+    return padding;
+  }
+  return padding;
+};
+var getQueryParams = (url) => {
+  try {
+    const queryParams = {};
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    const queryStrings = anchor.search.substring(1);
+    const params = queryStrings.split("&");
+    for (var i = 0; i < params.length; i++) {
+      var pair = params[i].split("=");
+      queryParams[pair[0]] = decodeURIComponent(pair[1]);
+    }
+    return queryParams;
+  } catch (error) {
+    return void 0;
+  }
+};
+var svgToPng = (svgElement, scale = 3) => {
+  return new Promise(function(resolve, reject) {
+    try {
+      const bbox = svgElement.getBoundingClientRect();
+      const originalWidth = bbox.width;
+      const originalHeight = bbox.height;
+      const scaledWidth = originalWidth * scale;
+      const scaledHeight = originalHeight * scale;
+      const clonedSvg = svgElement.cloneNode(true);
+      clonedSvg.setAttribute("transform-origin", "top left");
+      clonedSvg.setAttribute("transform", `scale(${scale})`);
+      const image64 = getSVGBase64(clonedSvg);
+      const canvas = document.createElement("canvas");
+      canvas.style.width = originalWidth + "px";
+      canvas.style.height = originalHeight + "px";
+      canvas.width = scaledWidth;
+      canvas.height = scaledHeight;
+      const ctx = canvas.getContext("2d");
+      const img = new Image();
+      img.onload = function() {
+        ctx.drawImage(this, 0, 0, scaledWidth, scaledHeight);
+        resolve(canvas.toDataURL("image/png", 1));
+      };
+      img.onerror = function() {
+        reject("failed to load image");
+      };
+      img.src = image64;
+    } catch (error) {
+      console.error(error);
+      reject("failed to convert svg to png " + error);
+    }
+  });
+};
+var getBBoxFromRef = (ref) => {
+  if (!ref || !ref.getBBox) {
+    return;
+  }
+  return ref.getBBox();
+};
+var getSVGBase64 = (svgElement) => {
+  try {
+    const domUrl = window.URL || window.webkitURL || window;
+    if (!domUrl) {
+      throw new Error("(browser doesnt support this)");
+    } else if (!svgElement) {
+      throw new Error("(svg element does not exist)");
+    }
+    var xml = new XMLSerializer().serializeToString(svgElement);
+    var svg64 = btoa(unescape(encodeURIComponent(xml)));
+    const imgSrc = `data:image/svg+xml;base64,${svg64}`;
+    return imgSrc;
+  } catch (error) {
+    return void 0;
+  }
+};
+
+// src/HelperFns/propsHelpers.ts
+var getStringFromSource = (source) => {
+  if (typeof source === "string" || typeof source === "number") {
+    return `${source}`;
+  }
+  if (Array.isArray(source) && !!source.length) {
+    return source.join(".");
+  }
+  return null;
+};
+var mergeSources = (source, newSource) => {
+  let finalSource = null;
+  try {
+    const sourceString = getStringFromSource(source);
+    const newSourceString = getStringFromSource(newSource);
+    if (sourceString && newSourceString) {
+      finalSource = [sourceString, newSourceString].join(".");
+    } else if (sourceString) {
+      finalSource = sourceString;
+    } else if (newSourceString) {
+      finalSource = newSourceString;
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  return finalSource;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGG_TYPES,
+  CHART_TYPES,
+  DATE_ONLY_CHART_TYPES,
+  DAYJS_PRECISION_FORMATS,
+  DEFAULT_AGG_TYPE,
+  DEFAULT_DATA_PAGE_SIZE,
+  DOUBLE_AXIS_CHART_TYPES,
+  DOW_STYLES,
+  MAX_DATA_PAGE_SIZE,
+  MAX_LEGEND_LABELS,
+  MIN_HISTOGRAM_SAMPLE,
+  MONTH_NAMES,
+  NumberColumnTypeDisplayNames,
+  NumberColumnTypes,
+  PrecisionTypes,
+  SEASON_NAMES,
+  TABLE_TYPES,
+  TimestampFormats,
+  WEEKDAY_NAMES_MON,
+  WEEKDAY_NAMES_SUN,
+  animateInputText,
+  authenticationDefault,
+  autoQLConfigDefault,
+  capitalizeFirstChar,
+  currentEventLoopEnd,
+  dataConfigDefault,
+  dataFormattingDefault,
+  dateSortFn,
+  dateStringSortFn,
+  deepEqual,
+  difference,
+  formatChartLabel,
+  formatDateStringType,
+  formatDateType,
+  formatElement,
+  formatEpochDate,
+  formatISODateWithPrecision,
+  formatStringDate,
+  formatStringDateWithPrecision,
+  functionsEqual,
+  getAuthentication,
+  getAutoQLConfig,
+  getBBoxFromRef,
+  getColumnTypeAmounts,
+  getCurrencySymbol,
+  getDataConfig,
+  getDataFormatting,
+  getDateColumnIndex,
+  getDayJSObj,
+  getDayjsObjForStringType,
+  getDefaultDisplayType,
+  getEpochFromDate,
+  getFirstChartDisplayType,
+  getGroupBys,
+  getGroupBysFromPivotTable,
+  getGroupBysFromTable,
+  getGroupableColumns,
+  getKeyByValue,
+  getNumberFormatConfig,
+  getNumberOfGroupables,
+  getPadding,
+  getQueryParams,
+  getSVGBase64,
+  getStringFromSource,
+  getSupportedDisplayTypes,
+  getVisibleColumns,
+  handleTooltipBoundaryCollision,
+  hasData,
+  hasDateColumn,
+  hasNumberColumn,
+  hasStringColumn,
+  invertArray,
+  isAggregation,
+  isChartType,
+  isColumnDateType,
+  isColumnNumberType,
+  isColumnStringType,
+  isDisplayTypeValid,
+  isListQuery,
+  isNumber,
+  isObject,
+  isSingleValueResponse,
+  isTableType,
+  makeEmptyArray,
+  mergeSources,
+  nameValueObject,
+  onlyUnique,
+  removeFromDOM,
+  rotateArray,
+  setCaretPosition,
+  shouldPlotMultiSeries,
+  sortDataByDate,
+  supports2DCharts,
+  supportsDatePivotTable,
+  supportsPieChart,
+  supportsRegularPivotTable,
+  svgToPng
+});
+//# sourceMappingURL=index.js.map