@adaptabletools/adaptable/src/View/Layout/Wizard/sections/columnLayoutHelpers.js

Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements

export const COLUMN_PINNING_OPTIONS = [
    { value: 'left', label: 'Left' },
    { value: 'None', label: 'None' },
    { value: 'right', label: 'Right' },
];
export const COLUMN_SORT_OPTIONS = [
    { value: 'Asc', label: 'Asc' },
    { value: 'Desc', label: 'Desc' },
    { value: 'None', label: 'None' },
];
export function getLayoutPinnedColumnIds(layout, side) {
    const pinning = layout.ColumnPinning ?? {};
    return Object.entries(pinning)
        .filter(([, pin]) => pin === side)
        .map(([columnId]) => columnId);
}
export function hasExplicitLayoutSizing(columnId, sizing, resolveDefaultWidth) {
    if (!sizing) {
        return false;
    }
    if (sizing.Flex != null) {
        return true;
    }
    if (sizing.MinWidth != null || sizing.MaxWidth != null) {
        return true;
    }
    if (sizing.Width != null) {
        if (resolveDefaultWidth) {
            return sizing.Width !== resolveDefaultWidth(columnId);
        }
        return true;
    }
    return false;
}
export function getLayoutExplicitSizedColumnIds(layout, resolveDefaultWidth) {
    const sizing = layout.ColumnSizing ?? {};
    return Object.keys(sizing).filter((columnId) => hasExplicitLayoutSizing(columnId, sizing[columnId], resolveDefaultWidth));
}
export function formatColumnSizingBrief(columnId, sizing, resolveDefaultWidth) {
    if (!hasExplicitLayoutSizing(columnId, sizing, resolveDefaultWidth)) {
        return '';
    }
    const display = getExplicitSizingDisplayValues(columnId, sizing, resolveDefaultWidth);
    const parts = [];
    if (display.flex != null) {
        parts.push(`flex ${display.flex}`);
    }
    else if (display.width != null) {
        parts.push(String(display.width));
    }
    if (display.minWidth != null) {
        parts.push(`min ${display.minWidth}`);
    }
    if (display.maxWidth != null) {
        parts.push(`max ${display.maxWidth}`);
    }
    return parts.join(', ');
}
export function getExplicitSizingDisplayValues(columnId, sizing, resolveDefaultWidth) {
    if (!sizing) {
        return {
            width: undefined,
            flex: undefined,
            minWidth: undefined,
            maxWidth: undefined,
        };
    }
    const width = sizing.Width != null &&
        (!resolveDefaultWidth || sizing.Width !== resolveDefaultWidth(columnId))
        ? sizing.Width
        : undefined;
    return {
        width,
        flex: sizing.Flex ?? undefined,
        minWidth: sizing.MinWidth ?? undefined,
        maxWidth: sizing.MaxWidth ?? undefined,
    };
}
export function formatColumnInspectorPinning(layout, columnId) {
    const pin = layout.ColumnPinning?.[columnId];
    if (pin === 'left') {
        return 'Left';
    }
    if (pin === 'right') {
        return 'Right';
    }
    return 'None';
}
export function formatColumnInspectorSizing(columnId, sizing, resolveDefaultWidth) {
    if (!hasExplicitLayoutSizing(columnId, sizing, resolveDefaultWidth)) {
        return 'Default';
    }
    const display = getExplicitSizingDisplayValues(columnId, sizing, resolveDefaultWidth);
    const parts = [];
    if (display.width != null) {
        parts.push(String(display.width));
    }
    if (display.flex != null) {
        parts.push(`flex ${display.flex}`);
    }
    if (display.minWidth != null) {
        parts.push(`min ${display.minWidth}`);
    }
    if (display.maxWidth != null) {
        parts.push(`max ${display.maxWidth}`);
    }
    return parts.length ? parts.join(', ') : 'Default';
}
export function formatColumnInspectorSorting(layout, columnId) {
    return getColumnSortSelection(layout, columnId);
}
export function getColumnSortSelection(layout, columnId) {
    const sort = (layout.ColumnSorts ?? []).find((entry) => entry.ColumnId === columnId);
    return sort?.SortOrder ?? 'None';
}
export function applyColumnPinChange(layout, columnId, pinning) {
    const ColumnPinning = { ...layout.ColumnPinning };
    if (pinning) {
        ColumnPinning[columnId] = pinning;
    }
    else {
        delete ColumnPinning[columnId];
    }
    return {
        ...layout,
        ColumnPinning,
    };
}
export function applyColumnSortChange(layout, columnId, sortOrder) {
    const existing = layout.ColumnSorts ?? [];
    if (sortOrder === 'None') {
        return {
            ...layout,
            ColumnSorts: existing.filter((entry) => entry.ColumnId !== columnId),
        };
    }
    const current = existing.find((entry) => entry.ColumnId === columnId);
    if (current) {
        return {
            ...layout,
            ColumnSorts: existing.map((entry) => entry.ColumnId === columnId ? { ...entry, SortOrder: sortOrder } : entry),
        };
    }
    return {
        ...layout,
        ColumnSorts: [...existing, { ColumnId: columnId, SortOrder: sortOrder }],
    };
}
export function applyColumnSizingFieldChange(layout, columnId, field, value, resolveDefaultWidth) {
    const ColumnSizing = { ...layout.ColumnSizing };
    const colSizingForCol = { ...(ColumnSizing[columnId] ?? {}) };
    const next = { ...colSizingForCol };
    switch (field) {
        case 'width':
            if (value == null || value === resolveDefaultWidth(columnId)) {
                delete next.Width;
            }
            else {
                delete next.Flex;
                next.Width = value;
            }
            break;
        case 'flex':
            if (value == null) {
                delete next.Flex;
            }
            else {
                delete next.Width;
                next.Flex = value;
            }
            break;
        case 'minWidth':
            if (value == null) {
                delete next.MinWidth;
            }
            else {
                next.MinWidth = value;
            }
            break;
        case 'maxWidth':
            if (value == null) {
                delete next.MaxWidth;
            }
            else {
                next.MaxWidth = value;
            }
            break;
    }
    if (hasExplicitLayoutSizing(columnId, next, resolveDefaultWidth)) {
        ColumnSizing[columnId] = next;
    }
    else {
        delete ColumnSizing[columnId];
    }
    return {
        ...layout,
        ColumnSizing,
    };
}