@quillsql/react 2.10.31 → 2.10.32

package/dist/esm/utils/aggregate.js

@@ -0,0 +1,423 @@
+// @ts-nocheck
+import { COMPARISON_OPTIONS } from '../DateRangePicker/dateRangePickerUtils';
+import { getPostgresBasicType } from '../ReportBuilder';
+import { add, sub, startOfWeek, startOfDay, startOfMonth, startOfYear, parse, } from 'date-fns';
+function findTimePeriod(dateFilter) {
+    if (!dateFilter) {
+        return null;
+    }
+    if (!dateFilter.initialRange &&
+        !dateFilter.startDate &&
+        !dateFilter.endDate) {
+        return null;
+    }
+    if (!dateFilter.startDate && dateFilter.endDate) {
+        return 'year';
+    }
+    let time_span;
+    if (dateFilter.initialRange) {
+        if (dateFilter.initialRange === 'LAST_90_DAYS') {
+            time_span = 1000 * 60 * 60 * 24 * 90;
+        }
+        else if (dateFilter.initialRange === 'LAST_30_DAYS') {
+            time_span = 1000 * 60 * 60 * 24 * 30;
+        }
+        else if (dateFilter.initialRange === 'CURRENT_MONTH') {
+            const now = new Date();
+            const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+            time_span = now - startOfMonth;
+        }
+        else if (dateFilter.initialRange === 'CURRENT_WEEK') {
+            const today = new Date();
+            time_span = new Date(today.setDate(today.getDate() - today.getDay()));
+        }
+        else if (dateFilter.initialRange === 'ALL_TIME') {
+            return 'year';
+        }
+    }
+    else {
+        time_span = Math.abs(dateFilter.startDate - dateFilter.endDate);
+    }
+    if (time_span < 1000 * 60 * 60 * 24 * 12) {
+        return 'day';
+    }
+    else if (time_span < 1000 * 60 * 60 * 24 * 7 * 12) {
+        return 'week';
+    }
+    else if (time_span < 1000 * 60 * 60 * 24 * 30 * 16) {
+        return 'month';
+    }
+    else
+        return 'year';
+}
+export function whatIsProbablyTheType(data, fieldName) {
+    const counts = {
+        date: 0,
+        number: 0,
+        string: 0,
+    };
+    for (const item of data) {
+        const value = item[fieldName];
+        if (value === undefined || value === null || Number.isNaN(value)) {
+            continue; // Skip if undefined, null, or NaN
+        }
+        if (typeof value === 'number') {
+            counts.number += 1;
+        }
+        else if (typeof value === 'string') {
+            // Check if the string is a date first
+            const date = new Date(value);
+            if (!Number.isNaN(date.getTime()) && date.toISOString() === value) {
+                counts.date += 1;
+                continue; // Move on to next iteration if it's a date
+            }
+            // Then, check if the string can be cast to a number
+            const numberValue = parseFloat(value);
+            if (!Number.isNaN(numberValue) && value.trim() !== '') {
+                counts.number += 1;
+            }
+            else {
+                counts.string += 1;
+            }
+        }
+    }
+    const maxType = Object.keys(counts).reduce((a, b) => counts[a] > counts[b] ? a : b);
+    return maxType;
+}
+export function aggregate2(dashboardItem, bucketFields, dateFilter) {
+    const timePeriod = findTimePeriod(dateFilter);
+    const rows = dashboardItem.rows;
+    const xAxisLabel = timePeriod;
+    const xAxisField = timePeriod;
+    if (!bucketFields.length || !rows.length)
+        return { ...dashboardItem, bucketedRows: [] };
+    if (getPostgresBasicType(dashboardItem.fields.find(field => field.name === bucketFields[0].field)) === 'string') {
+        const stringField = bucketFields[0].field;
+        const aggregation = {};
+        // let aggregatedArray;
+        // if (rows.length > 0) {
+        rows.forEach(row => {
+            const strValue = row[stringField];
+            if (!aggregation[strValue]) {
+                aggregation[strValue] = {
+                    [dashboardItem.yAxisFields[0].field]: 0,
+                };
+            }
+            // Sum up the amounts (or any other field) for each unique string
+            aggregation[strValue][dashboardItem.yAxisFields[0].field] += parseFloat(row[dashboardItem.yAxisFields[0].field]);
+        });
+        // Convert the object to an array
+        aggregatedArray = Object.keys(aggregation).map(str => ({
+            [stringField]: str,
+            [dashboardItem.yAxisFields[0].field]: aggregation[str][dashboardItem.yAxisFields[0].field].toFixed(2),
+        }));
+        // } else {
+        //   console.log('should be in here');
+        //   aggregatedArray = [];
+        // }
+        return {
+            ...dashboardItem,
+            xAxisField: stringField,
+            xAxisLabel: stringField,
+            bucketedRows: aggregatedArray,
+        };
+    }
+    else if (getPostgresBasicType(dashboardItem.fields.find(field => field.name === bucketFields[0].field)) === 'date') {
+        const dateField = bucketFields[0].field;
+        let xAxisFormat;
+        switch (timePeriod) {
+            case 'week':
+                xAxisFormat = 'MMM_dd-MMM_dd';
+                break;
+            case 'month':
+                xAxisFormat = 'MMM_yyyy'; // Eg: "Sep 2023"
+                break;
+            case 'year':
+                xAxisFormat = 'yyyy'; // Eg: "2023"
+                break;
+            default:
+                xAxisFormat = 'MMM_dd_yyyy'; // Default to full date, Eg: "Sep 05, 2023"
+                break;
+        }
+        const aggregation = {};
+        // TODO MAKE WORK WITH MULTIPLE Y AXIS FIELDS
+        rows.forEach(row => {
+            const date = new Date(row[dateField]);
+            let formattedDate;
+            switch (timePeriod) {
+                case 'day': {
+                    formattedDate = new Date(date.getFullYear(), date.getMonth(), date.getDate()).toISOString();
+                    break;
+                }
+                case 'week': {
+                    const weekStart = new Date(date);
+                    weekStart.setDate(date.getDate() - date.getDay()); // subtract the number of days since Sunday
+                    formattedDate = weekStart.toISOString();
+                    break;
+                }
+                case 'month': {
+                    formattedDate = new Date(date.getFullYear(), date.getMonth(), 1).toISOString();
+                    break;
+                }
+                case 'year': {
+                    formattedDate = new Date(date.getFullYear(), 0, 1).toISOString();
+                    break;
+                }
+                default:
+                    throw new Error('Unsupported aggregation period');
+            }
+            if (!aggregation[formattedDate]) {
+                aggregation[formattedDate] = {
+                    [dashboardItem.yAxisFields[0].field]: 0,
+                };
+            }
+            // Sum the spend amounts for each period
+            aggregation[formattedDate][dashboardItem.yAxisFields[0].field] +=
+                parseFloat(row.amount);
+        });
+        // Convert the object to an array and format the spend amounts
+        const aggregatedArray = Object.keys(aggregation).length
+            ? Object.keys(aggregation)
+                .map(date => ({
+                [timePeriod]: date,
+                [dashboardItem.yAxisFields[0].field]: aggregation[date][dashboardItem.yAxisFields[0].field].toFixed(2),
+            }))
+                .sort((a, b) => new Date(a[timePeriod]) - new Date(b[timePeriod]))
+            : [];
+        return {
+            ...dashboardItem,
+            xAxisField,
+            xAxisLabel,
+            xAxisFormat,
+            bucketedRows: aggregatedArray,
+        };
+    }
+    else {
+        return dashboardItem;
+    }
+}
+export function aggregate(dashboardItem, bucketFields, dateFilter) {
+    const timePeriod = dateFilter && Object.keys(dateFilter).length
+        ? findTimePeriod(dateFilter)
+        : 'month';
+    const rows = dashboardItem.rows;
+    const compareRows = dashboardItem.compareRows;
+    const xAxisLabel = timePeriod;
+    const xAxisField = timePeriod;
+    if (!rows.length) {
+        return { ...dashboardItem, bucketedRows: [] };
+    }
+    if (!bucketFields.length) {
+        //TODO: allow comparison for nonbucketed
+        return { ...dashboardItem, bucketedRows: [] };
+    }
+    if (getPostgresBasicType(dashboardItem.fields.find(field => field.name === bucketFields[0].field)) === 'string') {
+        const stringField = bucketFields[0].field;
+        const aggregation = {};
+        rows.forEach(row => {
+            const strValue = row[stringField];
+            if (!aggregation[strValue]) {
+                aggregation[strValue] = {};
+                dashboardItem.yAxisFields.forEach(yAxisField => {
+                    aggregation[strValue][yAxisField.field] = 0;
+                });
+            }
+            // Sum up the amounts (or any other field) for each unique string
+            dashboardItem.yAxisFields.forEach(yAxisField => {
+                aggregation[strValue][yAxisField.field] += parseFloat(row[yAxisField.field] ?? '0.0');
+            });
+        });
+        const aggregatedArray = Object.keys(aggregation).map(key => {
+            return {
+                [stringField]: key,
+                ...aggregation[key],
+            };
+        });
+        return {
+            ...dashboardItem,
+            xAxisField: stringField,
+            xAxisLabel: stringField,
+            bucketedRows: aggregatedArray,
+        };
+    }
+    else if (getPostgresBasicType(dashboardItem.fields.find(field => field.name === bucketFields[0].field)) === 'date') {
+        const dateField = bucketFields[0].field;
+        let interval;
+        let xAxisFormat;
+        switch (timePeriod) {
+            case 'week':
+                xAxisFormat = 'MMM_dd-MMM_dd';
+                interval = { weeks: 1 };
+                break;
+            case 'month':
+                xAxisFormat = 'MMM_yyyy'; // Eg: "Sep 2023"
+                interval = { months: 1 };
+                break;
+            case 'year':
+                xAxisFormat = 'yyyy'; // Eg: "2023"
+                interval = { years: 1 };
+                break;
+            default:
+                xAxisFormat = 'MMM_dd_yyyy'; // Default to full date, Eg: "Sep 05, 2023"
+                interval = { days: 1 };
+                break;
+        }
+        const aggregation = {};
+        rows.sort((a, b) => new Date(a[dateField]) - new Date(b[dateField]));
+        const firstEntryDate = dateFilter?.startDate || new Date(rows[0][dateField]);
+        let formattedDate;
+        switch (timePeriod) {
+            case 'day': {
+                formattedDate = startOfDay(firstEntryDate);
+                break;
+            }
+            case 'week': {
+                formattedDate = startOfWeek(firstEntryDate, { weekStartsOn: 1 });
+                break;
+            }
+            case 'month': {
+                formattedDate = startOfMonth(firstEntryDate);
+                break;
+            }
+            case 'year': {
+                formattedDate = startOfYear(firstEntryDate);
+                break;
+            }
+            default:
+                throw new Error('Unsupported aggregation period');
+        }
+        let iteratedDate = new Date(formattedDate);
+        const endDate = dateFilter?.endDate || new Date();
+        while (iteratedDate <= endDate) {
+            aggregation[iteratedDate] = {};
+            dashboardItem.yAxisFields.forEach(yAxisField => {
+                aggregation[iteratedDate][yAxisField.field] = 0;
+            });
+            iteratedDate = add(iteratedDate, interval);
+        }
+        // TODO MAKE WORK WITH MULTIPLE Y AXIS FIELDS
+        rows.forEach(row => {
+            const date = parse(row[dateField], 'yyyy-MM-dd', new Date());
+            let formattedDate;
+            switch (timePeriod) {
+                case 'day': {
+                    formattedDate = startOfDay(date);
+                    break;
+                }
+                case 'week': {
+                    formattedDate = startOfWeek(date, { weekStartsOn: 1 });
+                    break;
+                }
+                case 'month': {
+                    formattedDate = startOfMonth(date);
+                    break;
+                }
+                case 'year': {
+                    formattedDate = startOfYear(date);
+                    break;
+                }
+                default:
+                    throw new Error('Unsupported aggregation period');
+            }
+            if (!aggregation[formattedDate]) {
+                aggregation[formattedDate] = {};
+                dashboardItem.yAxisFields.forEach(yAxisField => {
+                    aggregation[formattedDate][yAxisField.field] = 0;
+                });
+            }
+            // Sum the amounts for each field and period
+            dashboardItem.yAxisFields.forEach(yAxisField => {
+                aggregation[formattedDate][yAxisField.field] += parseFloat(row[yAxisField.field]);
+            });
+        });
+        // Convert the object to an array and format the spend amounts
+        const aggregatedArray = Object.keys(aggregation).length
+            ? Object.keys(aggregation)
+                .map(date => ({
+                [timePeriod]: date,
+                [dashboardItem.yAxisFields[0].field]: aggregation[date][dashboardItem.yAxisFields[0].field].toFixed(2),
+            }))
+                .sort((a, b) => new Date(a[timePeriod]) - new Date(b[timePeriod]))
+            : [];
+        if (dateFilter &&
+            dateFilter.comparison &&
+            dateFilter.comparisonRange.value !== 'NO_COMPARISON' &&
+            dashboardItem.compareRows) {
+            const offset = COMPARISON_OPTIONS.find(option => {
+                return option.value === dateFilter.comparisonRange.value;
+            })?.offset;
+            aggregatedArray.forEach(row => {
+                dashboardItem.yAxisFields.forEach(yAxisField => {
+                    row[yAxisField.field + '2'] = 0;
+                });
+                row[xAxisField + '2'] = sub(new Date(row[timePeriod]), offset).toISOString();
+            });
+            compareRows.sort((a, b) => new Date(a[dateField]) - new Date(b[dateField]));
+            compareRows.forEach((row, index) => {
+                let date = parse(row[dateField], 'yyyy-MM-dd', new Date());
+                date = add(date, offset);
+                let formattedDate;
+                switch (timePeriod) {
+                    case 'day': {
+                        formattedDate = startOfDay(date);
+                        break;
+                    }
+                    case 'week': {
+                        formattedDate = startOfWeek(date, { weekStartsOn: 1 });
+                        break;
+                    }
+                    case 'month': {
+                        formattedDate = startOfMonth(date);
+                        break;
+                    }
+                    case 'year': {
+                        formattedDate = startOfYear(date);
+                        break;
+                    }
+                    default:
+                        throw new Error('Unsupported aggregation period');
+                }
+                // Sum the amounts for each field and period
+                if (bucketFields?.length) {
+                    dashboardItem.yAxisFields.forEach(yAxisField => {
+                        const correctBucketIndex = aggregatedArray.findIndex(row => {
+                            return row[timePeriod] === formattedDate;
+                        });
+                        if (correctBucketIndex >= 0) {
+                            if (!aggregatedArray[correctBucketIndex][yAxisField.field + '2']) {
+                                aggregatedArray[correctBucketIndex][yAxisField.field + '2'] = 0;
+                            }
+                            aggregatedArray[correctBucketIndex][yAxisField.field + '2'] +=
+                                parseFloat(row[yAxisField.field]);
+                            if (!aggregatedArray[correctBucketIndex][xAxisField + '2']) {
+                                aggregatedArray[correctBucketIndex][xAxisField + '2'] =
+                                    new Date(row[dateField]);
+                            }
+                        }
+                    });
+                }
+                else {
+                    dashboardItem.yAxisFields.forEach(yAxisField => {
+                        if (aggregatedArray.length - 1 >= index) {
+                            if (!aggregatedArray[index][yAxisField.field + '2']) {
+                                aggregatedArray[index][yAxisField.field + '2'] = 0;
+                            }
+                            aggregatedArray[index][yAxisField.field + '2'] += parseFloat(row[yAxisField.field]);
+                            aggregatedArray[index][xAxisField + '2'] = new Date(row[dateField]);
+                        }
+                    });
+                }
+            });
+        }
+        return {
+            ...dashboardItem,
+            xAxisField,
+            xAxisLabel,
+            xAxisFormat,
+            bucketedRows: aggregatedArray,
+        };
+    }
+    else {
+        return dashboardItem;
+    }
+}

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

@@ -0,0 +1,20 @@
+type Field = {
+    _id: string;
+    label: string;
+    field: string;
+    format: 'percent';
+};
+type Props = {
+    value: string | number | boolean | undefined | null;
+    field: string | undefined | null;
+    fields: Field[];
+};
+/**
+ * Pretty-prints the given values to their nice-looking string form.
+ *
+ * The axis formatter will print a shorter version of the valueFormatter, which
+ * fits nicely along the X or Y axes.
+ */
+export declare const axisFormatter: ({ value, field, fields, }: Props) => string | number | boolean;
+export {};
+//# sourceMappingURL=axisFormatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axisFormatter.d.ts","sourceRoot":"","sources":["../../../src/utils/axisFormatter.ts"],"names":[],"mappings":"AAGA,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,8BAIvB,KAAK,KAAG,MAAM,GAAG,MAAM,GAAG,OA8B5B,CAAC"}

package/dist/esm/utils/axisFormatter.js

@@ -0,0 +1,190 @@
+import { endOfWeek, format, getWeek, isValid, startOfWeek } from 'date-fns';
+import { utcToZonedTime } from 'date-fns-tz';
+/**
+ * Pretty-prints the given values to their nice-looking string form.
+ *
+ * The axis formatter will print a shorter version of the valueFormatter, which
+ * fits nicely along the X or Y axes.
+ */
+export const axisFormatter = ({ value, field, fields, }) => {
+    if (field === undefined || field === null)
+        return '';
+    if (value === undefined || value === null)
+        return '';
+    const fieldInfo = fields.find((f) => f.field === field);
+    if (!fieldInfo)
+        return '';
+    const HANDLERS = {
+        percent: formatPercent,
+        dollar_amount: formatDollarAmount,
+        dollar_cents: formatDollarCents,
+        whole_number: formatWholeNumber,
+        one_decimal_place: formatOneDecimalPlace,
+        two_decimal_places: formatTwoDecimalPlaces,
+        string: formatString,
+        yyyy: format_YYYY,
+        MMM_yyyy: format_MMM_yyyy,
+        MMM_dd_yyyy: format_MMM_dd_yyyy,
+        hh_ap_pm: format_hh_ap_pm,
+        'MMM_dd-MMM_dd': format_MMM_dd_MMM_dd,
+        'MMM_dd_hh:mm_ap_pm': format_MMM_dd_hh_mm_ap_pm,
+        'wo, yyyy': format_wo_yyyy,
+    };
+    // try to handle this value using the associated formatType handler
+    const formatType = fieldInfo.format;
+    if (Object.keys(HANDLERS).includes(formatType)) {
+        return HANDLERS[formatType](value);
+    }
+    return formatString(value); // by default make this value a string
+};
+/**
+ * HELPER FUNCTION DEFINITIONS
+ **/
+/**
+ * Formats the value as a string using the built-in converstion.
+ */
+const formatString = (value) => {
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return value.toString();
+};
+/**
+ * Formats the value as a (rounded) currency amount in dollars.
+ *
+ * eg. @example format(1234.567) => "$1.2K"
+ */
+const formatDollarAmount = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumSignificantDigits: 2,
+        maximumSignificantDigits: 2,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value ?? 0));
+};
+/**
+ * Formats the value as a (rounded) currency amount in dollars and cents.
+ *
+ * @example format(1234.567) => "$1.2K"
+ */
+const formatDollarCents = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumSignificantDigits: 2,
+        maximumSignificantDigits: 2,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value ?? 0));
+};
+/**
+ * Formats the value as a (rounded) integer.
+ *
+ * @example format(1234.567) => "1.2K"
+ */
+const formatWholeNumber = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        minimumSignificantDigits: 2,
+        maximumSignificantDigits: 2,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value));
+};
+/**
+ * Formats the value as a number rounded to exactly one decimal place.
+ *
+ * @example format(1234.567) => "1.2K"
+ * @example format(123.456) => "1,234.6"
+ */
+const formatOneDecimalPlace = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: 1,
+        maximumFractionDigits: 1,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value));
+};
+/**
+ * Formats the value as a number rounded to exactly two decimal places.
+ *
+ * @example format(1234.567) => "1.23K"
+ * @example format(123.456) => "123.46"
+ */
+const formatTwoDecimalPlaces = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value));
+};
+/**
+ * Formats the value as a percentage.
+ *
+ * @example format(0.1234) => "12%"
+ * @example format(0.99) => "99%"
+ *
+ * NOTE: This function expects that the value is already a percentage value, and
+ * does not try to guess whether the percentage is represented as a whole number
+ * or a decimal.
+ *
+ * @example format(1234.567) => "120K%"
+ * @example format(99) => "9.9K%"
+ */
+const formatPercent = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'percent',
+        minimumSignificantDigits: 2,
+        maximumSignificantDigits: 2,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value));
+};
+// Converts the value to a UTC date with the given format string. If the
+// resulting date is invalid, it returns "Invalid date".
+const _getUTCDateHelper = (value, fmt) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    return format(utcDate, fmt);
+};
+const format_YYYY = (value) => _getUTCDateHelper(value, 'yyyy');
+const format_MMM_yyyy = (value) => _getUTCDateHelper(value, 'MMM yyyy');
+const format_hh_ap_pm = (value) => _getUTCDateHelper(value, 'hh:mm aa');
+const format_MMM_dd_yyyy = (value) => _getUTCDateHelper(value, 'dd MMM yyyy');
+const format_MMM_dd_MMM_dd = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    const monday = startOfWeek(utcDate, { weekStartsOn: 1 });
+    const sunday = endOfWeek(utcDate, { weekStartsOn: 1 });
+    // Check if start and end are in the same month
+    if (format(monday, 'MMM') === format(sunday, 'MMM')) {
+        return `${format(monday, 'MMM dd')} - ${format(sunday, 'dd')}`;
+    }
+    else {
+        return `${format(monday, 'MMM dd')} - ${format(sunday, 'MMM dd')}`;
+    }
+};
+const format_MMM_dd_hh_mm_ap_pm = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    const formatStr = utcDate.getMinutes() === 0 ? 'MMM do h a' : 'MMM do h:mm a';
+    const res = format(utcDate, formatStr);
+    return res.slice(0, -2) + res.slice(-2).toLowerCase();
+};
+const format_wo_yyyy = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    return `${getWeek(utcDate)},${utcDate.getFullYear()}`;
+};

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

@@ -0,0 +1,13 @@
+declare const colorValues: readonly ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose"];
+export type Color = (typeof colorValues)[number];
+/**
+ * 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 declare function selectColor(element: any, colors: string[], index: number): string;
+export {};
+//# sourceMappingURL=color.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../src/utils/color.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,WAAW,mKAkBP,CAAC;AAEX,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAuBxE"}