@quillsql/react 2.15.2 → 2.15.4

package/dist/esm/utils/filterProcessing.js

@@ -1,590 +0,0 @@
-import { endOfDay, parse, startOfDay, sub } from 'date-fns';
-import { COMPARISON_RANGE, PRIMARY_RANGE, convertPresetOptionsToSelectableList, defaultOptionsV2, getRangeFromPresetOptions, } from '../DateRangePicker/dateRangePickerUtils';
-import { DateOperator, FieldType, InternalFilterType, InternalDashboardFilterType as DashboardFilterType, TimeUnit, FilterType, } from '../models/Filter';
-import { filterTreeToAst } from './astFilterProcessing';
-import { snakeAndCamelCaseToTitleCase } from './textProcessing';
-import { reportBuilderStateToAst } from './reportBuilder';
-import { quillFetch } from './dataFetcher';
-export function findAndProcessDateFilter(filters) {
-    let dateFilter = filters.find((filter) => filter.filterType === 'date_range');
-    if (dateFilter) {
-        // For the TRADITIONAL date filter
-        return dateFilter;
-    }
-    // For the new date filter
-    dateFilter = filters.find((filter) => filter.operator === 'BETWEEN' &&
-        filter.values &&
-        isValidDate(filter.values[0]));
-    if (!dateFilter) {
-        return null;
-    }
-    return {
-        startDate: new Date(dateFilter.values[0]),
-        endDate: new Date(dateFilter.values[1]),
-    };
-}
-function isValidDate(date) {
-    return !isNaN(Date.parse(date));
-}
-export function processFilterFromBackend(filter) {
-    if (filter.filterType === 'date_range') {
-        return {
-            ...filter,
-            startDate: filter.startDate ? new Date(filter.startDate) : undefined,
-            endDate: filter.endDate ? new Date(filter.endDate) : undefined,
-            options: defaultOptionsV2,
-            comparisonRange: {
-                ...filter.comparisonRange,
-                value: 'PREV_PERIOD',
-            },
-        };
-    }
-    if (filter.filterType === 'string') {
-        return filter;
-    }
-    return filter;
-}
-export function updateFilter(filter, value = null, comparison = null, dashboardName) {
-    //for dateObjects only, since values are arrays for dateObjects
-    const { ...filterWithoutSelectedValue } = filter;
-    if (filter.filterType === 'string') {
-        let selectedValue = {};
-        if (value || value === '') {
-            if (filter.stringFilterType === 'multiselect') {
-                const parsedValue = value;
-                if (parsedValue.length === 0) {
-                    selectedValue = { values: [] };
-                }
-                else {
-                    selectedValue = { values: parsedValue, operator: 'IN' };
-                }
-            }
-            else {
-                selectedValue = { selectedValue: value };
-            }
-        }
-        return {
-            ...filterWithoutSelectedValue,
-            ...selectedValue,
-            dashboardName: dashboardName,
-        };
-    }
-    if (filter.filterType === 'date' || filter.filterType === 'date_range') {
-        let presetsOptions = defaultOptionsV2;
-        if (filter.presetOptions || filter.defaultPresetRanges) {
-            presetsOptions = convertPresetOptionsToSelectableList(filter.presetOptions ?? [], filter.defaultPresetRanges ?? []);
-        }
-        if (comparison ||
-            (filter.comparison && filter.comparisonRange.value !== 'NO_COMPARISON')) {
-            const key = comparison?.value || filter.comparisonRange.value;
-            let primaryRange = {
-                startDate: value ? value.startDate : filter.startDate,
-                endDate: value ? value.endDate : filter.endDate,
-            };
-            if (value && value.preset) {
-                primaryRange = getRangeFromPresetOptions(value.preset, presetsOptions);
-            }
-            return {
-                startDate: primaryRange.startDate,
-                endDate: primaryRange.endDate,
-                filterType: 'date_range',
-                label: 'Date',
-                field: 'date_range',
-                preset: filter.preset,
-                options: filter.options,
-                comparison: true,
-                comparisonRange: {
-                    startDate: COMPARISON_RANGE[key](primaryRange)
-                        ?.startDate,
-                    endDate: COMPARISON_RANGE[key](primaryRange)?.endDate,
-                    value: key,
-                },
-                dashboardName: name,
-            };
-        }
-        else {
-            const primaryRange = value && value.preset
-                ? getRangeFromPresetOptions(value.preset, presetsOptions)
-                : {
-                    startDate: value?.startDate || filter.startDate,
-                    endDate: value?.endDate || filter.endDate,
-                };
-            return {
-                ...filter,
-                preset: filter.preset,
-                startDate: primaryRange.startDate,
-                endDate: primaryRange.endDate,
-                filterType: 'date_range',
-                field: 'date_range',
-                options: filter.options,
-                label: 'Date',
-                dashboardName: dashboardName,
-            };
-        }
-    }
-}
-// Function to translate field type to "string", "numeric", or "date"
-export const getType = (t) => {
-    // strip any size numbers at the end
-    // TODO: 'max' data types, e.g. varchar(max)
-    t = t.replace(/\d+$/, '');
-    switch (t) {
-        case 'string':
-        case 'char':
-        case 'varchar':
-        case 'nchar':
-        case 'nvarchar':
-        case 'ntext':
-        case 'binary':
-        case 'varbinary':
-        case 'tinyblob':
-        case 'tinytext':
-        case 'blob':
-        case 'mediumtext':
-        case 'mediumblob':
-        case 'longtext':
-        case 'longblob':
-        case 'text':
-            return FieldType.String;
-        case 'numeric':
-        case 'bit':
-        case 'tinybit':
-        case 'smallint':
-        case 'mediumint':
-        case 'int':
-        case 'tinyint':
-        case 'integer':
-        case 'bigint':
-        case 'float':
-        case 'double':
-        case 'double precision':
-        case 'decimal':
-        case 'dec':
-        case 'smallmoney':
-        case 'money':
-        case 'real':
-            return FieldType.Number;
-        case 'date':
-        case 'datetime':
-        case 'datetime2':
-        case 'smalldatetime':
-        case 'datetimeoffset':
-        case 'timestamp':
-        case 'timestamptz':
-        case 'time':
-        case 'year':
-            return FieldType.Date;
-        case 'bool':
-        case 'boolean':
-            return FieldType.Boolean;
-        case 'anyarray':
-            return FieldType.Null;
-        default:
-            return FieldType.String;
-    }
-};
-/**
- * Returns a sentence to describe a Filter
- */
-export function filterSentence(filter) {
-    let value = '';
-    if (filter.filterType == InternalFilterType.NullFilter) {
-        return `${snakeAndCamelCaseToTitleCase(filter.field)} ${filter.operator}`;
-    }
-    else if (filter.value === null || filter.value === undefined) {
-        return 'Error: filter missing value';
-    }
-    if (typeof filter.value === 'string' || typeof filter.value === 'number') {
-        value = filter.value.toString();
-    }
-    else if (filter.value === false || filter.value === true) {
-        value = filter.value.toString();
-    }
-    else if ('unit' in filter.value) {
-        if (filter.operator === DateOperator.InTheCurrent) {
-            value = `${filter.value.unit}`;
-        }
-        else {
-            value = `${filter.value.value} ${filter.value.unit}${filter.value.value === 1 ? '' : 's'}`;
-        }
-    }
-    else if ('startDate' in filter.value) {
-        value = `from ${filter.value.startDate}`;
-    }
-    else if (filter.value.length > 0) {
-        value = filter.value.join(', ');
-    }
-    return `${snakeAndCamelCaseToTitleCase(filter.field)} ${filter.operator}${filter.operator === 'is' || filter.operator === 'is not' ? ' one of' : ''} ${value}`;
-}
-/**
- * Function that flattens a tree of filters into an array
- */
-export function generateFilterStack(filterTree) {
-    if (!filterTree) {
-        return [];
-    }
-    const tree = filterTree;
-    let filterStack = [];
-    /**
-     * Function that takes in a FilterTree and flattens it into an array using in order traversal
-     */
-    function traverseTree(node) {
-        if (!node) {
-            return;
-        }
-        if (node.leaf) {
-            filterStack.push(node);
-        }
-        else {
-            traverseTree(node.leftNode);
-            filterStack.push(node);
-            traverseTree(node.rightNode);
-        }
-    }
-    traverseTree(tree);
-    // Remove null (invalid) filters from filter stack
-    filterStack = filterStack.filter((filter) => {
-        return ((!filter.leaf &&
-            filter.rightNode &&
-            (!filter.rightNode.leaf || filter.rightNode.value)) ||
-            (filter.leaf && filter.value));
-    });
-    return filterStack;
-}
-/**
- * Given an array of Filters (presumed to be in in-order state), generate
- * the corresponding Filter tree. Essentially the reverse of what traverseTree does
- */
-export function filterStackToFilterTree(stack) {
-    function buildTree(i) {
-        const newNode = {
-            leaf: false,
-            operator: null,
-            leftNode: null,
-            rightNode: null,
-        };
-        if (i >= stack.length) {
-            return null;
-        }
-        else if (stack[i].leaf) {
-            if (i < stack.length - 1) {
-                // more nodes later
-                newNode.operator = stack[i + 1].operator;
-                newNode.leftNode = {
-                    leaf: true,
-                    leftNode: null,
-                    rightNode: null,
-                    operator: null,
-                    value: stack[i].value,
-                };
-                newNode.rightNode = buildTree(i + 2);
-            }
-            else {
-                newNode.leaf = true;
-                newNode.value = stack[i].value;
-            }
-        }
-        return newNode;
-    }
-    return buildTree(0);
-}
-/**
- * This function uses the baseAst and forms a SQL query using the a filters array
- */
-export async function buildQueryFromFilters(reportBuilderState, filters, client, getToken, eventTracking) {
-    const subTree = filterStackToFilterTree(filters);
-    let whereNode = null;
-    if (subTree) {
-        whereNode = filterTreeToAst(subTree, client.databaseType?.toLowerCase() || 'postgresql');
-    }
-    const ast = reportBuilderStateToAst({ ...reportBuilderState, filterStack: filters }, client.databaseType?.toLowerCase() || 'postgresql');
-    const queryAst = { ...ast, where: whereNode };
-    try {
-        const { data } = await quillFetch({
-            client,
-            task: 'sqlify',
-            metadata: {
-                clientId: client.clientId,
-                useNewNodeSql: true,
-                ast: queryAst,
-            },
-            getToken,
-        });
-        const query = data?.query;
-        return { success: true, query };
-    }
-    catch (error) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error building query from filters',
-            errorMessage: error.message,
-            errorStack: error.stack,
-            errorData: {
-                caller: 'buildQueryFromFilters',
-                function: 'buildQueryFromFilters',
-            },
-        });
-        return { success: false, error: `error: ${error.message}` };
-    }
-}
-export function applyCustomFilterToDashDateFilter(customDateFilter, dashboardDateFilter) {
-    if (customDateFilter.filterType === FilterType.Date &&
-        customDateFilter.value &&
-        typeof customDateFilter.value === 'object' &&
-        'startDate' in customDateFilter.value &&
-        'endDate' in customDateFilter.value) {
-        const startDate = customDateFilter.value.startDate;
-        const endDate = customDateFilter.value.endDate;
-        return {
-            ...dashboardDateFilter,
-            startDate: new Date(startDate),
-            endDate: new Date(endDate),
-        };
-    }
-    else if (customDateFilter.filterType === FilterType.Date &&
-        customDateFilter.value &&
-        typeof customDateFilter.value === 'object' &&
-        'value' in customDateFilter.value &&
-        'unit' in customDateFilter.value) {
-        const { value, unit } = customDateFilter.value;
-        let processedUnit;
-        let processedValue = value || 1;
-        switch (unit) {
-            case TimeUnit.Day:
-                processedUnit = 'days';
-                break;
-            case TimeUnit.Week:
-                processedUnit = 'weeks';
-                break;
-            case TimeUnit.Month:
-                processedUnit = 'months';
-                break;
-            case TimeUnit.Year:
-                processedUnit = 'years';
-                break;
-            case TimeUnit.Hour:
-                processedUnit = 'hours';
-                break;
-            case TimeUnit.Quarter:
-                processedUnit = 'months';
-                processedValue *= 3;
-                break;
-        }
-        switch (customDateFilter.operator) {
-            case DateOperator.InTheLast:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: sub(new Date(), { [processedUnit]: processedValue }),
-                    endDate: new Date(),
-                };
-            // This represents the previous period compared to the current period.
-            // For instance, if the current period is the last 30 days, the previous period would be the 30 days before that.
-            case DateOperator.InThePrevious:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: sub(new Date(), { [processedUnit]: processedValue * 2 }),
-                    endDate: sub(new Date(), { [processedUnit]: processedValue }),
-                };
-            // This represents the current period, and value is always 0.
-            // For instance if today was the 5th of August, the current month would be from the 1st to the 5th of August.
-            case DateOperator.InTheCurrent:
-                switch (unit) {
-                    case TimeUnit.Day:
-                        return {
-                            ...dashboardDateFilter,
-                            startDate: startOfDay(new Date()),
-                            endDate: endOfDay(new Date()),
-                        };
-                    case TimeUnit.Week:
-                        return {
-                            ...dashboardDateFilter,
-                            startDate: sub(new Date(), { days: new Date().getDay() }),
-                            endDate: new Date(),
-                        };
-                    case TimeUnit.Month:
-                        return {
-                            ...dashboardDateFilter,
-                            startDate: new Date(new Date().getFullYear(), new Date().getMonth(), 1),
-                            endDate: new Date(),
-                        };
-                    case TimeUnit.Year:
-                        return {
-                            ...dashboardDateFilter,
-                            startDate: new Date(new Date().getFullYear(), 0, 1),
-                            endDate: new Date(),
-                        };
-                    case TimeUnit.Quarter:
-                        return {
-                            ...dashboardDateFilter,
-                            startDate: new Date(new Date().getFullYear(), Math.floor(new Date().getMonth() / 3) * 3, 1),
-                            endDate: new Date(),
-                        };
-                    case TimeUnit.Hour:
-                        return {
-                            ...dashboardDateFilter,
-                            startDate: new Date(new Date().getFullYear(), new Date().getMonth(), new Date().getDate(), new Date().getHours()),
-                            endDate: new Date(),
-                        };
-                }
-                break;
-            default:
-                return dashboardDateFilter;
-        }
-    }
-    else if (customDateFilter.filterType === FilterType.Date &&
-        customDateFilter.value &&
-        typeof customDateFilter.value === 'string') {
-        const parsedDate = parse(customDateFilter.value, 'yyyy-mm-dd', new Date());
-        switch (customDateFilter.operator) {
-            case DateOperator.GreaterThanOrEqualTo:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: parsedDate,
-                    endDate: undefined,
-                };
-            case DateOperator.LessThanOrEqualTo:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: undefined,
-                    endDate: parsedDate,
-                };
-            case DateOperator.LessThan:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: undefined,
-                    endDate: sub(parsedDate, { days: 1 }),
-                };
-            case DateOperator.GreaterThan:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: sub(parsedDate, { days: 1 }),
-                    endDate: undefined,
-                };
-            case DateOperator.EqualTo:
-                return {
-                    ...dashboardDateFilter,
-                    startDate: parsedDate,
-                    endDate: parsedDate,
-                };
-            default:
-                return dashboardDateFilter;
-        }
-    }
-    return dashboardDateFilter;
-}
-export function mergeCustomFilters(filters, customFilters) {
-    const customDateFilters = customFilters.filter((filter) => filter.filterType === InternalFilterType.DateCustomFilter ||
-        filter.filterType === InternalFilterType.DateFilter ||
-        filter.filterType === InternalFilterType.DateComparisonFilter);
-    if (customDateFilters.length === 0) {
-        return filters.concat(customFilters);
-    }
-    const withoutDate = filters.filter((filter) => filter.filterType !== DashboardFilterType.Date);
-    const customWithoutDate = customFilters.filter((filter) => filter.filterType !== InternalFilterType.DateCustomFilter);
-    const withDate = filters.find((filter) => filter.filterType === DashboardFilterType.Date);
-    return withoutDate
-        .concat([
-        withDate
-            ? applyCustomFilterToDashDateFilter(customDateFilters[0], withDate)
-            : {
-                filterType: DashboardFilterType.Date,
-                label: 'Date',
-                field: customDateFilters[0].field,
-                table: customDateFilters[0].table,
-                options: defaultOptionsV2,
-                primaryRange: {
-                    label: 'Last 30 Days',
-                    value: 'LAST_30_DAYS',
-                },
-                dashboardName: 'none',
-                presetOptions: [],
-                defaultPresetRanges: [],
-                preset: {
-                    label: 'Last 30 Days',
-                    value: 'LAST_30_DAYS',
-                },
-                startDate: new Date(customDateFilters[0].value.startDate),
-                endDate: new Date(customDateFilters[0].value.endDate),
-            },
-    ])
-        .concat(customWithoutDate);
-}
-export function filtersAreEquivalent(filters1, filters2) {
-    if (!filters1 && !filters2) {
-        return true;
-    }
-    if (!filters1 || !filters2) {
-        return false;
-    }
-    if (filters1.length !== filters2.length) {
-        return false;
-    }
-    const sortedFilters1 = [...filters1].sort((a, b) => `${a.table ?? ''}.${a.field}`.localeCompare(`${b.table ?? ''}.${b.field}`));
-    const sortedFilters2 = [...filters2].sort((a, b) => `${a.table ?? ''}.${a.field}`.localeCompare(`${b.table ?? ''}.${b.field}`));
-    for (let i = 0; i < sortedFilters1.length; i++) {
-        if (sortedFilters1[i]?.field !== sortedFilters2[i]?.field ||
-            sortedFilters1[i]?.filterType !== sortedFilters2[i]?.filterType ||
-            sortedFilters1[i]?.fieldType !== sortedFilters2[i]?.fieldType ||
-            sortedFilters1[i]?.operator !== sortedFilters2[i]?.operator ||
-            sortedFilters1[i]?.value !== sortedFilters2[i]?.value ||
-            sortedFilters1[i]?.table !== sortedFilters2[i]?.table) {
-            return false;
-        }
-    }
-    return true;
-}
-export const createDefaultDateFilter = (filter, reports, dashboardName) => {
-    const comparisonRangeStart = getComparisonRange(filter, 'startDate');
-    const comparisonRangeEnd = getComparisonRange(filter, 'endDate');
-    const range = PRIMARY_RANGE[filter.primaryRange?.value ?? 'LAST_30_DAYS'] ??
-        PRIMARY_RANGE['LAST_30_DAYS'];
-    return filter
-        ? {
-            ...filter,
-            startDate: !range.startDate || range.startDate instanceof Date
-                ? range.startDate
-                : new Date(range.startDate), // when range.startDate is a string
-            endDate: !range.endDate || range.endDate instanceof Date
-                ? range.endDate
-                : new Date(range.endDate), // when range.endDate is a string
-            filterType: DashboardFilterType.Date,
-            dateField: [
-                ...new Map(reports.map((report) => {
-                    const key = JSON.stringify(report.dateField);
-                    return [key, report.dateField];
-                })).values(),
-            ],
-            options: defaultOptionsV2,
-            preset: filter.primaryRange,
-            dashboardName: dashboardName,
-            comparisonRange: filter.comparison && comparisonRangeStart && comparisonRangeEnd
-                ? {
-                    startDate: comparisonRangeStart,
-                    endDate: comparisonRangeEnd,
-                    value: filter.comparisonRange?.value ??
-                        filter?.defaultComparisonRange ??
-                        'NO_COMPARISON',
-                }
-                : undefined,
-        }
-        : undefined;
-};
-const getComparisonRange = (dateFilter, rangeType) => {
-    const range = convertPresetOptionsToSelectableList(dateFilter?.presetOptions ?? [], dateFilter?.defaultPresetRanges ?? []).find((option) => option.value === dateFilter?.primaryRange?.value) ??
-        PRIMARY_RANGE[dateFilter?.primaryRange?.value ?? 'LAST_30_DAYS'] ??
-        PRIMARY_RANGE['LAST_30_DAYS'];
-    if (!range.startDate || !range.endDate) {
-        return undefined;
-    }
-    return (dateFilter?.comparisonRange?.[rangeType] ??
-        COMPARISON_RANGE[dateFilter?.defaultComparisonRange ??
-            'NO_COMPARISON']({
-            startDate: !range.startDate || range.startDate instanceof Date
-                ? range.startDate
-                : new Date(range.startDate), // when range.startDate is a string
-            endDate: !range.endDate || range.endDate instanceof Date
-                ? range.endDate
-                : new Date(range.endDate), // when range.endDate is a string
-        })?.[rangeType]);
-};

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

@@ -1,11 +0,0 @@
-/**
- * Calculates the adjusted domain for numeric values in the specified fields of the given data.
- * @param data - The data containing numeric fields.
- * @param  fields - The fields to consider for domain calculation.
- * @returns - An array representing the adjusted domain [min, max].
- */
-export default function getDomain(data: any[], fields: any[], referenceLines: {
-    label: string;
-    query: number[];
-}[] | undefined): number[];
-//# sourceMappingURL=getDomain.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getDomain.d.ts","sourceRoot":"","sources":["../../../src/utils/getDomain.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,EAAE,GAAG,EAAE,EACb,cAAc,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,EAAE,GAAG,SAAS,GAC/D,MAAM,EAAE,CA6CV"}

package/dist/esm/utils/getDomain.js

@@ -1,62 +0,0 @@
-/**
- * Calculates the adjusted domain for numeric values in the specified fields of the given data.
- * @param data - The data containing numeric fields.
- * @param  fields - The fields to consider for domain calculation.
- * @returns - An array representing the adjusted domain [min, max].
- */
-export default function getDomain(data, fields, referenceLines) {
-    const fieldsArray = fields.map((elem) => elem.field);
-    const numericValues = [];
-    data.forEach((item) => {
-        fieldsArray.forEach((field) => {
-            let value = item[field];
-            // Try to cast the value to a number
-            const numericValue = parseFloat(value);
-            if (!isNaN(numericValue)) {
-                value = numericValue;
-            }
-            if (typeof value === 'number') {
-                numericValues.push(value);
-            }
-        });
-    });
-    if (referenceLines) {
-        referenceLines.forEach((line) => {
-            if (typeof line.query[0] === 'number') {
-                numericValues.push(line.query[0]);
-            }
-            if (typeof line.query[line.query.length - 1] === 'number') {
-                numericValues.push(line.query[line.query.length - 1]);
-            }
-        });
-    }
-    const [minValue, maxValue] = numericValues.reduce(([min, max], value) => [Math.min(min, value), Math.max(max, value)], [Infinity, -Infinity]);
-    if (minValue === 0 && maxValue === 0) {
-        return [0, 1];
-    }
-    if (minValue === Infinity && maxValue === -Infinity) {
-        return [0, 1];
-    }
-    return fuzzyRound(Math.min(minValue, 0), maxValue);
-}
-// Rounds the range to 4 equally-spaced increments of nice,round numbers.
-function fuzzyRound(min, max) {
-    const range = parseFloat((max - min).toPrecision(1));
-    const increment = Math.ceil(range / 4);
-    let newMin = min;
-    // if (min % increment !== 0) {
-    //   newMin = min - (min % increment);
-    // }
-    if (Number.isNaN(newMin)) {
-        newMin = 0;
-    }
-    let newMax = min + increment * 4;
-    if (max % increment !== 0) {
-        const adjMax = max + (increment - (max % increment));
-        newMax = parseFloat(adjMax.toPrecision(2));
-    }
-    if (Number.isNaN(newMax)) {
-        newMax = 0;
-    }
-    return [newMin ?? 0, newMax ?? 0];
-}

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

@@ -1,2 +0,0 @@
-export declare function internalLog(message: string, ...optionalParams: any[]): void;
-//# sourceMappingURL=logging.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/utils/logging.ts"],"names":[],"mappings":"AACA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE,QAKpE"}

package/dist/esm/utils/logging.js

@@ -1,7 +0,0 @@
-/* eslint-disable no-undef */
-export function internalLog(message, ...optionalParams) {
-    if (process?.env?.QUILL_ENV === 'development') {
-        const completeMessage = `Quill: ${message}: ${optionalParams.join('\n')}`;
-        console.log(completeMessage);
-    }
-}