autoql-fe-utils 1.0.59 → 1.0.60

package/dist/index.d.ts

@@ -31,7 +31,10 @@ declare enum AggTypes {
     MIN = "MIN",
     MAX = "MAX",
     COUNT = "COUNT",
-    COUNT_DISTINCT = "COUNT_DISTINCT"
+    COUNT_DISTINCT = "COUNT_DISTINCT",
+    MEDIAN = "MEDIAN",
+    STD_DEV = "STD_DEV",
+    VARIANCE = "VARIANCE"
 }
 declare enum ColumnTypes {
     DOLLAR_AMT = "DOLLAR_AMT",
@@ -120,7 +123,8 @@ declare class AggType {
     supportsStrings?: boolean;
     symbol?: string;
     fn?: Function;
-    constructor({ type, displayName, tooltip, unit, supportsStrings, symbol, fn }: AggTypeParams);
+    icon?: string;
+    constructor({ type, displayName, tooltip, unit, icon, supportsStrings, symbol, fn, }: AggTypeParams);
 }
 
 declare class DataExplorerSubject {
@@ -174,7 +178,13 @@ declare const DEFAULT_AGG_TYPE = AggTypes.SUM;
 declare const AGG_TYPES: {
     SUM: AggType;
     AVG: AggType;
+    MIN: AggType;
+    MAX: AggType;
     COUNT: AggType;
+    COUNT_DISTINCT: AggType;
+    MEDIAN: AggType;
+    STD_DEV: AggType;
+    VARIANCE: AggType;
 };
 declare const DISPLAY_TYPES: {
     TABLE: {
@@ -602,6 +612,7 @@ type AggTypeParams = {
     supportsStrings?: boolean;
     symbol?: string;
     fn?: Function;
+    icon?: string;
 };
 interface SubjectSuggestion {
     name: string;

package/dist/index.global.js

@@ -13690,6 +13690,22 @@
   function number(x) {
     return x === null ? NaN : +x;
   }
+  function* numbers(values, valueof) {
+    if (valueof === void 0) {
+      for (let value of values) {
+        if (value != null && (value = +value) >= value) {
+          yield value;
+        }
+      }
+    } else {
+      let index = -1;
+      for (let value of values) {
+        if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+          yield value;
+        }
+      }
+    }
+  }
 
   // node_modules/d3-array/src/bisect.js
   var ascendingBisect = bisector(ascending);
@@ -13718,6 +13734,40 @@
     return count2;
   }
 
+  // node_modules/d3-array/src/variance.js
+  function variance(values, valueof) {
+    let count2 = 0;
+    let delta;
+    let mean2 = 0;
+    let sum2 = 0;
+    if (valueof === void 0) {
+      for (let value of values) {
+        if (value != null && (value = +value) >= value) {
+          delta = value - mean2;
+          mean2 += delta / ++count2;
+          sum2 += delta * (value - mean2);
+        }
+      }
+    } else {
+      let index = -1;
+      for (let value of values) {
+        if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+          delta = value - mean2;
+          mean2 += delta / ++count2;
+          sum2 += delta * (value - mean2);
+        }
+      }
+    }
+    if (count2 > 1)
+      return sum2 / (count2 - 1);
+  }
+
+  // node_modules/d3-array/src/deviation.js
+  function deviation(values, valueof) {
+    const v = variance(values, valueof);
+    return v ? Math.sqrt(v) : v;
+  }
+
   // node_modules/d3-array/src/extent.js
   function extent(values, valueof) {
     let min2;
@@ -13805,6 +13855,23 @@
     return x;
   }
 
+  // node_modules/d3-array/src/sort.js
+  function compareDefined(compare = ascending) {
+    if (compare === ascending)
+      return ascendingDefined;
+    if (typeof compare !== "function")
+      throw new TypeError("compare is not a function");
+    return (a, b) => {
+      const x = compare(a, b);
+      if (x || x === 0)
+        return x;
+      return (compare(b, b) === 0) - (compare(a, a) === 0);
+    };
+  }
+  function ascendingDefined(a, b) {
+    return (a == null || !(a >= a)) - (b == null || !(b >= b)) || (a < b ? -1 : a > b ? 1 : 0);
+  }
+
   // node_modules/d3-array/src/array.js
   var array = Array.prototype;
   var slice = array.slice;
@@ -14026,6 +14093,68 @@
     return min2;
   }
 
+  // node_modules/d3-array/src/quickselect.js
+  function quickselect(array3, k, left2 = 0, right2 = Infinity, compare) {
+    k = Math.floor(k);
+    left2 = Math.floor(Math.max(0, left2));
+    right2 = Math.floor(Math.min(array3.length - 1, right2));
+    if (!(left2 <= k && k <= right2))
+      return array3;
+    compare = compare === void 0 ? ascendingDefined : compareDefined(compare);
+    while (right2 > left2) {
+      if (right2 - left2 > 600) {
+        const n = right2 - left2 + 1;
+        const m = k - left2 + 1;
+        const z = Math.log(n);
+        const s = 0.5 * Math.exp(2 * z / 3);
+        const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+        const newLeft = Math.max(left2, Math.floor(k - m * s / n + sd));
+        const newRight = Math.min(right2, Math.floor(k + (n - m) * s / n + sd));
+        quickselect(array3, k, newLeft, newRight, compare);
+      }
+      const t = array3[k];
+      let i = left2;
+      let j = right2;
+      swap(array3, left2, k);
+      if (compare(array3[right2], t) > 0)
+        swap(array3, left2, right2);
+      while (i < j) {
+        swap(array3, i, j), ++i, --j;
+        while (compare(array3[i], t) < 0)
+          ++i;
+        while (compare(array3[j], t) > 0)
+          --j;
+      }
+      if (compare(array3[left2], t) === 0)
+        swap(array3, left2, j);
+      else
+        ++j, swap(array3, j, right2);
+      if (j <= k)
+        left2 = j + 1;
+      if (k <= j)
+        right2 = j - 1;
+    }
+    return array3;
+  }
+  function swap(array3, i, j) {
+    const t = array3[i];
+    array3[i] = array3[j];
+    array3[j] = t;
+  }
+
+  // node_modules/d3-array/src/quantile.js
+  function quantile(values, p, valueof) {
+    values = Float64Array.from(numbers(values, valueof));
+    if (!(n = values.length) || isNaN(p = +p))
+      return;
+    if (p <= 0 || n < 2)
+      return min(values);
+    if (p >= 1)
+      return max(values);
+    var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = max(quickselect(values, i0).subarray(0, i0 + 1)), value1 = min(values.subarray(i0 + 1));
+    return value0 + (value1 - value0) * (i - i0);
+  }
+
   // node_modules/d3-array/src/mean.js
   function mean(values, valueof) {
     let count2 = 0;
@@ -14048,6 +14177,11 @@
       return sum2 / count2;
   }
 
+  // node_modules/d3-array/src/median.js
+  function median(values, valueof) {
+    return quantile(values, 0.5, valueof);
+  }
+
   // node_modules/d3-array/src/range.js
   function range(start, stop, step) {
     start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
@@ -14107,6 +14241,9 @@
     AggTypes2["MAX"] = "MAX";
     AggTypes2["COUNT"] = "COUNT";
     AggTypes2["COUNT_DISTINCT"] = "COUNT_DISTINCT";
+    AggTypes2["MEDIAN"] = "MEDIAN";
+    AggTypes2["STD_DEV"] = "STD_DEV";
+    AggTypes2["VARIANCE"] = "VARIANCE";
     return AggTypes2;
   })(AggTypes || {});
   var ColumnTypes = /* @__PURE__ */ ((ColumnTypes2) => {
@@ -14200,8 +14337,17 @@
 
   // src/Classes/AggType.ts
   var AggType = class {
-    constructor({ type, displayName, tooltip, unit: unit2, supportsStrings = false, symbol, fn = () => {
-    } }) {
+    constructor({
+      type,
+      displayName,
+      tooltip,
+      unit: unit2,
+      icon,
+      supportsStrings = false,
+      symbol,
+      fn = () => {
+      }
+    }) {
       this.type = type;
       this.displayName = displayName ? displayName : "";
       this.tooltip = tooltip;
@@ -14209,6 +14355,7 @@
       this.supportsStrings = supportsStrings;
       this.symbol = symbol;
       this.fn = fn;
+      this.icon = icon;
     }
   };
 
@@ -14323,7 +14470,8 @@
       type: "SUM" /* SUM */,
       displayName: "Sum",
       tooltip: "<strong>Sum:</strong> Values that have the same chart axis label will be added up.",
-      symbol: String.fromCharCode(931),
+      // symbol: String.fromCharCode(931),
+      icon: "sum",
       fn: sum
     }),
     AVG: new AggType({
@@ -14333,20 +14481,20 @@
       symbol: String.fromCharCode(956),
       fn: mean
     }),
-    // MIN: new AggType({
-    //   type: AggTypes.MIN,
-    //   displayName: 'Minimum',
-    //   tooltip: '<strong>Minimum:</strong> The smallest value will be shown for all data points with same label.',
-    //   symbol: '-',
-    //   fn: min,
-    // }),
-    // MAX: new AggType({
-    //   type: AggTypes.MAX,
-    //   displayName: 'Maximum',
-    //   tooltip: '<strong>Maximum:</strong> The largest value will be shown for all data points with same label.',
-    //   symbol: '+',
-    //   fn: max,
-    // }),
+    MIN: new AggType({
+      type: "MIN" /* MIN */,
+      displayName: "Minimum",
+      tooltip: "<strong>Minimum:</strong> The smallest value will be shown for all data points with same label.",
+      icon: "minimum",
+      fn: min
+    }),
+    MAX: new AggType({
+      type: "MAX" /* MAX */,
+      displayName: "Maximum",
+      tooltip: "<strong>Maximum:</strong> The largest value will be shown for all data points with same label.",
+      icon: "maximum",
+      fn: max
+    }),
     COUNT: new AggType({
       type: "COUNT" /* COUNT */,
       displayName: "Count",
@@ -14358,31 +14506,43 @@
         var _a, _b;
         return (_b = (_a = arr == null ? void 0 : arr.filter((value) => !!value)) == null ? void 0 : _a.length) != null ? _b : 0;
       }
+    }),
+    COUNT_DISTINCT: new AggType({
+      type: "COUNT_DISTINCT" /* COUNT_DISTINCT */,
+      displayName: "Count Distinct",
+      unit: "none",
+      supportsStrings: true,
+      tooltip: "<strong>Count Distinct:</strong> The total number of <em>unique</em> non-blank values will be shown for all data points with the same label.",
+      symbol: "#!",
+      fn: (arr) => {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = arr == null ? void 0 : arr.filter((value) => !!value || value == 0)) == null ? void 0 : _a.filter(onlyUnique)) == null ? void 0 : _b.length) != null ? _c : 0;
+      }
+    }),
+    MEDIAN: new AggType({
+      type: "MEDIAN" /* MEDIAN */,
+      displayName: "Median",
+      tooltip: "The median (middle) value will be shown for all data points with same label.",
+      // symbol: 'Median',
+      icon: "median",
+      fn: median
+    }),
+    STD_DEV: new AggType({
+      type: "STD_DEV" /* STD_DEV */,
+      displayName: "Standard deviation",
+      unit: "none",
+      tooltip: "The standard deviation will be shown for all data points with the same label.",
+      symbol: "\u03C3",
+      fn: deviation
+    }),
+    VARIANCE: new AggType({
+      type: "VARIANCE" /* VARIANCE */,
+      displayName: "Variance",
+      unit: "none",
+      tooltip: "The variance will be shown for all data points with the same label.",
+      symbol: "\u03C3\xB2",
+      fn: variance
     })
-    // COUNT_DISTINCT: new AggType({
-    //   type: AggTypes.COUNT_DISTINCT,
-    //   displayName: 'Count Distinct',
-    //   unit: 'none',
-    //   supportsStrings: true,
-    //   tooltip:
-    //     '<strong>Count Distinct:</strong> The total number of <em>unique</em> non-blank values will be shown for all data points with the same label.',
-    //   symbol: '#!',
-    //   fn: (arr) => arr?.filter((value) => !!value)?.filter(onlyUnique)?.length ?? 0,
-    // }),
-    // MEDIAN: new AggType({
-    //   displayName: 'Median',
-    //   tooltip: 'The median (middle) value will be shown for all data points with same label.',
-    // }),
-    // STD_DEV: new AggType({
-    //   displayName: 'Standard deviation',
-    //   unit: 'none',
-    //   tooltip: 'The standard deviation will be shown for all data points with the same label.',
-    // }),
-    // VARIANCE: new AggType({
-    //   displayName: 'Variance',
-    //   unit: 'none',
-    //   tooltip: 'The variance will be shown for all data points with the same label.',
-    // }),
   };
   var DISPLAY_TYPES = {
     TABLE: {
@@ -18817,8 +18977,6 @@
       console.error("Unable to generate pivot data - rows, columns, or table config was not provided");
       return {};
     }
-    let pivotTableRowsLimited = false;
-    let pivotTableColumnsLimited = false;
     try {
       let tableData = rows == null ? void 0 : rows.filter((row) => row[0] !== null);
       if (!(tableData == null ? void 0 : tableData.length)) {
@@ -18826,43 +18984,30 @@
         return {};
       }
       const { legendColumnIndex, stringColumnIndex, numberColumnIndex } = tableConfig;
-      const maxColumns = 20;
-      const maxRows = 100;
       if (isNaN(legendColumnIndex) || isNaN(stringColumnIndex) || isNaN(numberColumnIndex)) {
         console.error(
           "Unable to generate pivot data - table config provided was invalid. You must provide a valid legend, string, ad number column index."
         );
         return {};
       }
-      let uniqueRowHeaders = sortDataByDate(tableData, columns, "desc", "isTable").map((d) => d[stringColumnIndex]).filter(onlyUnique);
-      let uniqueColumnHeaders = sortDataByDate(tableData, columns, "desc", "isTable").map((d) => d[legendColumnIndex]).filter(onlyUnique);
-      let newStringColumnIndex = stringColumnIndex;
-      let newLegendColumnIndex = legendColumnIndex;
-      if (isFirstGeneration && Object.keys(uniqueColumnHeaders).length > Object.keys(uniqueRowHeaders).length && (!isColumnDateType(columns[stringColumnIndex]) || Object.keys(uniqueColumnHeaders).length > MAX_LEGEND_LABELS)) {
-        newStringColumnIndex = legendColumnIndex;
-        newLegendColumnIndex = stringColumnIndex;
-        const tempValues = [...uniqueRowHeaders];
-        uniqueRowHeaders = [...uniqueColumnHeaders];
-        uniqueColumnHeaders = tempValues;
-      }
-      if ((uniqueRowHeaders == null ? void 0 : uniqueRowHeaders.length) > maxRows) {
-        uniqueRowHeaders = uniqueRowHeaders.slice(0, maxRows);
-        pivotTableRowsLimited = true;
-      }
-      const uniqueRowHeadersObj = uniqueRowHeaders.reduce((map4, title, i) => {
+      let uniqueValues0 = sortDataByDate(tableData, columns, "desc", "isTable").map((d) => d[stringColumnIndex]).filter(onlyUnique).reduce((map4, title, i) => {
         map4[title] = i;
         return map4;
       }, {});
-      if ((uniqueColumnHeaders == null ? void 0 : uniqueColumnHeaders.length) > maxColumns) {
-        uniqueColumnHeaders = uniqueColumnHeaders.slice(0, maxColumns);
-        pivotTableColumnsLimited = true;
-      }
-      const uniqueColumnHeadersObj = uniqueColumnHeaders.reduce((map4, title, i) => {
+      let uniqueValues1 = sortDataByDate(tableData, columns, "desc", "isTable").map((d) => d[legendColumnIndex]).filter(onlyUnique).reduce((map4, title, i) => {
         map4[title] = i;
         return map4;
       }, {});
-      const pivotTableColumns = [];
-      pivotTableColumns.push({
+      let newStringColumnIndex = stringColumnIndex;
+      let newLegendColumnIndex = legendColumnIndex;
+      if (isFirstGeneration && Object.keys(uniqueValues1).length > Object.keys(uniqueValues0).length && (!isColumnDateType(columns[stringColumnIndex]) || Object.keys(uniqueValues1).length > MAX_LEGEND_LABELS)) {
+        newStringColumnIndex = legendColumnIndex;
+        newLegendColumnIndex = stringColumnIndex;
+        const tempValues = (0, import_lodash5.default)(uniqueValues0);
+        uniqueValues0 = (0, import_lodash5.default)(uniqueValues1);
+        uniqueValues1 = (0, import_lodash5.default)(tempValues);
+      }
+      const firstColumn = {
         ...columns[newStringColumnIndex],
         index: 0,
         frozen: true,
@@ -18872,9 +19017,10 @@
         cssClass: "pivot-category",
         pivot: true,
         headerFilter: false
-      });
+      };
+      const pivotTableColumns = [firstColumn];
       const fullDataFormatting = getDataFormatting(dataFormatting);
-      uniqueColumnHeaders.forEach((columnName, i) => {
+      Object.keys(uniqueValues1).forEach((columnName, i) => {
         const formattedColumnName = formatElement({
           element: columnName,
           column: columns[newLegendColumnIndex],
@@ -18896,38 +19042,30 @@
         });
       });
       const pivotTableData = makeEmptyArray(
-        uniqueColumnHeaders.length + 1,
+        Object.keys(uniqueValues1).length + 1,
         // Add one for the frozen first column
-        uniqueRowHeaders.length
+        Object.keys(uniqueValues0).length
       );
       tableData.forEach((row) => {
-        var _a, _b;
-        const pivotRowIndex = uniqueRowHeadersObj[row[newStringColumnIndex]];
-        const pivotRowHeaderValue = row[newStringColumnIndex];
-        if (!pivotRowHeaderValue || !pivotTableData[pivotRowIndex]) {
-          return;
-        }
-        pivotTableData[pivotRowIndex][0] = pivotRowHeaderValue;
+        var _a;
+        const pivotCategoryIndex = uniqueValues0[row[newStringColumnIndex]];
+        const pivotCategoryValue = row[newStringColumnIndex];
+        pivotTableData[pivotCategoryIndex][0] = pivotCategoryValue;
+        const pivotColumnIndex = uniqueValues1[row[newLegendColumnIndex]] + 1;
         const pivotValue = Number(row[numberColumnIndex]);
-        const pivotColumnIndex = uniqueColumnHeadersObj[row[newLegendColumnIndex]] + 1;
-        pivotTableData[pivotRowIndex][pivotColumnIndex] = pivotValue;
-        if (pivotTableColumns[pivotColumnIndex]) {
-          pivotTableColumns[pivotColumnIndex].origValues[pivotRowHeaderValue] = {
-            name: (_a = columns[newStringColumnIndex]) == null ? void 0 : _a.name,
-            drill_down: (_b = columns[newStringColumnIndex]) == null ? void 0 : _b.drill_down,
-            value: pivotRowHeaderValue
-          };
-        }
+        pivotTableData[pivotCategoryIndex][pivotColumnIndex] = pivotValue;
+        pivotTableColumns[pivotColumnIndex].origValues[pivotCategoryValue] = {
+          name: (_a = columns[newStringColumnIndex]) == null ? void 0 : _a.name,
+          value: pivotCategoryValue
+        };
       });
       const dataReturn = {
         pivotTableColumns,
         pivotTableData,
         stringColumnIndex: newStringColumnIndex,
         legendColumnIndex: newLegendColumnIndex,
-        pivotColumnHeaders: uniqueColumnHeaders,
-        pivotRowHeaders: uniqueRowHeaders,
-        pivotTableRowsLimited,
-        pivotTableColumnsLimited
+        pivotColumnHeaders: uniqueValues1,
+        pivotRowHeaders: uniqueValues0
       };
       return dataReturn;
     } catch (error) {
@@ -23459,8 +23597,10 @@
   };
   var applyStylesForHiddenSeries = ({ legendElement, legendLabels }) => {
     try {
-      select_default2(legendElement).selectAll(".cell").each(function(label) {
-        const legendLabel = legendLabels.find((l) => l.label === label);
+      select_default2(legendElement).selectAll(".cell").each(function() {
+        var _a, _b;
+        const cellData = JSON.parse((_b = (_a = select_default2(this)) == null ? void 0 : _a.data) == null ? void 0 : _b.call(_a));
+        const legendLabel = legendLabels == null ? void 0 : legendLabels.find((l) => l.label === (cellData == null ? void 0 : cellData.label));
         if (legendLabel) {
           select_default2(this).select(".swatch").attr("stroke", legendLabel.color).attr("stroke-location", "outside");
           if (legendLabel.hidden) {