@quillsql/react 2.8.7 → 2.8.9

package/dist/utils/axisFormatter.js

@@ -0,0 +1,185 @@
+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 value.toString(); // by default make this value a string
+};
+/**
+ * HELPER FUNCTION DEFINITIONS
+ **/
+/**
+ * Formats the value as a string using the built-in converstion.
+ */
+const formatString = (value) => 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/utils/schema.d.ts

@@ -0,0 +1,22 @@
+interface TableInfo {
+    displayName: string;
+    columns: {
+        name: string;
+        label: string;
+        fieldType: string;
+    }[];
+}
+export interface ColumnSelectorInfo {
+    name: string;
+    selected: boolean;
+    presentTables: string[];
+    selectable: boolean;
+    tableName: string;
+    displayName: string;
+    textFiltered: boolean;
+    fieldType: string;
+}
+export declare function formatColumnData(tableInfo: TableInfo[], selectedTable: any, customerFieldName: string): ColumnSelectorInfo[];
+export declare function columnGrouping(tableInfo: TableInfo[]): any[];
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/utils/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/utils/schema.ts"],"names":[],"mappings":"AAGA,UAAU,SAAS;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC/D;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,EAAE,EACtB,aAAa,EAAE,GAAG,EAClB,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,EAAE,CA0CtB;AAGD,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,GAAG,EAAE,CAmG5D"}

package/dist/utils/schema.js

@@ -0,0 +1,134 @@
+import { deSnakeOrCamelCase, singularize } from './textFormatting';
+export function formatColumnData(tableInfo, selectedTable, customerFieldName) {
+    const initialState = [];
+    const formattedData = tableInfo.reduce((allColumnDetails, table) => {
+        let setSelected = false;
+        if (selectedTable.displayName === table.displayName) {
+            setSelected = true;
+        }
+        table.columns.forEach((column) => {
+            if (column.name === customerFieldName) {
+                return;
+            }
+            let formattedDisplayName = '';
+            console.log(column.name);
+            if (column.name.endsWith('_id')) {
+                formattedDisplayName = singularize(deSnakeOrCamelCase(column.name));
+            }
+            else {
+                formattedDisplayName =
+                    singularize(deSnakeOrCamelCase(table.displayName)) +
+                        ' ' +
+                        deSnakeOrCamelCase(column.name);
+            }
+            const presentColumn = allColumnDetails.find((columnDetail) => columnDetail.displayName === formattedDisplayName);
+            if (presentColumn) {
+                presentColumn.presentTables.push(table.displayName);
+            }
+            else {
+                allColumnDetails.push({
+                    name: column.name,
+                    selected: setSelected,
+                    presentTables: [table.displayName],
+                    selectable: setSelected,
+                    tableName: table.displayName,
+                    displayName: formattedDisplayName,
+                    textFiltered: true,
+                    fieldType: column.fieldType,
+                });
+            }
+        });
+        return allColumnDetails;
+    }, initialState);
+    return formattedData;
+}
+// THIS FUNCTION IS A CURRENTLY NOT IN USE BUT IS A STRONG EXAMPLE OF AUTOMATED JOINS
+export function columnGrouping(tableInfo) {
+    const tableMap = {};
+    tableInfo.forEach((table) => {
+        tableMap[table.displayName] = [];
+    });
+    tableInfo.forEach((table) => {
+        tableMap[table.displayName]?.push(table.displayName);
+        table.columns.forEach((column) => {
+            if (column.name.endsWith('_id')) {
+                const otherTable = column.name.replace('_id', '') + 's';
+                const possibleTable = column.name.replace('_id', '');
+                if (tableMap[table.displayName]) {
+                    tableMap[table.displayName]?.push(otherTable);
+                    tableMap[table.displayName]?.push(possibleTable);
+                    tableMap[otherTable]?.push(table.displayName);
+                    tableMap[possibleTable]?.push(table.displayName);
+                }
+            }
+        });
+    });
+    function dfs(tableName, visited, group) {
+        group.push(tableName);
+        visited[tableName] = true;
+        tableMap[tableName]?.forEach((table) => {
+            if (!visited[table]) {
+                dfs(table, visited, group);
+            }
+        });
+    }
+    // perform a depth first search to create a grouping of tables that can be selected all together
+    const visited = {};
+    const groups = [];
+    const tableNames = Object.keys(tableMap);
+    let i = 0;
+    tableNames.forEach((table) => {
+        if (!visited[table]) {
+            groups.push([]);
+            dfs(table, visited, groups[i]);
+            i++;
+        }
+    });
+    const formattedGroups = groups.map((tableGroup) => {
+        // loop through all the columns in each table and add them to columnsFormatted
+        // if the coulmn name isn't a foreign key then format the name to be more readable. example User.id -> User Id
+        // if the column is a foreign key then format the name to be like the following. example user_id -> User Id
+        const formattedColumns = tableGroup.map((table) => {
+            const curTableInfo = tableInfo.find((tableInfo) => tableInfo.displayName === table);
+            if (curTableInfo) {
+                const columns = curTableInfo.columns.map((column) => {
+                    if (column.name.endsWith('_id')) {
+                        return {
+                            displayName: singularize(deSnakeOrCamelCase(column.name)),
+                            tableName: curTableInfo.displayName,
+                            name: column.name,
+                        };
+                    }
+                    return {
+                        displayName: singularize(deSnakeOrCamelCase(table)) +
+                            ' ' +
+                            deSnakeOrCamelCase(column.name),
+                        tableName: curTableInfo.displayName,
+                        name: column.name,
+                    };
+                });
+                return columns;
+            }
+            return [];
+        });
+        // if there are multiple objects with the same name then flatten the array and remove duplicates by name
+        const formattedColumnsFlat = formattedColumns.flat().filter((column, i) => {
+            return (formattedColumns
+                .flat()
+                .findIndex((c) => c.displayName === column.displayName) === i);
+        });
+        const formattedColumnsFlatNames = formattedColumnsFlat.map((column) => {
+            return {
+                displayName: column.displayName,
+                selected: false,
+                group: tableGroup.join('_'),
+                selectable: true,
+                tableName: column.tableName,
+                name: column.name,
+                textFiltered: true,
+            };
+        });
+        return formattedColumnsFlatNames;
+    });
+    return formattedGroups.flat();
+}

package/dist/utils/textFormatting.d.ts

@@ -0,0 +1,4 @@
+export declare function capitalize(str: string): string;
+export declare function singularize(str: string): string;
+export declare function deSnakeOrCamelCase(value: string): string;
+//# sourceMappingURL=textFormatting.d.ts.map

package/dist/utils/textFormatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textFormatting.d.ts","sourceRoot":"","sources":["../../src/utils/textFormatting.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAGD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO/C;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBxD"}

package/dist/utils/textFormatting.js

@@ -0,0 +1,38 @@
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+// create a function that removes pluralization
+export function singularize(str) {
+    if (str.endsWith('ies')) {
+        return str.slice(0, str.length - 3) + 'y';
+    }
+    else if (str.endsWith('s')) {
+        return str.slice(0, str.length - 1);
+    }
+    return str;
+}
+export function deSnakeOrCamelCase(value) {
+    if (value.toLowerCase() === 'id') {
+        return 'ID';
+    }
+    let splitVals = [];
+    if (/_/.test(value)) {
+        splitVals = value.split('_');
+    }
+    else if (/[a-z][A-Z]/.test(value)) {
+        splitVals = value.split(/(?=[A-Z])/);
+    }
+    if (splitVals.length > 0) {
+        splitVals.forEach((val, index) => {
+            console.log(val);
+            if (val.toLowerCase() === 'id') {
+                splitVals[index] = 'ID';
+            }
+            else {
+                splitVals[index] = capitalize(val);
+            }
+        });
+        return splitVals.join(' ');
+    }
+    return capitalize(value);
+}

package/dist/utils/valueFormatter.d.ts

@@ -0,0 +1,17 @@
+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.
+ */
+export declare const valueFormatter: ({ value, field, fields, }: Props) => string | number | boolean;
+export {};
+//# sourceMappingURL=valueFormatter.d.ts.map

package/dist/utils/valueFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFormatter.d.ts","sourceRoot":"","sources":["../../src/utils/valueFormatter.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;;GAEG;AACH,eAAO,MAAM,cAAc,8BAIxB,KAAK,KAAG,MAAM,GAAG,MAAM,GAAG,OA+B5B,CAAC"}

package/dist/utils/valueFormatter.js

@@ -0,0 +1,166 @@
+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.
+ */
+export const valueFormatter = ({ 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 value.toString(); // by default make this value a string
+};
+/**
+ * HELPER FUNCTION DEFINITIONS
+ **/
+/**
+ * Formats the value as a string using the built-in converstion.
+ */
+const formatString = (value) => value.toString();
+/**
+ * Formats the value as a (rounded) currency amount in dollars.
+ *
+ * eg. @example format(1234.567) => "$1,235"
+ */
+const formatDollarAmount = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        maximumFractionDigits: 0,
+    });
+    return formatter.format(Number(value ?? 0));
+};
+/**
+ * Formats the value as a (rounded) currency amount in dollars and cents.
+ *
+ * @example format(1234.567) => "$1,234.57"
+ */
+const formatDollarCents = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+    return formatter.format(Number(value ?? 0));
+};
+/**
+ * Formats the value as a (rounded) integer.
+ *
+ * @example format(1234.567) => "1,235"
+ */
+const formatWholeNumber = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        maximumFractionDigits: 0,
+    });
+    return formatter.format(Number(value));
+};
+/**
+ * Formats the value as a number rounded to exactly one decimal place.
+ *
+ * @example format(1234.567) => "1,234.6"
+ */
+const formatOneDecimalPlace = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: 1,
+        maximumFractionDigits: 1,
+    });
+    return formatter.format(Number(value));
+};
+/**
+ * Formats the value as a number rounded to exactly two decimal places.
+ *
+ * @example format(1234.567) => "1,234.57"
+ */
+const formatTwoDecimalPlaces = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+    return formatter.format(Number(value));
+};
+/**
+ * Formats the value as a percentage.
+ *
+ * @example format(0.1234) => "12.34%"
+ * @example format(0.99) => "99.00%"
+ *
+ * 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) => "123,456.70%"
+ * @example format(99) => "9,900.00%"
+ */
+const formatPercent = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'percent',
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+    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/utils/valueFormatterCSV.d.ts

@@ -0,0 +1,17 @@
+type Field = {
+    _id: string;
+    label: string;
+    field: string;
+    format: 'percent';
+};
+type Props = {
+    value: string | number | boolean | undefined | null;
+    field: string | undefined | null;
+    fields: Field[];
+};
+/**
+ * Formats a value to CSV-format.
+ */
+export declare const valueFormatterCSV: ({ value, field, fields, }: Props) => string | number | boolean;
+export {};
+//# sourceMappingURL=valueFormatterCSV.d.ts.map

package/dist/utils/valueFormatterCSV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFormatterCSV.d.ts","sourceRoot":"","sources":["../../src/utils/valueFormatterCSV.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;;GAEG;AACH,eAAO,MAAM,iBAAiB,8BAI3B,KAAK,KAAG,MAAM,GAAG,MAAM,GAAG,OA+B5B,CAAC"}