How to use the dash-table/components/Table/props.TableAction.Native function in dash-table

}

    const getNullyCases = (
        columnId: ColumnId
    ): SortAsNull => {
        const column = R.find(c => c.id === columnId, columns);

        return (column && column.sort_as_null) || [];
    };

    const isNully = (
        value: any,
        columnId: ColumnId
    ) => R.isNil(value) || R.includes(value, getNullyCases(columnId));

    if (sort_action === TableAction.Native) {
        data = sort(data, sort_by, isNully);
    }

    // virtual_indices
    const indices = R.map(datum => map.get(datum) as number, data);

    return { data, indices };
};

.add('"a" ascending -- empty string override', () => ())
    .add('"a" descending -- empty string override', () => (

const getter = (
    page_action: TableAction,
    page_current: number,
    page_size: number,
    setProps: SetProps,
    data: Data
): IPaginator => {
    switch (page_action) {
        case TableAction.None:
            return getNoPagination();
        case TableAction.Native:
            return getFrontEndPagination(page_current, page_size, setProps, data);
        case TableAction.Custom:
            return getBackEndPagination(page_current, setProps);
        default:
            throw new Error(`Unknown pagination mode: '${page_action}'`);
    }
};

function getActionableState() {
    const state = getDefaultState();
    state.tableProps.filter_action = TableAction.Native;

    R.forEach(c => {
        c.clearable = true;
        c.hideable = 'last';
        c.selectable = true;
    }, state.tableProps.columns || []);

    return state;
}

function isBackEnd(value: TableAction) {
    return value !== TableAction.Native;
}

const getter = (
    columns: Columns,
    data: Data,
    filter_action: TableAction,
    filter_query: string,
    sort_action: TableAction,
    sort_by: SortBy = []
): IDerivedData => {
    const map = new Map();
    R.addIndex(R.forEach)((datum, index) => {
        map.set(datum, index);
    }, data);

    if (filter_action === TableAction.Native) {
        const tree = new QuerySyntaxTree(filter_query);

        data = tree.isValid ?
            tree.filter(data) :
            data;
    }

    const getNullyCases = (
        columnId: ColumnId
    ): SortAsNull => {
        const column = R.find(c => c.id === columnId, columns);

        return (column && column.sort_as_null) || [];
    };

    const isNully = (

get displayPagination() {
        const {
            data,
            page_action,
            page_size
        } = this.props;

        return (
            page_action === TableAction.Native &&
            page_size < data.length
        ) || page_action === TableAction.Custom;
    }

function getDefaultState(
    generateData: Function = generateMockData
): {
    filter_query: string,
    tableProps: Partial
} {
    const mock = generateData(5000);

    return {
        filter_query: '',
        tableProps: R.merge(getBaseTableProps(mock), {
            data: mock.data,
            editable: true,
            sort_action: TableAction.Native,
            fill_width: false,
            fixed_rows: { headers: true },
            fixed_columns: { headers: true },
            merge_duplicate_headers: false,
            row_deletable: true,
            row_selectable: 'single',
            page_action: TableAction.Native
        }) as Partial
    };
}