Skip to content

Project NOMAD is an offline-first knowledge and education server. Wikipedia, thousands of books, courses, maps, and optional local AI, all running on hardware you own with no internet required.

TypeScript
7.7 KB
Raw Blame
import { capitalizeFirstLetter } from '~/lib/util'
import classNames from '~/lib/classNames'
import LoadingSpinner from '~/components/LoadingSpinner'
import React, { RefObject, useState } from 'react'

export type StyledTableProps<T extends { [key: string]: any }> = {
  loading?: boolean
  tableProps?: React.HTMLAttributes<HTMLTableElement>
  tableRowStyle?: React.CSSProperties
  tableBodyClassName?: string
  tableBodyStyle?: React.CSSProperties
  data?: T[]
  noDataText?: string
  onRowClick?: (record: T) => void
  columns?: {
    accessor: keyof T
    title?: React.ReactNode
    render?: (record: T, index: number) => React.ReactNode
    className?: string
    /** Opt out of the default single-line truncation/`overflow: hidden` on
     * this column's cells. Needed for columns whose render() opens a
     * floating popover (e.g. a combobox) -- otherwise the cell clips the
     * popover to its own row height instead of letting it float. */
    noTruncate?: boolean
  }[]
  className?: string
  rowLines?: boolean
  ref?: RefObject<HTMLDivElement | null>
  containerProps?: React.HTMLAttributes<HTMLDivElement>
  compact?: boolean
  expandable?: {
    expandedRowRender: (record: T, index: number) => React.ReactNode
    defaultExpandedRowKeys?: (string | number)[]
    onExpandedRowsChange?: (expandedKeys: (string | number)[]) => void
    expandIconColumnIndex?: number
  }
}

function StyledTable<T extends { [key: string]: any }>({
  loading = false,
  tableProps = {},
  tableRowStyle = {},
  tableBodyClassName = '',
  tableBodyStyle = {},
  data = [],
  noDataText = 'No records found',
  onRowClick,
  columns = [],
  className = '',
  ref,
  containerProps = {},
  rowLines = true,
  compact = false,
  expandable,
}: StyledTableProps<T>) {
  const { className: tableClassName, ...restTableProps } = tableProps

  const [expandedRowKeys, setExpandedRowKeys] = useState<(string | number)[]>(
    expandable?.defaultExpandedRowKeys || []
  )

  const leftPadding = compact ? 'pl-2' : 'pl-4 sm:pl-6'

  const isRowExpanded = (record: T, index: number) => {
    const key = record.id ?? index
    return expandedRowKeys.includes(key)
  }

  const toggleRowExpansion = (record: T, index: number, event: React.MouseEvent) => {
    event.stopPropagation()
    const key = record.id ?? index
    const newExpandedKeys = expandedRowKeys.includes(key)
      ? expandedRowKeys.filter((k) => k !== key)
      : [...expandedRowKeys, key]
    setExpandedRowKeys(newExpandedKeys)
    expandable?.onExpandedRowsChange?.(newExpandedKeys)
  }

  return (
    <div
      className={classNames(
        'w-full overflow-x-auto bg-surface-primary ring-1 ring-border-default sm:mx-0 sm:rounded-lg p-1 shadow-md',
        className
      )}
      ref={ref}
      {...containerProps}
    >
      <table className="min-w-full overflow-auto" {...restTableProps}>
        <thead className='border-b border-border-subtle '>
          <tr>
            {expandable && (
              <th
                className={classNames(
                  'whitespace-nowrap text-left font-semibold text-text-primary w-12',
                  compact ? `${leftPadding} py-2` : `${leftPadding} py-4  pr-3`
                )}
              />
            )}
            {columns.map((column, index) => (
              <th
                key={index}
                className={classNames(
                  'whitespace-nowrap text-left font-semibold text-text-primary',
                  compact ? `${leftPadding} py-2` : `${leftPadding} py-4  pr-3`
                )}
              >
                {column.title ?? capitalizeFirstLetter(column.accessor.toString())}
              </th>
            ))}
          </tr>
        </thead>
        <tbody className={tableBodyClassName} style={tableBodyStyle}>
          {!loading &&
            data.length !== 0 &&
            data.map((record, recordIdx) => {
              const isExpanded = expandable && isRowExpanded(record, recordIdx)
              return (
                <React.Fragment key={record.id || recordIdx}>
                  <tr
                    data-index={'index' in record ? record.index : recordIdx}
                    onClick={() => onRowClick?.(record)}
                    style={{
                      ...tableRowStyle,
                      height: 'height' in record ? record.height : 'auto',
                      transform:
                        'translateY' in record ? 'translateY(' + record.transformY + 'px)' : undefined,
                    }}
                    className={classNames(
                      rowLines ? 'border-b border-border-subtle' : '',
                      onRowClick ? `cursor-pointer hover:bg-surface-secondary ` : ''
                    )}
                  >
                    {expandable && (
                      <td
                        className={classNames(
                          'text-sm whitespace-nowrap text-left w-12',
                          compact ? `${leftPadding} py-2` : `${leftPadding} py-4 pr-3`
                        )}
                        onClick={(e) => toggleRowExpansion(record, recordIdx, e)}
                      >
                        <button
                          className="text-text-muted hover:text-text-primary focus:outline-none"
                          aria-label={isExpanded ? 'Collapse row' : 'Expand row'}
                        >
                          <svg
                            className={classNames(
                              'w-5 h-5 transition-transform',
                              isExpanded ? 'rotate-90' : ''
                            )}
                            fill="none"
                            stroke="currentColor"
                            viewBox="0 0 24 24"
                          >
                            <path
                              strokeLinecap="round"
                              strokeLinejoin="round"
                              strokeWidth={2}
                              d="M9 5l7 7-7 7"
                            />
                          </svg>
                        </button>
                      </td>
                    )}
                    {columns.map((column, index) => (
                      <td
                        key={index}
                        className={classNames(
                          'relative text-sm max-w-72 break-words text-left',
                          column.noTruncate ? '' : 'whitespace-nowrap truncate',
                          column.className || '',
                          compact ? `${leftPadding} py-2` : `${leftPadding} py-4 pr-3`
                        )}
                      >
                        {column.render
                          ? column.render(record, index)
                          : (record[column.accessor] as React.ReactNode)}
                      </td>
                    ))}
                  </tr>
                  {expandable && isExpanded && (
                    <tr className="bg-surface-secondary">
                      <td colSpan={columns.length + 1}>
                        {expandable.expandedRowRender(record, recordIdx)}
                      </td>
                    </tr>
                  )}
                </React.Fragment>
              )
            })}
          {!loading && data.length === 0 && (
            <tr>
              <td colSpan={columns.length + (expandable ? 1 : 0)} className="!text-center py-8 text-text-muted">
                {noDataText}
              </td>
            </tr>
          )}
          {loading && (
            <tr className="!h-16">
              <td colSpan={columns.length + (expandable ? 1 : 0)} className="!text-center">
                <LoadingSpinner fullscreen={false} />
              </td>
            </tr>
          )}
        </tbody>
      </table>
    </div>
  )
}

export default StyledTable