dees-catalog/ts_web/elements/00group-dataview/dees-table/data.ts

import type { Column, ISortDescriptor, TDisplayFunction } from './types.js';

export function computeColumnsFromDisplayFunction<T>(
  displayFunction: TDisplayFunction<T>,
  data: T[]
): Column<T>[] {
  if (!data || data.length === 0) return [];
  const firstTransformedItem = displayFunction(data[0]);
  const keys: string[] = Object.keys(firstTransformedItem);
  return keys.map((key) => ({
    key,
    header: key,
    value: (row: T) => displayFunction(row)[key],
  }));
}

export function computeEffectiveColumns<T>(
  columns: Column<T>[] | undefined,
  augmentFromDisplayFunction: boolean,
  displayFunction: TDisplayFunction<T>,
  data: T[]
): Column<T>[] {
  const base = (columns || []).slice();
  if (!augmentFromDisplayFunction) return base;
  const fromDisplay = computeColumnsFromDisplayFunction(displayFunction, data);
  const existingKeys = new Set(base.map((c) => String(c.key)));
  for (const col of fromDisplay) {
    if (!existingKeys.has(String(col.key))) {
      base.push(col);
    }
  }
  return base;
}

export function getCellValue<T>(row: T, col: Column<T>, displayFunction?: TDisplayFunction<T>): any {
  return col.value ? col.value(row) : (row as any)[col.key as any];
}

/**
 * Compares two cell values in ascending order. Returns -1, 0, or 1.
 * Null/undefined values sort before defined values. Numbers compare numerically;
 * everything else compares as case-insensitive strings.
 */
export function compareCellValues(va: any, vb: any): number {
  if (va == null && vb == null) return 0;
  if (va == null) return -1;
  if (vb == null) return 1;
  if (typeof va === 'number' && typeof vb === 'number') {
    if (va < vb) return -1;
    if (va > vb) return 1;
    return 0;
  }
  const sa = String(va).toLowerCase();
  const sb = String(vb).toLowerCase();
  if (sa < sb) return -1;
  if (sa > sb) return 1;
  return 0;
}

export function getViewData<T>(
  data: T[],
  effectiveColumns: Column<T>[],
  sortBy: ISortDescriptor[],
  filterText?: string,
  columnFilters?: Record<string, string>,
  filterMode: 'table' | 'data' = 'table',
  lucenePredicate?: (row: T) => boolean
): T[] {
  let arr = data.slice();
  const ft = (filterText || '').trim().toLowerCase();
  const cf = columnFilters || {};
  const cfKeys = Object.keys(cf).filter((k) => (cf[k] ?? '').trim().length > 0);
  if (ft || cfKeys.length > 0) {
    arr = arr.filter((row) => {
      // column filters (AND across columns)
      for (const k of cfKeys) {
        if (filterMode === 'data') {
          // raw object check for that key
          const val = (row as any)[k];
          const s = String(val ?? '').toLowerCase();
          const needle = String(cf[k]).toLowerCase();
          if (!s.includes(needle)) return false;
        } else {
          const col = effectiveColumns.find((c) => String(c.key) === k);
          if (!col || col.hidden || col.filterable === false) continue;
          const val = getCellValue(row, col);
          const s = String(val ?? '').toLowerCase();
          const needle = String(cf[k]).toLowerCase();
          if (!s.includes(needle)) return false;
        }
      }
      // global filter (OR across visible columns) or lucene predicate
      if (ft) {
        if (lucenePredicate) {
          if (!lucenePredicate(row)) return false;
          return true;
        }
        let any = false;
        if (filterMode === 'data') {
          for (const val of Object.values(row as any)) {
            const s = String(val ?? '').toLowerCase();
            if (s.includes(ft)) { any = true; break; }
          }
        } else {
          for (const col of effectiveColumns) {
            if (col.hidden) continue;
            const val = getCellValue(row, col);
            const s = String(val ?? '').toLowerCase();
            if (s.includes(ft)) { any = true; break; }
          }
        }
        if (!any) return false;
      }
      return true;
    });
  }
  if (!sortBy || sortBy.length === 0) return arr;
  // Pre-resolve descriptors -> columns once for performance.
  const resolved = sortBy
    .map((desc) => ({ desc, col: effectiveColumns.find((c) => String(c.key) === desc.key) }))
    .filter((entry): entry is { desc: ISortDescriptor; col: Column<T> } => !!entry.col);
  if (resolved.length === 0) return arr;
  arr.sort((a, b) => {
    for (const { desc, col } of resolved) {
      const cmp = compareCellValues(getCellValue(a, col), getCellValue(b, col));
      if (cmp !== 0) return desc.dir === 'asc' ? cmp : -cmp;
    }
    return 0;
  });
  return arr;
}