Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

8.5 KB
Raw Blame
import { useMemo, useState, type ReactNode } from 'react';
import {
  createColumnHelper, createPaginatedRowModel, createSortedRowModel, flexRender,
  rowPaginationFeature, rowSelectionFeature, rowSortingFeature, columnVisibilityFeature, tableFeatures, useTable,
  type RowData, type RowSelectionState, type SortingState,
} from '@tanstack/react-table';
import { Button } from '@/components/base/buttons/button';
import { Checkbox } from '@/components/base/checkbox/checkbox';
import { Table, TableBody, TableCell, TableColumn, TableHeader, TableRow } from '@/components/base/table/table';
import { ChevronSortDown } from '@/components/foundations/icons/chevrons';
import { DataTableFrame } from './data-table-frame';
import { DataTableFooter, DataTableSort } from './table-controls';
import { SelectionDock } from './selection-dock';
import { cardClass } from './card';
import { useTableSelection } from './use-table-selection';
import { useTablePreferences } from './table-column-preferences';
import { TableColumnControls, TableColumnResizer } from './table-column-controls';
import { TableSelectionHeader } from './table-selection-header';

const features = tableFeatures({
  rowSortingFeature, rowSelectionFeature, rowPaginationFeature, columnVisibilityFeature,
  sortedRowModel: createSortedRowModel(), paginatedRowModel: createPaginatedRowModel(),
});

export interface DataColumn<T> {
  id: string;
  label: string;
  value?(item: T): string | number;
  render(item: T): ReactNode;
  width?: number;
  min?: number;
  max?: number;
  flex?: boolean;
}

interface DataTableProps<T> {
  label: string;
  items: T[];
  columns: DataColumn<T>[];
  rowId(item: T): string;
  rowLabel(item: T): string;
  selected: string[];
  onSelected(ids: string[]): void;
  actions(items: T[], clear: () => void): ReactNode;
  title?: string;
  titleId?: string;
  description?: ReactNode;
  footerActions?: ReactNode;
  toolbarActions?: ReactNode;
  panel?: boolean;
  unit?: string;
}

/** 数据表共用排序、跨页选择与分页;业务动作只接收仍在清单里的所选行。 */
export function DataTable<T extends RowData>({ label, items, columns, rowId, rowLabel, selected, onSelected, actions,
  title = label, titleId, description, footerActions, toolbarActions, panel = true, unit = '条记录' }: DataTableProps<T>) {
  const [sorting, setSorting] = useState<SortingState>([]);
  const preferenceColumns = useMemo(() => [
    { id: 'select', label: '选择', width: 48, min: 48, max: 48, required: true },
    ...columns.map((column, index) => ({ ...column, width: column.width ?? (index === 0 ? 320 : 160),
      min: column.min ?? (index === 0 ? 320 : 96), flex: column.flex ?? index === 0, required: index === 0 })),
  ], [columns]);
  const preferences = useTablePreferences(`data:${label}`, preferenceColumns);
  const [pagination, setPagination] = useState({ pageIndex: 0, pageSize: 20 });
  const activateSelection = useTableSelection(() => onSelected([]));
  const pages = Math.max(1, Math.ceil(items.length / pagination.pageSize));
  const pageIndex = Math.min(pagination.pageIndex, pages - 1);
  const rowSelection: RowSelectionState = Object.fromEntries(selected.map((id) => [id, true]));
  const definitions = useMemo(() => {
    const helper = createColumnHelper<typeof features, T>();
    return helper.columns([
      helper.display({ id: 'select', header: ({ table }) => (
        <TableSelectionHeader table={table} label={`全选${label}`} />
      ), cell: ({ row }) => (
        <Checkbox slot={null} aria-label={`选择 ${rowLabel(row.original)}`} isSelected={row.getIsSelected()}
          onChange={(on) => row.toggleSelected(on)} />
      ) }),
      ...columns.map((column) => helper.accessor((item: T) => column.value?.(item) ?? '', {
        id: column.id, header: column.label, enableSorting: Boolean(column.value),
        sortFn: (a, b) => {
          const first = column.value!(a.original), second = column.value!(b.original);
          return typeof first === 'number' && typeof second === 'number'
            ? first - second : String(first).localeCompare(String(second), 'zh-CN', { numeric: true });
        },
        cell: ({ row }) => column.render(row.original),
      })),
    ]);
  }, [columns, label, rowLabel]);
  const table = useTable({
    features, data: items, columns: definitions, getRowId: rowId,
    state: { sorting, rowSelection, pagination: { ...pagination, pageIndex }, columnVisibility: preferences.visibility },
    onColumnVisibilityChange: preferences.change,
    onSortingChange: (updater) => { setSorting(updater); setPagination((now) => ({ ...now, pageIndex: 0 })); },
    onPaginationChange: setPagination, enableRowSelection: true,
    onRowSelectionChange: (updater) => {
      const next = typeof updater === 'function' ? updater(rowSelection) : updater;
      if (Object.values(next).some(Boolean)) activateSelection();
      onSelected(items.filter((item) => next[rowId(item)]).map(rowId));
    },
  });
  const chosen = table.getSelectedRowModel().rows.map((row) => row.original);
  return (
    <div data-data-table-panel={panel || undefined} className={panel
      ? cardClass({ padding: 'none', className: 'flex flex-col gap-4 px-6 py-5 max-sm:px-4' })
      : 'flex min-w-0 flex-col gap-4'}>
      <div data-responsive-toolbar="" role="toolbar" aria-label={`${label}工具栏`}>
        <div data-toolbar-heading="">
        <h3 id={titleId} className="text-title-2-medium text-text-primary">{title}</h3>
        <span className="text-body-2-regular tabular-nums text-text-secondary">
          {`${items.length.toLocaleString()} ${unit}`}
        </span>
        </div>
        <div data-toolbar-actions="">
        {toolbarActions}
        <TableColumnControls preferences={preferences} label={label} />
        <DataTableSort label={label} options={columns.filter((column) => column.value).map((column) => ({ id: column.id, label: column.label }))}
          sorting={sorting} onChange={(next) => { setSorting(next); setPagination((now) => ({ ...now, pageIndex: 0 })); }} />
        </div>
      </div>
      {description ? <p className="text-body-2-regular text-text-secondary">{description}</p> : null}
      <SelectionDock label={`${label}批量操作`} visible={chosen.length > 0} count={`已选 ${chosen.length.toLocaleString()} ${unit}`}>
        {actions(chosen, () => onSelected([]))}
        <Button variant="ghost" size="small" onClick={() => onSelected([])}>取消选择</Button>
      </SelectionDock>
      <DataTableFrame follow preferences={preferences} onRowClick={(id) => table.getRow(id)?.toggleSelected()}>
        <Table aria-label={label} size="sm"
          sortDescriptor={sorting[0] ? { column: sorting[0].id, direction: sorting[0].desc ? 'descending' : 'ascending' } : undefined}
          onSortChange={(sort) => table.getColumn(String(sort.column))?.toggleSorting(sort.direction === 'descending')}>
          <TableHeader>
            {table.getHeaderGroups()[0]!.headers.map((header) => (
              <TableColumn key={header.id} id={header.id} isRowHeader={header.id === columns[0]!.id} allowsSorting={header.column.getCanSort()} {...preferences.columnProps(header.id)}>
                {({ sortDirection }) => <><span className="flex items-center gap-0.5">
                  {flexRender(header.column.columnDef.header, header.getContext())}
                  {header.column.getCanSort() ? <span data-sort-indicator data-direction={sortDirection || undefined}><ChevronSortDown /></span> : null}
                </span><TableColumnResizer preferences={preferences} id={header.id} /></>}
              </TableColumn>
            ))}
            <TableColumn id="remaining-space" aria-label="行空白区域" data-table-space="" width={preferences.spaceWidth} minWidth={0} />
          </TableHeader>
          <TableBody renderEmptyState={() => '没有记录'}>
            {table.getRowModel().rows.map((row) => (
              <TableRow key={row.id} id={row.id} data-board-selected={row.getIsSelected() || undefined}>
                {row.getVisibleCells().map((cell) => <TableCell key={cell.id}>{flexRender(cell.column.columnDef.cell, cell.getContext())}</TableCell>)}
                <TableCell data-table-space="" />
              </TableRow>
            ))}
          </TableBody>
        </Table>
      </DataTableFrame>
      <DataTableFooter label={label} total={items.length} pagination={{ ...pagination, pageIndex }} onChange={setPagination} unit={unit} />
      {footerActions ? <div className="flex flex-wrap items-center justify-end gap-2 border-t border-separator-border pt-4">{footerActions}</div> : null}
    </div>
  );
}