tubular-common/dist/Models/columnUtils.js

Tubular Common Models and Data Transformer

import dayjs from 'dayjs';
import customParseFormat from 'dayjs/plugin/customParseFormat';
import { AggregateFunctions, ColumnDataType, ColumnSortDirection, CompareOperators } from './Column';
dayjs.extend(customParseFormat);
const normalizaRegex = /([a-z])([A-Z])/g;
const defaultOriginDateFormat = 'YYYY-MM-DD';
const defaultOriginDateTimeFormat = 'YYYY-MM-DDTHH:mm:ss';
const defaultDisplayDateFormat = 'YYYY-MM-DD';
const defaultDisplayDateTimeFormat = 'YYYY-MM-DDTHH:mm:ss';
const defaultComputedCsvValueGetter = () => '';
const getSortDirectionFromOptions = (options) => (options.sortable && options.sortDirection) || ColumnSortDirection.None;
const getSortOrder = (sortDirection, options) => (sortDirection !== ColumnSortDirection.None && options.sortOrder) || -1;
const checkUndefined = (value, defaultValue = true) => (value === undefined ? defaultValue : value);
export const NumericOperators = [
    { value: CompareOperators.None, title: 'None' },
    { value: CompareOperators.Equals, title: 'Equals' },
    { value: CompareOperators.Between, title: 'Between' },
    { value: CompareOperators.Gte, title: '>=' },
    { value: CompareOperators.Gt, title: '>' },
    { value: CompareOperators.Lte, title: '<=' },
    { value: CompareOperators.Lt, title: '<' },
];
export const StringOperators = [
    { value: CompareOperators.None, title: 'None' },
    { value: CompareOperators.Equals, title: 'Equals' },
    { value: CompareOperators.NotEquals, title: 'Not Equals' },
    { value: CompareOperators.Contains, title: 'Contains' },
    { value: CompareOperators.NotContains, title: 'Not Contains' },
    { value: CompareOperators.StartsWith, title: 'Starts With' },
    { value: CompareOperators.NotStartsWith, title: 'Not Starts With' },
    { value: CompareOperators.EndsWith, title: 'Ends With' },
    { value: CompareOperators.NotEndsWith, title: 'Not Ends With' },
];
export const BooleanOperators = [
    { value: CompareOperators.None, title: 'None' },
    { value: CompareOperators.Equals, title: 'Equals' },
    { value: CompareOperators.NotEquals, title: 'Not Equals' },
];
export const getOperators = (column) => {
    switch (column.dataType) {
        case ColumnDataType.String:
            return StringOperators;
        case ColumnDataType.Numeric:
        case ColumnDataType.Date:
        case ColumnDataType.DateTime:
        case ColumnDataType.DateTimeUtc:
            return NumericOperators;
        case ColumnDataType.Boolean:
            return BooleanOperators;
        default:
            return [];
    }
};
const getSortDirection = (sortDirection) => {
    if (sortDirection === ColumnSortDirection.None)
        return ColumnSortDirection.Ascending;
    return sortDirection === ColumnSortDirection.Ascending ? ColumnSortDirection.Descending : ColumnSortDirection.None;
};
export const sortColumnArray = (columnName, columns, multiSort) => {
    const column = columns.find((c) => c.name === columnName);
    if (!column) {
        return undefined;
    }
    column.sortDirection = getSortDirection(column.sortDirection);
    column.sortOrder = column.sortDirection === ColumnSortDirection.None ? -1 : Number.MAX_VALUE;
    if (!multiSort) {
        // biome-ignore lint/complexity/noForEach: <explanation>
        columns
            .filter((col) => col.name !== columnName)
            .forEach((c) => {
            c.sortOrder = -1;
            c.sortDirection = ColumnSortDirection.None;
        });
    }
    columns
        .filter((col) => col.sortOrder > 0)
        .sort((a, b) => {
        if (a.sortOrder === b.sortOrder)
            return 0;
        return a.sortOrder > b.sortOrder ? 1 : -1;
    })
        .forEach((col, i) => {
        col.sortOrder = i + 1;
    });
    return columns;
};
export const columnHasFilter = (column) => (!!column.filterText || !!column.filterArgument) && column.filterOperator !== CompareOperators.None;
export const createColumn = (name, options) => {
    const temp = options || {};
    const sortDirection = getSortDirectionFromOptions(temp);
    return {
        aggregate: temp.aggregate || AggregateFunctions.None,
        dataType: temp.dataType || ColumnDataType.String,
        dateDisplayFormat: temp.dateDisplayFormat || defaultDisplayDateFormat,
        dateOriginFormat: temp.dateOriginFormat || defaultOriginDateFormat,
        dateTimeDisplayFormat: temp.dateTimeDisplayFormat || defaultDisplayDateTimeFormat,
        dateTimeOriginFormat: temp.dateTimeOriginFormat || defaultOriginDateTimeFormat,
        getComputedStringValue: temp.getComputedStringValue || defaultComputedCsvValueGetter,
        isKey: !!temp.isKey,
        isComputed: Boolean(checkUndefined(temp.isComputed, false)),
        label: temp.label || (name || '').replace(normalizaRegex, '$1 $2'),
        name,
        searchable: !!temp.searchable,
        sortDirection,
        sortOrder: getSortOrder(sortDirection, temp),
        sortable: !!temp.sortable,
        visible: Boolean(checkUndefined(temp.visible)),
        filterArgument: temp.filterArgument,
        filterOperator: temp.filterOperator,
        filterText: temp.filterText,
        filterable: Boolean(checkUndefined(temp.filterable, false)),
        exportable: Boolean(checkUndefined(temp.exportable)),
    };
};
export const isDateColum = (column) => column.dataType === ColumnDataType.Date ||
    column.dataType === ColumnDataType.DateTime ||
    column.dataType === ColumnDataType.DateTimeUtc;
export const parseDateColumnValue = (column, value) => {
    if (!isDateColum(column) || !value)
        return '';
    switch (column.dataType) {
        case ColumnDataType.DateTime:
        case ColumnDataType.DateTimeUtc:
            return dayjs(value, column.dateTimeOriginFormat).format(column.dateTimeDisplayFormat);
        default:
            return dayjs(value, column.dateOriginFormat).format(column.dateDisplayFormat);
    }
};
//# sourceMappingURL=columnUtils.js.map