reactjs - Noe gikk galt med react-tabellen som bruker typescript

Jeg har en TypeScript-feil når jeg bruker react-table med useGlobalFilter. Jeg fulgte bare noen instruksjoner på internett. Her er koden min:

const DataTable : React.FC<IDataTableProps> = ({columns, data}) => {
    const {
        getTableProps,
        getTableBodyProps,
        headerGroups,
        rows,
        prepareRow,
        setGlobalFilter,
        state,
    } = useTable({columns, data}, useGlobalFilter);

    const GlobalFilter = ({ globalFilter , setGlobalFilter} : {globalFilter: any, setGlobalFilter: any})  => {
        return (
            <input
                value={globalFilter || ""}
                onChange={e => {
                setGlobalFilter(e.target.value || undefined); // Set undefined to remove the filter entirely
                }}
                placeholder={`Search All ...`}
            />
            );
        };

    return <Container>
        <GlobalFilter globalFilter={state.globalFilter} setGlobalFilter={setGlobalFilter} />
        <Table {...getTableProps()}>
            <THead>
                {headerGroups.map(headerGroup => (
                    <TR {...headerGroup.getHeaderGroupProps()}>
                        {headerGroup.headers.map(column => {
                            return (
                                <TH {...column.getHeaderProps()}>{column.render("Header")}</TH>
                            )}
                        )}
                    </TR>
                ))}
            </THead>
            <TBody {...getTableBodyProps()} >
                {rows.map((row, i) => {
                    prepareRow(row);
                    return (
                        <TR {...row.getRowProps()}>
                            {row.cells.map(cell => {
                                return <TD {...cell.getCellProps()} >
                                    {cell.render("Cell")}
                                </TD>
                            })}
                        </TR>
                    )
                })}
            </TBody>
        </Table>
    </Container>
}

Typescript-feil jeg får: Property 'setGlobalFilter' eksisterer ikke på typen 'TableInstance'. TS2339

Kan noen hjelpe meg? Tusen takk!

Svar #1

Det er mulig at du mangler @types/react-table-pakken.

Hvis pakken allerede er installert, er det et annet trinn å følge for å få dette til å kjøre. Du må opprette en react-table-config.d.ts-fil i @types-mappen.

Vennligst fyll det med følgende konfigurasjon og ta ut delene som ikke trengs

import {
  UseColumnOrderInstanceProps,
  UseColumnOrderState,
  UseExpandedHooks,
  UseExpandedInstanceProps,
  UseExpandedOptions,
  UseExpandedRowProps,
  UseExpandedState,
  UseFiltersColumnOptions,
  UseFiltersColumnProps,
  UseFiltersInstanceProps,
  UseFiltersOptions,
  UseFiltersState,
  UseGlobalFiltersColumnOptions,
  UseGlobalFiltersInstanceProps,
  UseGlobalFiltersOptions,
  UseGlobalFiltersState,
  UseGroupByCellProps,
  UseGroupByColumnOptions,
  UseGroupByColumnProps,
  UseGroupByHooks,
  UseGroupByInstanceProps,
  UseGroupByOptions,
  UseGroupByRowProps,
  UseGroupByState,
  UsePaginationInstanceProps,
  UsePaginationOptions,
  UsePaginationState,
  UseResizeColumnsColumnOptions,
  UseResizeColumnsColumnProps,
  UseResizeColumnsOptions,
  UseResizeColumnsState,
  UseRowSelectHooks,
  UseRowSelectInstanceProps,
  UseRowSelectOptions,
  UseRowSelectRowProps,
  UseRowSelectState,
  UseRowStateCellProps,
  UseRowStateInstanceProps,
  UseRowStateOptions,
  UseRowStateRowProps,
  UseRowStateState,
  UseSortByColumnOptions,
  UseSortByColumnProps,
  UseSortByHooks,
  UseSortByInstanceProps,
  UseSortByOptions,
  UseSortByState
} from 'react-table'

declare module 'react-table' {
  // take this file as-is, or comment out the sections that don't apply to your plugin configuration

  export interface TableOptions<D extends Record<string, unknown>>
    extends UseExpandedOptions<D>,
      UseFiltersOptions<D>,
      UseGlobalFiltersOptions<D>,
      UseGroupByOptions<D>,
      UsePaginationOptions<D>,
      UseResizeColumnsOptions<D>,
      UseRowSelectOptions<D>,
      UseRowStateOptions<D>,
      UseSortByOptions<D>,
      // note that having Record here allows you to add anything to the options, this matches the spirit of the
      // underlying js library, but might be cleaner if it's replaced by a more specific type that matches your
      // feature set, this is a safe default.
      Record<string, any> {}

  export interface Hooks<D extends Record<string, unknown> = Record<string, unknown>>
    extends UseExpandedHooks<D>,
      UseGroupByHooks<D>,
      UseRowSelectHooks<D>,
      UseSortByHooks<D> {}

  export interface TableInstance<D extends Record<string, unknown> = Record<string, unknown>>
    extends UseColumnOrderInstanceProps<D>,
      UseExpandedInstanceProps<D>,
      UseFiltersInstanceProps<D>,
      UseGlobalFiltersInstanceProps<D>,
      UseGroupByInstanceProps<D>,
      UsePaginationInstanceProps<D>,
      UseRowSelectInstanceProps<D>,
      UseRowStateInstanceProps<D>,
      UseSortByInstanceProps<D> {}

  export interface TableState<D extends Record<string, unknown> = Record<string, unknown>>
    extends UseColumnOrderState<D>,
      UseExpandedState<D>,
      UseFiltersState<D>,
      UseGlobalFiltersState<D>,
      UseGroupByState<D>,
      UsePaginationState<D>,
      UseResizeColumnsState<D>,
      UseRowSelectState<D>,
      UseRowStateState<D>,
      UseSortByState<D> {}

  export interface ColumnInterface<D extends Record<string, unknown> = Record<string, unknown>>
    extends UseFiltersColumnOptions<D>,
      UseGlobalFiltersColumnOptions<D>,
      UseGroupByColumnOptions<D>,
      UseResizeColumnsColumnOptions<D>,
      UseSortByColumnOptions<D> {}

  export interface ColumnInstance<D extends Record<string, unknown> = Record<string, unknown>>
    extends UseFiltersColumnProps<D>,
      UseGroupByColumnProps<D>,
      UseResizeColumnsColumnProps<D>,
      UseSortByColumnProps<D> {}

  export interface Cell<D extends Record<string, unknown> = Record<string, unknown>, V = any>
    extends UseGroupByCellProps<D>,
      UseRowStateCellProps<D> {}

  export interface Row<D extends Record<string, unknown> = Record<string, unknown>>
    extends UseExpandedRowProps<D>,
      UseGroupByRowProps<D>,
      UseRowSelectRowProps<D>,
      UseRowStateRowProps<D> {}
}

Løsningen kommer fra DefinitelyTyped for react-table

Svar #2

Hvis du fikk feilen All declarations of 'TableInstance' must have identical type parameters.ts(2428) når du gjør migrasjonsguiden fra DefinitelyTyped, kan du manuelt justere den medfølgende react-table-config.d.ts-filen for å samsvare med typeparameteren fra ditt @types/react-table-pakke.

Gå til type-definisjonspakken (node_modules/@types/react-table), se i index.d.ts-filen, du vil se mange generiske grensesnitt, disse grensesnittene har forskjellige parametere enn grensesnittet du har i react-table-config.d.ts-filen din, og det er derfor det klager når du prøver å slå sammen disse deklarasjonene.

For eksempel, dette er grensesnittet fra type-definisjonspakken

export interface TableInstance<D extends object = {}>

Og dette er den tilsvarende grensesnittet i din react-table-config.d.ts

export interface TableInstance<D extends Record<string, unknown> = Record<string, unknown>>

Derfra bør fiksen være enkel, bare endre parameterdelen i din react-table-config.d.ts-fil for å samsvare med typedefinisjonspakken din.

Å endre react-table-config.d.ts er egentlig ikke ønskelig (spesielt med kommentaren «ta denne filen som den er»), men dette er hva som fungerer best for meg uten noen klager og uten nedgradering (jeg bruker react-table 7.7.0 og @types/react-table 7.7.2). Jeg håper på react-table v8 som vil ha sin innebygde typedefinisjon for å unngå denne hodepinen.

Relaterte artikler