@economic/taco 2.40.0 → 2.40.2

package/dist/components/Table/types.d.ts

@@ -0,0 +1,284 @@
+import React from 'react';
+import { Cell, ColumnInstance, IdType, Row as BaseRow, TableInstance, UseExpandedRowProps, UseRowSelectRowProps, UseRowStateRowProps, UseSortByColumnProps } from 'react-table';
+import { IconName } from '../Icon/components';
+export declare type SortDirection = 'asc' | 'desc';
+export declare type SortTypes = 'datetime' | 'string' | 'number' | 'boolean' | 'auto';
+export declare type RowIndexPath = string | undefined;
+export declare type Row<TRow extends {}> = TRow & {
+    subRows?: Row<TRow>[];
+};
+export declare type LegacyTableRow<TRow extends {}> = {
+    /**
+     * Index of the row.
+     * Note: This index is relative to the root or parent row if it is a sub row
+     * If you need full path of the row from the root, use indexPath
+     */
+    index: number;
+    /**
+     * Index path (dot notated) of the row.
+     * Note: This path is a dot notation of indexes to the root
+     */
+    indexPath: string;
+    depth?: number;
+    /**
+     * Define whether the row is expanded.
+     * If expended, `rowExpansionRenderer` render function will be called.
+     * It can be used to render a specific icon in your cell based on the state of the row.
+     */
+    isExpanded?: boolean;
+    /**
+     * Toggles the row expansion.
+     * It can be used as a handler for the click event on your cell.
+     */
+    toggleRowExpanded?: () => void;
+    /** Represents the values rendered in each cell */
+    values: Row<TRow>;
+    isEditing?: boolean;
+    toggleRowEditing?: () => void;
+};
+export declare type LegacyTableCell<TRow extends {}> = {
+    accessor: string;
+    /** Represents the row which renders the specific cell, exposing its properties */
+    row: LegacyTableRow<TRow>;
+    /** Access the rendered value in the cell */
+    value: any;
+};
+export declare type LegacyTableColumnProps<TRow extends {}> = {
+    /**
+     * This string is used to build the data model for your column.
+     * It should match one of the properties defined in your `data` object on `Table`,
+     * since this will map the value from the provided data.
+     * If the accessor doesn't match a property from table's `data`,
+     * you should render something using the `cellRenderer` prop.
+     */
+    accessor: string;
+    /**
+     * Align column's content.
+     * Not specifying this will default to a `centered` column
+     */
+    align?: 'left' | 'center' | 'right';
+    /** Add a classname to the column */
+    className?: string;
+    /**
+     * Define the content of the cell.
+     * It needs to be a render function that can return a transformed version of the existing value,
+     * or any valid react node, for e.g. a `div`
+     */
+    cellRenderer?: (cellProps: LegacyTableCell<TRow>) => React.ReactNode;
+    /** Disable sorting on column */
+    disableSorting?: boolean;
+    editRenderer?: (cellProps: LegacyTableCell<TRow>) => React.ReactNode;
+    /**
+     * Specify the width and growth characteristics of a column.
+     * This follows the standard flex-box `flex` css property
+     */
+    flex?: string | ((row: TRow) => string);
+    /** Text displayed in the column header */
+    headRenderer?: React.ReactNode;
+    /** Hides the column */
+    hidden?: boolean;
+    /** Hides the column on all sub rows */
+    hiddenOnSubRows?: boolean;
+    /**
+     * Specify the sort rule on a column.
+     * Specifying no value defaults to no sorting rule
+     */
+    sort?: SortDirection;
+    /**
+     * Sort type on a column is used to compare 2 rows of data and order them correctly based on the specified type.
+     * Default value is `auto`, which will apply sort type based on the type of your column's value.
+     * `auto` will use type checking for booleans or numbers before falling back to string
+     */
+    sortType?: SortTypes;
+    /**
+     * Use inline style for your column.
+     * *Note* that `flex` should be set using `flex` prop, otherwise it will be overriden here by `undefined`
+     */
+    style?: object;
+};
+export declare type LegacyTableGroupProps<TRow extends {}> = {
+    /** Content of a group should be another `Table.Group` or a `Table.Column` */
+    children: React.ReactElement<LegacyTableColumnProps<TRow>> | React.ReactElement<LegacyTableColumnProps<TRow>>[];
+    /** Hide the entire group (and columns defined within group) */
+    hidden?: boolean;
+    /** Text displayed in the group's header */
+    title: string;
+};
+export declare type RowClickHandler<TRow extends {}> = (row: LegacyTableRow<TRow>, event: React.MouseEvent) => void;
+export declare type RowDragHandler<TRow extends {}> = (rows: Array<LegacyTableRow<TRow>>, showPlaceholder: (placeholder: string) => void, event: React.DragEvent) => void;
+export declare type SortRule<T> = {
+    /** Name of the accessor you want to sort */
+    accessor: IdType<T>;
+    /** Set whether it is a descending sort direction */
+    desc?: boolean;
+};
+export declare type SelectedRowsState = Record<number, boolean>;
+export declare type SelectedRowsHandler = React.Dispatch<React.SetStateAction<SelectedRowsState>>;
+export declare type SortHandler<T> = (sortRules: SortRule<T>[] | undefined, sortedData?: T[]) => void;
+export declare type PaginationHandler = (pageNumber: number, pageSize: number) => void;
+export declare type RowCreateHandler<TRow extends {}> = (parentRow: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowEditHandler<TRow extends {}> = (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowCopyHandler<TRow extends {}> = (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowDeleteHandler<TRow extends {}> = (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowActiveHandler<TRow extends {}> = (row: LegacyTableRow<TRow>) => void;
+export declare type RowAction<TRow extends {}> = {
+    disabled?: ((row: LegacyTableRow<TRow>) => boolean) | boolean;
+    icon: ((row: LegacyTableRow<TRow>) => IconName) | IconName;
+    onClick: (row: LegacyTableRow<TRow>, event: React.MouseEvent<HTMLElement>) => void;
+    text: ((row: LegacyTableRow<TRow>) => React.ReactNode) | React.ReactNode;
+    tooltip?: ((row: LegacyTableRow<TRow>) => string) | string;
+    showOnRow?: boolean;
+    visible?: ((row: LegacyTableRow<TRow>) => boolean) | boolean;
+};
+export declare type RowActionHandler<TRow extends {}> = RowAction<TRow> | undefined | null | boolean;
+export declare type LegacyTableProps<TRow extends {}> = React.HTMLAttributes<HTMLDivElement> & {
+    /** Autofocus the table when loaded */
+    autoFocus?: boolean;
+    /**
+     * Children should be one of the Table's components.
+     * Read about `ForwardedGenericTableWithStatics` for more details.
+     * *Note* that there can also be children that are rendered conditionally
+     */
+    children: LegacyTableChildren<TRow>;
+    /** Provide data to be displayed in your table */
+    data: Row<TRow>[];
+    /**
+     * This will attach the `keyDown` handler for Table to the window,
+     * so that user can directly navigate through table using keyboard, even if the table is not focused.
+     * *Note* that the `keydown` handler will be executed only if focus is on body or the table itself
+     */
+    dangerouslyHijackGlobalKeyboardNavigation?: boolean;
+    /**
+     * Provide an empty state to the table if there is no data or it is loading asynchronously
+     */
+    emptyStateRenderer?: () => React.ReactNode;
+    /** Handler called when a row is clicked */
+    onRowClick?: RowClickHandler<TRow>;
+    /** Handler called when a row is dragged */
+    onRowDrag?: RowDragHandler<TRow>;
+    /**
+     * Handler used toghether with `selectedRows`.
+     * *Note* that row selection should be used within a state since it is controlled.
+     * To enable row selection, you have to use both `selectedRows` and `onSelectedRows` - you can use standard `useState` for this
+     */
+    onSelectedRows?: SelectedRowsHandler;
+    /**
+     * Provide a className for rows.
+     * It can be a `string` or a render function that is given the properties of the row and returns a `string`
+     */
+    rowClassName?: string | ((row: LegacyTableRow<TRow>) => string | undefined);
+    /** Show extra content below each row */
+    rowExpansionRenderer?: (row: LegacyTableRow<TRow>) => React.ReactNode;
+    /** Give the row a specific height */
+    rowHeight?: number;
+    /**
+     * Used toghether with `onSelectedRows`.
+     * *Note* that row selection should be used within a state since it is controlled.
+     * To enable row selection, you have to use both `selectedRows` and `onSelectedRows` - you can use standard `useState` for this
+     */
+    selectedRows?: SelectedRowsState;
+    activeIndex?: number;
+    defaultActiveIndex?: number;
+    onChangeActiveIndex?: (activeIndex: number) => void;
+    /** Disable sorting on the entire table */
+    disableSorting?: boolean;
+    /**
+     * Handler which passes back the current sorting state and sorted data.
+     * You can use this if you need to handle in some way the current sort values,
+     * for e.g. to save them in localstorage and pass them back as `sortRules`
+     */
+    onSort?: SortHandler<TRow>;
+    /** Enable manual (external) sorting */
+    manualSorting?: boolean;
+    /**
+     * Provide the initial sorting rules on your table.
+     * *Note* that these values will override any default sorting specified on columns
+     */
+    sortRules?: SortRule<TRow>[];
+    disablePagination?: boolean;
+    length?: number;
+    /** Handler called when navigating through pages */
+    onPaginate?: PaginationHandler;
+    /** Current page index (zero based) */
+    pageIndex?: number;
+    /** Number of items displayed on a page */
+    pageSize?: number;
+    /** Handler called as user scrolls a virtualised window */
+    loadMore?: (startIndex: number, endIndex: number) => void;
+    /** Enable inline editing mode by providing the property name of a unique id in your data */
+    inlineEditingUniqueId?: keyof TRow;
+    /** Handler called when a new row is added - without this property defined the 'add new row' button will not be visible */
+    onRowCreate?: RowCreateHandler<TRow>;
+    /** Collection of items/links to show in the actions menu - without this property defined the actions men button will not be visible */
+    actions?: RowActionHandler<TRow>[];
+    /** Handler called when a row is edited - without this property defined the 'edit row' button will not be visible - unless inline editing mode is set */
+    onRowEdit?: RowEditHandler<TRow>;
+    /** Handler called when a row is copied - without this property defined the 'copy row' button will not be visible */
+    onRowCopy?: RowCopyHandler<TRow>;
+    /** Handler called when a row is deleted - without this property defined the 'delete row' button will not be visible */
+    onRowDelete?: RowDeleteHandler<TRow>;
+    /** Handler called when a row is made active */
+    onRowActive?: RowActiveHandler<TRow>;
+};
+export declare type LegacyTableRef = HTMLDivElement & {
+    instance: {
+        toggleAllRowsExpanded: any;
+        toggleHideAllColumns: any;
+        toggleHideColumn: any;
+        toggleEditing: any;
+        toggleRowEditing: any;
+        resetRowEditing: any;
+        toggleRowExpanded: any;
+        toggleSortBy: any;
+    };
+};
+export declare type ForwardedGenericTableWithStatics = React.ForwardRefExoticComponent<LegacyTableProps<any> & React.RefAttributes<HTMLDivElement>> & {
+    /** Represents a column in your table */
+    Column: <TRow extends {}>(props: LegacyTableColumnProps<TRow>) => JSX.Element | null;
+    /**
+     * Container for columns.
+     * Visually this adds a column above and spans all group children.
+     * *Note* that groups can only be nested two levels deep
+     */
+    Group: <TRow extends {}>(props: LegacyTableGroupProps<TRow>) => JSX.Element | null;
+} & (<TRow extends {}>(props: LegacyTableProps<TRow> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => JSX.Element);
+export declare type LegacyTableChild<TRow extends {}> = React.ReactElement<LegacyTableColumnProps<TRow>> | React.ReactElement<LegacyTableGroupProps<TRow>> | boolean | null;
+export declare type LegacyTableChildren<TRow extends {}> = LegacyTableChild<TRow> | LegacyTableChild<TRow>[];
+/** @internal */
+export declare type InternalTableColumn = LegacyTableColumnProps<any> & ColumnInstance & UseSortByColumnProps<{}> & {
+    className?: string;
+};
+/** @internal */
+export declare type InternalTableCell = LegacyTableCell<any> & Cell & {
+    column: InternalTableColumn;
+};
+/** @internal */
+export declare type InternalTableRow = LegacyTableRow<any> & BaseRow & UseExpandedRowProps<{}> & UseRowSelectRowProps<{}> & UseRowStateRowProps<{}>;
+/** @internal */
+export declare type InternalBaseTable = Partial<LegacyTableProps<any>> & Partial<TableInstance> & {
+    children: JSX.Element;
+    headerRef?: React.MutableRefObject<HTMLDivElement | null>;
+    bodyRef?: React.MutableRefObject<HTMLDivElement | null>;
+};
+/** @internal */
+export declare type InternalTable = {
+    rowProps: Pick<LegacyTableProps<any>, 'inlineEditingUniqueId' | 'onRowClick' | 'rowClassName' | 'rowExpansionRenderer'> & {
+        activeIndex?: number;
+        setActiveIndex?: any;
+        rowHeight: number | undefined;
+    };
+    tableProps: any;
+    state: any;
+    pagination: {
+        length: number;
+        pageSize: number;
+        pageIndex: number;
+        setPageIndex: (index: number) => void;
+        setPageSize: (size: number) => void;
+    } | null;
+    rows: any[];
+    prepareRow: (row: any, index: number) => void;
+    instance: any;
+};

package/dist/components/Table/util/renderColumn.d.ts

@@ -0,0 +1 @@
+export declare const Column: ({ cell }: any) => any;

package/dist/components/Table/util/renderRow.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Row: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;

package/dist/components/Table/util/rowIndexPath.d.ts

@@ -0,0 +1,5 @@
+import { Row, RowIndexPath } from '../types';
+export declare const convertRowIndexPathToNumberArray: (rowIndexPath: RowIndexPath) => number[];
+export declare const getByRowIndexPath: <TRow extends {}>(data: Row<TRow>[], rowIndexPath: RowIndexPath) => Row<TRow> | undefined;
+export declare const setByRowIndexPath: <TRow extends {}>(data: Row<TRow>[], rowIndexPath: RowIndexPath, values: any) => Row<TRow>[];
+export declare const getParentRowIndexPath: (rowIndexPath: RowIndexPath) => RowIndexPath;

package/dist/components/Table/util/sortTypes.d.ts

@@ -0,0 +1,4 @@
+import { SortTypes, LegacyTableRow } from '../types';
+declare type SortHandler<T> = (rowA: LegacyTableRow<T>, rowB: LegacyTableRow<T>, columnId: string) => 0 | 1 | -1;
+export declare const sortTypes: (locale: string) => Record<SortTypes, SortHandler<any>>;
+export {};

package/dist/components/Table/util.d.ts

@@ -0,0 +1,12 @@
+import { LegacyTableRow, LegacyTableChildren, InternalTableRow, SortRule } from './types';
+import { SortingRule } from 'react-table';
+export declare const sanitizeRowProps: (row: InternalTableRow, rowExpansionRenderer: any) => LegacyTableRow<any>;
+export declare const getColumnsFromChildren: (children: LegacyTableChildren<any>, rowExpansionRenderer: any) => {
+    columns: (import("./types").LegacyTableColumnProps<any> & import("react-table").ColumnInstance<{}> & import("react-table").UseSortByColumnProps<{}> & {
+        className?: string | undefined;
+    } & {
+        disableSortBy: boolean | undefined;
+    })[];
+    sortRules: SortingRule<any>[];
+};
+export declare const getInternalSortRules: <T>(sortRules: SortRule<T>[] | undefined) => SortingRule<T>[] | undefined;

package/dist/components/Table3/Table3.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { Table3Props, Table3Ref, Table3ColumnProps, Table3GroupProps } from './types';
+import './style.css';
+declare function Column<TType = unknown>(_: Table3ColumnProps<TType>): null;
+declare namespace Column {
+    var displayName: string;
+}
+declare function Group(_: Table3GroupProps): null;
+declare namespace Group {
+    var displayName: string;
+}
+export declare const Table3: (<TType = unknown>(props: (import("../..").TableClientProps<TType> & {
+    enableEditing?: boolean | undefined;
+    onEditingChange?: import("./types").Table3EditingChangeHandler<TType> | undefined;
+    onEditingCreate?: import("./types").Table3EditingCreateHandler<TType> | undefined;
+    onEditingSave?: import("./types").Table3EditingSaveHandler<TType> | undefined;
+    validator?: import("./types").Table3EditingValidatorFn<TType> | undefined;
+} & React.RefAttributes<Table3Ref>) | (import("../..").TableServerProps<TType> & {
+    enableEditing?: boolean | undefined;
+    onEditingChange?: import("./types").Table3EditingChangeHandler<TType> | undefined;
+    onEditingCreate?: import("./types").Table3EditingCreateHandler<TType> | undefined;
+    onEditingSave?: import("./types").Table3EditingSaveHandler<TType> | undefined;
+    validator?: import("./types").Table3EditingValidatorFn<TType> | undefined;
+} & React.RefAttributes<Table3Ref>)) => JSX.Element) & {
+    Column: typeof Column;
+    Group: typeof Group;
+};
+export type { Table3Props, Table3Ref, Table3ColumnProps, Table3GroupProps, Table3EditingSaveHandler, Table3EditingValidatorFn, Table3FeatureProps, Table3Texts, } from './types';

package/dist/components/Table3/components/Columns/Cell/Cell.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { TableCellRendererProps } from '../../../../../primitives/Table/Core/types';
+export declare function Cell<TType = unknown>(props: TableCellRendererProps<TType>): JSX.Element;

package/dist/components/Table3/components/Columns/Cell/Editing/RowMoveIndicator.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Cell as ReactTableCell } from '@tanstack/react-table';
+declare type TableRowMoveIndicatorProps<TType = unknown> = {
+    cell: ReactTableCell<TType, unknown>;
+    cellRef: React.RefObject<HTMLTableCellElement>;
+    isActiveRow: boolean;
+};
+export declare function RowMoveIndicator<TType = unknown>(props: TableRowMoveIndicatorProps<TType>): JSX.Element | null;
+export {};

package/dist/components/Table3/components/Columns/Cell/Editing/TextareaWithAutosizing.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { TableFontSize } from '../../../../../../primitives/Table/types';
+export declare const TextareaWithAutosizing: React.ForwardRefExoticComponent<React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    highlighted?: boolean | undefined;
+    invalid?: boolean | undefined;
+    value?: string | undefined;
+} & {
+    fontSize: TableFontSize;
+    isTruncated: boolean;
+} & React.RefAttributes<HTMLTextAreaElement>>;

package/dist/components/Table3/components/Columns/Cell/EditingControlCell.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { TableCellRendererProps } from '../../../../../primitives/Table/Core/types';
+export declare function EditingControlCell<TType = unknown>(props: TableCellRendererProps<TType>): JSX.Element;

package/dist/components/Table3/components/Columns/Cell/EditingDisplayCell.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { TableCellRendererProps } from '../../../../../primitives/Table/Core/types';
+export declare const EditingDisplayCell: <TType = unknown>(props: TableCellRendererProps<TType>) => JSX.Element;

package/dist/components/Table3/components/Columns/Cell/util.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { TableCellRendererProps } from '../../../../../primitives/Table/Core/types';
+export declare function useEditingCellAutofocus<TType = unknown>(props: TableCellRendererProps<TType>): (event: React.FocusEvent<HTMLTableCellElement>) => void;

package/dist/components/Table3/components/Columns/Internal/EditingActionsMenu.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+declare type EditingActionMenuProps = {
+    hasChanges: boolean;
+    hasErrors: boolean;
+    onClear: () => void;
+    onExit: () => void;
+    onEditingSave: () => Promise<void>;
+    isLastRow: boolean;
+};
+export declare function EditingActionMenu(props: EditingActionMenuProps): JSX.Element;
+export {};

package/dist/components/Table3/components/Editing/Alert.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+import { ScrollToOptions as ReactVirtualScrollToOptions } from '@tanstack/react-virtual';
+import { AlertProps as BaseAlertProps } from '../../../Alert/Alert';
+import { TableRef } from '../../../../primitives/Table/types';
+declare type AlertProps<TType = unknown> = Omit<BaseAlertProps, 'children'> & {
+    scrollToIndex: (index: number, options: ReactVirtualScrollToOptions) => void;
+    table: ReactTable<TType>;
+    tableRef: React.RefObject<TableRef>;
+};
+export declare function Alert<TType = unknown>(props: AlertProps<TType>): JSX.Element;
+export {};

package/dist/components/Table3/components/Row/Editing/CreateRowButton.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { Table as ReactTable, TableMeta as ReactTableMeta } from '@tanstack/react-table';
+import { ScrollToOptions } from '@tanstack/react-virtual';
+declare type Props<TType = unknown> = {
+    table: ReactTable<TType>;
+    tableMeta: ReactTableMeta<TType>;
+    onEditingCreate: (() => (row: Partial<TType>) => boolean) | undefined;
+    scrollToIndex: (index: number, options?: ScrollToOptions) => void;
+};
+export default function CreateNewRowButton<TType = unknown>(props: Props<TType>): JSX.Element;
+export {};

package/dist/components/Table3/components/Row/Editing/SaveStatus.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Table as ReactTable } from '@tanstack/react-table';
+declare type SaveStatusProps<TType = unknown> = {
+    rowId: string;
+    table: ReactTable<TType>;
+};
+export declare function SaveStatus<TType = unknown>(props: SaveStatusProps<TType>): JSX.Element;
+export {};

package/dist/components/Table3/components/Row/Row.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DisplayRowProps } from '../../../../primitives/Table/Core/components/Row/BuiltIns/DisplayRow';
+export declare function Row<TType = unknown>(props: DisplayRowProps<TType>): JSX.Element;

package/dist/components/Table3/components/Toolbar/Editing/Editing.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+declare type EditingProps<TType = unknown> = React.HTMLAttributes<HTMLButtonElement> & {
+    scrollToIndex: any;
+    table: ReactTable<TType>;
+};
+export declare function Editing<TType = unknown>(props: EditingProps<TType>): JSX.Element;
+export {};

package/dist/components/Table3/features/useTableEditing.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { Cell as ReactTableCell, Table as ReactTable } from '@tanstack/react-table';
+import { Table3EditingChangeHandler, Table3EditingSaveHandler, Table3EditingValidatorFn } from '../types';
+import { TableRef } from '../../../primitives/Table/types';
+export declare function useTableEditing<TType = unknown>(isEnabled: boolean | undefined, handleSave: Table3EditingSaveHandler<TType> | undefined, handleChange: Table3EditingChangeHandler<TType> | undefined, validator: Table3EditingValidatorFn<TType> | undefined): {
+    getCellValue: <T extends TType>(cell: ReactTableCell<T, unknown>) => unknown;
+    getCellError: <T_1 extends TType>(cell: ReactTableCell<T_1, unknown>) => string | undefined;
+    setCellValue: <T_2 extends TType>(cell: ReactTableCell<T_2, unknown>, change: unknown, rowIndex: number) => Promise<void>;
+    validateCell: <T_3 extends TType>(cell: ReactTableCell<T_3, unknown>) => Promise<void>;
+    addCreatedRowChangeset: (row: any) => Promise<void>;
+    hasChanges: (rowId?: string | undefined) => boolean;
+    hasErrors: <T_4 extends TType>(table: ReactTable<T_4>, tableRef: React.RefObject<TableRef>) => number | false;
+    getErrors: <T_5 extends TType>() => {
+        rowId: string;
+        pendingChange: PendingChange<T_5>;
+    }[];
+    saveChanges: (rowId?: string | undefined) => Promise<void>;
+    resetChanges: (rowId: string) => void;
+    hasRowErrors: (rowId: string) => boolean;
+    hasRowErrorsSeen: (rowId: string) => boolean;
+    setRowErrorsSeen: (rowId: string) => void;
+    getRowSaveStatus: (rowId: string) => false | "pending" | "complete";
+    setRowSaveStatus: (rowId: string, status: "pending" | "complete" | undefined) => void;
+    getRowMoveReason: (rowId: string) => "search" | "sorting" | "filter" | undefined;
+    isEnabled: boolean;
+    isEditing: boolean;
+    isDetailedMode: boolean;
+    toggleDetailedMode: React.Dispatch<React.SetStateAction<boolean>>;
+    toggleEditing: React.Dispatch<React.SetStateAction<boolean>>;
+    lastFocusedCellIndex: number | undefined;
+    setLastFocusedCellIndex: (index: number | undefined) => void;
+};
+declare type SaveState = 'pending' | 'complete';
+declare type PendingChange<TType = unknown> = Partial<TType> & {
+    _meta: {
+        original: TType;
+        moveReason: Record<string, 'search' | 'sorting' | 'filter'>;
+        errors: {
+            row: string;
+            cells: Record<string, string>;
+            hasShownErrorAlert: boolean;
+        };
+        status?: SaveState;
+    };
+};
+export {};

package/dist/components/Table3/listeners/useTableEditingListener.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { Table as ReactTable } from '@tanstack/react-table';
+import { TableRef } from '../../../primitives/Table/types';
+export declare function useTableEditingListener<TType = unknown>(table: ReactTable<TType>, tableRef: React.RefObject<TableRef>): void;

package/dist/components/Table3/types.d.ts

@@ -0,0 +1,73 @@
+import { TableFeatureProps, TableProps, TableRef, TableColumnProps, TableGroupProps } from '../../primitives/Table/types';
+export declare type Table3Ref = TableRef & {
+    instance: {
+        toggleEditing: (enabled: boolean | undefined) => void;
+    };
+};
+export declare type Table3EditingChangeHandler<TType = unknown> = (accessor: string, value: unknown, row: TType, prevRow: TType) => Promise<Partial<TType>> | undefined;
+export declare type Table3EditingCreateHandler<TType = unknown> = () => (row: Partial<TType>) => boolean;
+export declare type Table3EditingSaveHandler<TType = unknown> = (row: TType) => Promise<void>;
+export declare type Table3EditingValidatorFn<TType = unknown> = (row: TType) => Promise<Partial<Record<keyof TType, string>> | undefined> | Partial<Record<keyof TType, string>> | undefined;
+export declare type Table3FeatureProps = TableFeatureProps & {
+    enableEditing?: boolean;
+};
+export declare type Table3Props<TType = unknown> = TableProps<TType> & {
+    enableEditing?: boolean;
+    onEditingChange?: Table3EditingChangeHandler<TType>;
+    onEditingCreate?: Table3EditingCreateHandler<TType>;
+    onEditingSave?: Table3EditingSaveHandler<TType>;
+    validator?: Table3EditingValidatorFn<TType>;
+};
+export declare type Table3ColumnProps<TType = unknown> = TableColumnProps<TType>;
+export declare type Table3GroupProps = TableGroupProps;
+export declare type Table3Texts = {
+    editing: {
+        actions: {
+            tooltip: string;
+            save: string;
+            clear: string;
+            exit: string;
+        };
+        buttons: {
+            edit: {
+                tooltip: string;
+            };
+            create: {
+                label: string;
+            };
+        };
+        clearChangesConfirmationDialog: {
+            title: string;
+            description: string;
+            cancel: string;
+            confirm: string;
+        };
+        rowIndicator: {
+            rowWillMove: string;
+            rowWillBeHidden: string;
+            rowWillMoveReasonSearch: string;
+            rowWillMoveReasonFilter: string;
+            rowWillMoveReasonSorting: string;
+        };
+        saving: {
+            progress: string;
+            complete: string;
+        };
+        validation: {
+            alert: {
+                titleOne: string;
+                titlePlural: string;
+                messageOne: string;
+                messagePlural: string;
+                messageRow: string;
+                messageAnd: string;
+            };
+            resetFiltersDialog: {
+                title: string;
+                description: string;
+                cancel: string;
+                confirm: string;
+            };
+        };
+    };
+};

package/dist/components/Table3/useTable3.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { RowData } from '@tanstack/react-table';
+import { useTableEditing } from './features/useTableEditing';
+import { Table3Props, Table3Ref } from './types';
+declare module '@tanstack/table-core' {
+    interface TableMeta<TData extends RowData> {
+        editing: ReturnType<typeof useTableEditing>;
+    }
+}
+export declare function useTable3<TType>(props: Table3Props<TType>, ref: React.Ref<Table3Ref>): import("../../primitives/Table/Core/useTable").useTableReturnValue<TType>;

package/dist/components/Table3/util/editing.d.ts

@@ -0,0 +1,3 @@
+import { Cell as ReactTableCell } from '@tanstack/react-table';
+export declare function willRowMove<TType = unknown>(cell: ReactTableCell<TType, unknown>, change: unknown, rowIndex: number): "search" | "filter" | "sorting" | undefined;
+export declare function animateCreateRow(id: any): void;