bface/src/ui/components/grid/utils.js

export function normalizeColumnDefinitionsInput(input = {}) {
  if (Array.isArray(input)) {
    return Object.fromEntries(
      input
        .map((column) => {
          const field = column?.field || column?.id;
          if (!field) {
            return null;
          }

          return [
            field,
            {
              ...column,
              field,
              id: field,
              renderer: column.renderer || column.render || null
            }
          ];
        })
        .filter(Boolean)
    );
  }

  if (input && typeof input === 'object') {
    return Object.fromEntries(
      Object.entries(input).map(([field, column]) => [
        field,
        {
          ...(column || {}),
          field: column?.field || column?.id || field,
          id: column?.id || column?.field || field,
          renderer: column?.renderer || column?.render || null
        }
      ])
    );
  }

  return {};
}

export function normalizeColumnsArray(input = []) {
  if (Array.isArray(input)) {
    return input
      .map((column) => {
        const id = column?.id || column?.field;
        if (!id) {
          return null;
        }

        return {
          ...column,
          id,
          field: column.field || id,
          render: column.render || column.renderer || null
        };
      })
      .filter(Boolean);
  }

  if (input && typeof input === 'object') {
    return Object.entries(input).map(([field, column]) => ({
      ...(column || {}),
      id: column?.id || column?.field || field,
      field: column?.field || column?.id || field,
      render: column?.render || column?.renderer || null
    }));
  }

  return [];
}

export function resolveCellValue(row, column) {
  return row?.[column.field];
}

export function resolveCellAlignment(column) {
  return column.align || 'left';
}

export function resolveVisibleColumns(columns = [], viewportWidth = 0) {
  if (!columns.length) {
    return [];
  }

  let hiddenPriorities = new Set();
  if (viewportWidth > 0 && viewportWidth < 760) {
    hiddenPriorities = new Set(['wide', 'mid']);
  } else if (viewportWidth > 0 && viewportWidth < 980) {
    hiddenPriorities = new Set(['wide']);
  }

  const filtered = columns.filter((column) => {
    if (column.alwaysVisible || !column.priority) {
      return true;
    }
    return !hiddenPriorities.has(column.priority);
  });

  return filtered.length ? filtered : columns.slice(0, 1);
}

export function areSortEntriesEqual(left = [], right = []) {
  if (left.length !== right.length) {
    return false;
  }

  return left.every(
    (entry, index) =>
      entry.field === right[index]?.field && entry.direction === right[index]?.direction
  );
}

export function getColumnJustify(align = 'left') {
  if (align === 'right') {
    return 'flex-end';
  }
  if (align === 'center') {
    return 'center';
  }
  return 'flex-start';
}

export function getColumnLayoutStyle(column = {}) {
  const width = column.width;

  if (typeof width === 'number') {
    if (width > 0 && width <= 1) {
      return {
        flex: width,
        flexBasis: 0,
        minWidth: column.minWidth || 120
      };
    }
    if (width > 1) {
      return {
        flexShrink: 0,
        flexGrow: 0,
        width: `${width}em`,
        minWidth: `${width}em`
      };
    }
  }

  if (typeof width === 'string') {
    return {
      flexShrink: 0,
      flexGrow: 0,
      width,
      minWidth: width
    };
  }

  return {
    flex: column.flex || 1,
    flexBasis: 0,
    minWidth: column.minWidth || 120
  };
}

export function formatValueByColumn(value, column = {}) {
  if (value == null || value === '') {
    return '-';
  }

  if (typeof column.format === 'function') {
    return column.format(value, column);
  }

  if (column.type === 'currency') {
    const numeric = Number(value);
    if (!Number.isFinite(numeric)) {
      return '-';
    }
    return new Intl.NumberFormat('en-US', {
      style: 'currency',
      currency: column.currency || 'USD'
    }).format(numeric);
  }

  if (column.type === 'boolean') {
    return value ? 'Yes' : 'No';
  }

  return String(value);
}