@quillsql/react 2.12.37 → 2.12.39

package/dist/esm/utils/color.js

@@ -0,0 +1,425 @@
+/**
+ * Generates an array of colors by interpolating between colors in the given array.
+ * @param colors - The array of colors to interpolate between.
+ * @param length - The desired length of the resulting array.
+ */
+export function generateArrayFromColor(colors, length) {
+    if (typeof colors === 'string') {
+        return monochromaticInterpolation(colors, length);
+    }
+    if (colors.length === 1) {
+        return monochromaticInterpolation(colors[0], length);
+    }
+    const pairs = colors.length - 1;
+    const needed = length - colors.length;
+    const baseAmount = Math.floor(needed / pairs);
+    const extras = needed % pairs;
+    let result = [];
+    let i = 0;
+    let j = 1;
+    while (j < colors.length) {
+        const additional = i < extras ? 1 : 0;
+        const interpLength = 2 + baseAmount + additional;
+        const interp = interpolateBetween(colors[i], colors[j], interpLength);
+        const lastIndex = j === colors.length - 1 ? undefined : -1;
+        result = result.concat(interp.slice(0, lastIndex));
+        i++;
+        j++;
+    }
+    return result;
+}
+function hexToRgb(hex) {
+    const r = parseInt(hex.substring(1, 3), 16);
+    const g = parseInt(hex.substring(3, 5), 16);
+    const b = parseInt(hex.substring(5, 7), 16);
+    return { r, g, b };
+}
+function rgbToHex(rgb) {
+    const rHex = rgb.r.toString(16).padStart(2, '0');
+    const gHex = rgb.g.toString(16).padStart(2, '0');
+    const bHex = rgb.b.toString(16).padStart(2, '0');
+    return `#${rHex}${gHex}${bHex}`;
+}
+function colorToHSL(color) {
+    const colorHex = namedColorToHex(color);
+    const { r, g, b } = hexToRgb(colorHex);
+    return rgbToHsl(r, g, b);
+}
+/**
+ * Interpolates between two colors using HSL color space.
+ * @param leftColor - The left color in hexadecimal format.
+ * @param rightColor - The right color in hexadecimal format.
+ * @param length - The number of interpolated colors to generate between the
+ * left and right colors.
+ */
+function interpolateBetween(leftColor, rightColor, length = 3) {
+    const [h, s, _l] = colorToHSL(leftColor);
+    const [h2, s2, _l2] = colorToHSL(rightColor);
+    const hues = linspace(h, h2, length);
+    const saturations = linspace(s, s2, length);
+    const lightnesses = linspace(_l, _l2, length);
+    return Array.from({ length }).map((_, i) => {
+        const [r, g, b] = HSLtoRGB(hues[i], saturations[i], lightnesses[i]);
+        return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+    });
+}
+/**
+ * Generates monochromatic interpolation of a given color.
+ * @param color - The base color in hexadecimal format.
+ * @param length - The number of interpolated colors to generate.
+ */
+function monochromaticInterpolation(color, length) {
+    const [h, s] = colorToHSL(color);
+    const hues = linspace(h, h, length);
+    const saturations = linspace(s, s, length);
+    const lightnesses = linspace(0.6, 0.9, length);
+    return Array.from({ length }).map((_, i) => {
+        const [r, g, b] = HSLtoRGB(hues[i], saturations[i], lightnesses[i]);
+        return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+    });
+}
+/**
+ * Generates an array of numbers linearly spaced between start and end.
+ * @param start - The starting number of the sequence.
+ * @param end - The end number of the sequence.
+ * @param num - The number of samples to generate.
+ */
+function linspace(start, end, num) {
+    if (num <= 1)
+        return [start];
+    const step = (end - start) / (num - 1);
+    const result = new Array(num);
+    for (let i = 0; i < num; i++) {
+        result[i] = start + step * i;
+    }
+    return result;
+}
+const colorValues = [
+    'red',
+    'orange',
+    'amber',
+    'yellow',
+    'lime',
+    'green',
+    'emerald',
+    'teal',
+    'cyan',
+    'sky',
+    'blue',
+    'indigo',
+    'violet',
+    'purple',
+    'fuchsia',
+    'pink',
+    'rose',
+];
+/**
+ * Selects a color from the list of colors based on the element's index. If
+ * the element is a comparison range, it will select the color and then
+ * transform it to be grayscale.
+ * @param element the chart element to select the color for
+ * @param colors a list of colors to choose from
+ * @param index the index of this element in colors
+ */
+export function selectColor(element, colors, index) {
+    if (!element?.field)
+        return 'gray';
+    const isComparison = element.field.includes('comparison_');
+    const color = colors[index % colors.length] ?? '';
+    if (!isComparison) {
+        return color;
+    }
+    // If the element is a comparison, make the color grayscale.
+    if (Object.keys(COLOR_TO_HEX).includes(color)) {
+        const colorHex = COLOR_TO_HEX[color];
+        const rgbArray = hexToRGB(colorHex);
+        return toGrayscale(rgbArray);
+    }
+    // If the element is already hex, make it grayscale
+    if (color?.startsWith('#')) {
+        const rgbArray = hexToRGB(color);
+        return toGrayscale(rgbArray);
+    }
+    return 'gray'; // unknown color, fallback on gray
+}
+/**
+ * Transform a hex string to an RGB array.
+ *
+ * Examples:
+ * - #8661f2   -> [134, 97, 242]
+ * - #1661ea2e -> [22, 97, 234, 46]
+ *
+ * TODO: Add support for triplet-style hex codes like this:
+ * - #123 -> #112233 -> [17, 34, 51]
+ */
+function hexToRGB(hex) {
+    // Matches 3-4 pairs of hex digits with an optional leading `#` character
+    const regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i;
+    const result = regex.exec(hex);
+    if (result) {
+        return [
+            parseInt(result[1], 16), // index 0 is whole string, then ()'s
+            parseInt(result[2], 16),
+            parseInt(result[3], 16),
+            ...(result[4] ? [parseInt(result[4], 16)] : []), // <- alpha channel
+        ];
+    }
+    // try 'RGB[A](0, 0, 0[, 0])' style colors, matching on digits (with decimals)
+    const rgba = hex.match(/[0-9.]+/g);
+    if (rgba) {
+        return [
+            Number(rgba[0]),
+            Number(rgba[1]),
+            Number(rgba[2]),
+            ...(rgba[3] ? [Number(rgba[3])] : []),
+        ];
+    }
+    return [128, 128, 128]; // unknown color, return 'gray'
+}
+/**
+ * Converts an RGB object to grayscale.
+ *
+ * This implementation uses the luminosity method (same as GIMP's grayscale
+ * algorithm) to convert colors with proportions relative to what the human
+ * eye can percieve. This lets us maximize the visual difference between
+ * different shades of gray.
+ */
+function toGrayscale(rgba) {
+    if (rgba.length < 3)
+        return 'rbg(128, 128, 128)';
+    let sum = 0;
+    sum += Number(rgba[0] * 0.89);
+    sum += Number(rgba[1] * 1.77);
+    sum += Number(rgba[2] * 0.33);
+    const avg = (sum / 3).toFixed(2);
+    return `rgb(${avg}, ${avg}, ${avg})`;
+}
+export function namedColorToHex(color) {
+    if (Object.keys(COLOR_TO_HEX).includes(color)) {
+        return COLOR_TO_HEX[color];
+    }
+    return color;
+}
+/**
+ * A comprehensive map of all the CSS named-colors that modern browsers will
+ * recognize, and converts them into their hex values.
+ */
+const COLOR_TO_HEX = {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgreen: '#006400',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    gold: '#ffd700',
+    goldenrod: '#daa520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavender: '#e6e6fa',
+    lavenderblush: '#fff0f5',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgrey: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370d8',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#d87093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#ff0000',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32',
+};
+/**
+ * Converts an RGB color value to HSL. Conversion formula
+ * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+ * Assumes r, g, and b are contained in the set [0, 255] and
+ * returns h, s, and l in the set [0, 1].
+ *
+ * @param   Number  r       The red color value
+ * @param   Number  g       The green color value
+ * @param   Number  b       The blue color value
+ * @return  Array           The HSL representation
+ */
+export function rgbToHsl(r, g, b) {
+    (r /= 255), (g /= 255), (b /= 255);
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = (max + min) / 2;
+    let s = (max + min) / 2;
+    const l = (max + min) / 2;
+    if (max == min) {
+        h = s = 0; // achromatic
+    }
+    else {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+        h /= 6;
+    }
+    return [h, s, l];
+}
+/**
+ * Converts an HSL color value to RGB. Conversion formula
+ * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+ * Assumes h, s, and l are contained in the set [0, 1] and
+ * returns r, g, and b in the set [0, 255].
+ *
+ * @param   Number  h       The hue
+ * @param   Number  s       The saturation
+ * @param   Number  l       The lightness
+ * @return  Array           The RGB representation
+ */
+export function HSLtoRGB(h, s, l) {
+    let r, g, b;
+    if (s == 0) {
+        r = g = b = l; // achromatic
+    }
+    else {
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return [r * 255, g * 255, b * 255];
+}

package/dist/esm/utils/columnProcessing.d.ts

@@ -0,0 +1,13 @@
+import { ColumnInfo } from '../components/ReportBuilder/schema';
+import { Column, ColumnInternal } from '../models/Columns';
+import { QuillReportInternal } from '../models/Report';
+export declare function convertPostgresColumn(field: {
+    name: string;
+    dataTypeID: number;
+}): ColumnInternal;
+export declare function convertColumnInfoToColumnInternal(columnInfo: ColumnInfo): ColumnInternal;
+export declare function convertFieldTypeToJSType(fieldType: string): string;
+export declare function convertFormatToJsType(column: Column): string;
+export declare function processColumnName(columnName: string): string;
+export declare const getYAxisFields: (report: QuillReportInternal) => any[];
+//# sourceMappingURL=columnProcessing.d.ts.map

package/dist/esm/utils/columnProcessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/columnProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEhE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAOvD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,cAAc,CAyGjB;AAED,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,UAAU,GACrB,cAAc,CAShB;AA0DD,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAsBlE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY5D;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,eAAO,MAAM,cAAc,WAAY,mBAAmB,UAsDzD,CAAC"}

package/dist/esm/utils/columnProcessing.js

@@ -0,0 +1,260 @@
+import { findAndProcessDateFilter } from './filterProcessing';
+function removeBigQuerySpecialChars(columnName) {
+    return columnName.replaceAll('quill_forward_slash', '/');
+}
+export function convertPostgresColumn(field) {
+    let format;
+    let fieldType;
+    let jsType;
+    switch (field.dataTypeID) {
+        case 16: // bool
+            format = 'string';
+            break;
+        case 20: // int8
+        case 21: // int2
+        case 23: // int4
+            format = 'whole_number';
+            break;
+        case 700: // float4
+        case 701: // float8
+        case 1700: // numeric
+            format = 'two_decimal_places';
+            break;
+        case 1082: // date
+        case 1083: // time
+        case 1184: // timestamptz
+        case 1114: // timestamp
+            format = 'MMM_dd_yyyy';
+            break;
+        case 1186: // interval
+        case 1043: // varchar
+        default:
+            format = 'string';
+    }
+    switch (field.dataTypeID) {
+        case 16: // boolean
+            fieldType = 'bool';
+            break;
+        case 20: // int8
+            fieldType = 'int8';
+            break;
+        case 21: // int2
+            fieldType = 'int2';
+            break;
+        case 23: // int4
+            fieldType = 'int4';
+            break;
+        case 700: // float4
+            fieldType = 'float4';
+            break;
+        case 701: // float8
+            fieldType = 'float8';
+            break;
+        case 1700: // numeric
+            fieldType = 'numeric';
+            break;
+        case 1082: // date
+            fieldType = 'date';
+            break;
+        case 1083: // time
+            fieldType = 'time';
+            break;
+        case 1184: // timestamptz
+            fieldType = 'timestamptz';
+            break;
+        case 1186: // interval
+            fieldType = 'interval';
+            break;
+        case 1114: // timestamp
+            fieldType = 'timestamp';
+            break;
+        case 1043: // varchar
+        default:
+            fieldType = 'varchar';
+    }
+    switch (field.dataTypeID) {
+        case 16: // boolean
+            jsType = 'bool';
+            break;
+        case 20: // int8
+        case 21: // int2
+        case 23: // int4
+        case 700: // float4
+        case 701: // float8
+        case 1700: // numeric
+            jsType = 'number';
+            break;
+        case 1082: // date
+        case 1083: // time
+        case 1184: // timestamptz
+        case 1186: // interval
+        case 1114: // timestamp
+            jsType = 'date';
+            break;
+        case 1043: // varchar
+        default:
+            jsType = 'string';
+    }
+    return {
+        label: field.name,
+        field: field.name,
+        format,
+        fieldType,
+        dataTypeID: field.dataTypeID,
+        jsType: jsType,
+    };
+}
+export function convertColumnInfoToColumnInternal(columnInfo) {
+    return {
+        label: columnInfo.name,
+        field: columnInfo.name,
+        format: fieldTypeToFormat(columnInfo.fieldType),
+        fieldType: columnInfo.fieldType,
+        dataTypeID: fieldTypeToDataTypeID(columnInfo.fieldType),
+        jsType: convertFieldTypeToJSType(columnInfo.fieldType),
+    };
+}
+function fieldTypeToFormat(fieldType) {
+    switch (fieldType) {
+        case 'bool':
+            return 'string';
+        case 'int8':
+        case 'int2':
+        case 'int4':
+            return 'whole_number';
+        case 'float4':
+        case 'float8':
+        case 'numeric':
+            return 'two_decimal_places';
+        case 'date':
+        case 'time':
+        case 'timestamptz':
+        case 'timestamp':
+            return 'MMM_dd_yyyy';
+        case 'interval':
+        case 'varchar':
+        default:
+            return 'string';
+    }
+}
+function fieldTypeToDataTypeID(fieldType) {
+    switch (fieldType) {
+        case 'bool':
+            return 16;
+        case 'int8':
+            return 20;
+        case 'int2':
+            return 21;
+        case 'int4':
+            return 23;
+        case 'float4':
+            return 700;
+        case 'float8':
+            return 701;
+        case 'numeric':
+            return 1700;
+        case 'date':
+            return 1082;
+        case 'time':
+            return 1083;
+        case 'timestamptz':
+            return 1184;
+        case 'timestamp':
+            return 1114;
+        case 'interval':
+            return 1186;
+        case 'varchar':
+        default:
+            return 1043;
+    }
+}
+export function convertFieldTypeToJSType(fieldType) {
+    switch (fieldType) {
+        case 'bool':
+            return 'bool';
+        case 'int8':
+        case 'int2':
+        case 'int4':
+        case 'float4':
+        case 'float8':
+        case 'numeric':
+            return 'number';
+        case 'date':
+        case 'time':
+        case 'timestamptz':
+        case 'timestamp':
+            return 'date';
+        case 'interval':
+        case 'varchar':
+        case 'text':
+        default:
+            return 'string';
+    }
+}
+export function convertFormatToJsType(column) {
+    switch (column.format) {
+        case 'string':
+            return 'string';
+        case 'whole_number':
+        case 'two_decimal_places':
+            return 'number';
+        case 'MMM_dd_yyyy':
+            return 'date';
+        default:
+            return 'string';
+    }
+}
+export function processColumnName(columnName) {
+    return removeBigQuerySpecialChars(columnName);
+}
+export const getYAxisFields = (report) => {
+    try {
+        const curDateFilter = findAndProcessDateFilter(Object.values(report.filtersApplied));
+        if (report.pivot && report.pivotColumns && report.pivot.columnField) {
+            return (report.pivotColumns
+                .slice(1)
+                .map((column) => {
+                // @ts-ignore
+                return { ...column, format: report.yAxisFields[0].format };
+            }) ?? []);
+        }
+        else if (report.pivot && report.pivotColumns) {
+            return (report.pivotColumns
+                .slice(1)
+                .map((column) => {
+                return {
+                    ...column,
+                    // @ts-ignore
+                    label: report?.yAxisFields[0].label,
+                    // @ts-ignore
+                    format: report?.yAxisFields[0].format,
+                };
+            }) ?? []);
+        }
+        else {
+            if (curDateFilter?.comparison &&
+                curDateFilter.comparisonRange.value !== 'NO_COMPARISON') {
+                const comparisonYAxisFields = report.yAxisFields?.map((field) => {
+                    return {
+                        ...field,
+                        field: `comparison_${field.field}`,
+                        label: `comparison ${field.label ?? field.field}`,
+                    };
+                });
+                if (report.pivotColumns) {
+                    return report.pivotColumns;
+                }
+                else if (comparisonYAxisFields || report.yAxisFields) {
+                    const yAxisFields = report.yAxisFields ?? [];
+                    const compYAxisFields = comparisonYAxisFields ?? [];
+                    return [...yAxisFields, ...compYAxisFields];
+                }
+                return [];
+            }
+            return report.pivotColumns ?? report.yAxisFields ?? [];
+        }
+    }
+    catch (e) {
+        return report.yAxisFields;
+    }
+};

package/dist/esm/utils/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_COLUMN_ROWS_LIMIT = 500;
+export declare const MAX_PIVOT_UNIQUE_VALUES = 250;
+//# sourceMappingURL=constants.d.ts.map