@jiaozhiye/qm-design-react 1.0.0-beta.1

package/lib/table/src/filter/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IColumn, IFilter } from '../table/types';
+declare type IHeadFilterProps = {
+    column: IColumn;
+    filters: IFilter;
+};
+declare const HeadFilter: React.FC<IHeadFilterProps>;
+export default HeadFilter;

package/lib/table/src/filter-sql/index.d.ts

@@ -0,0 +1,5 @@
+import type { IRecord } from '../table/types';
+export declare const stringify: (string: any, separator?: string) => any;
+export declare const array_format: (array: any) => string;
+export declare const isBracketBalance: (str: any) => boolean;
+export declare const where: <T extends IRecord<any>>(array: T[], query: string) => T[];

package/lib/table/src/filter-sql/lib/filter_string.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    operations: (string: any) => any[];
+    number_operations: (string: any) => any;
+    string_format: (string: any) => any;
+    stringify: (string: any, separator?: string) => any;
+    array_format: (array: any) => string;
+    operation_format: (string: any) => any;
+    find_replace: (string: any, find: any, replace: any) => any;
+    replace_symbols: (string: any) => any;
+};
+export default _default;

package/lib/table/src/filter-sql/lib/operations.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 解析 where 条件的各种情况
+ * @param {any} value 数据值
+ * @param {string} expression 标记符
+ * @param {any} condition 条件值
+ * @returns {boolean}
+ */
+export declare const matchWhere: (value: any, expression: string, condition: any) => boolean;

package/lib/table/src/filter-sql/lib/variables_replacement.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    isBracketBalance: (str: any) => boolean;
+    replace_variables: (string: any, variable: any) => any;
+};
+export default _default;

package/lib/table/src/footer/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+declare type IFootProps = {
+    summationRows: Record<string, string | number>[];
+    flattenColumns: IColumn[];
+};
+declare const TableFooter: React.FC<IFootProps>;
+export default TableFooter;

package/lib/table/src/full-screen/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare type IFullScreenProps = {
+    isFullScreen: boolean;
+};
+declare const FullScreen: React.FC<IFullScreenProps>;
+export default FullScreen;

package/lib/table/src/group-summary/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const GroupSummary: React.FC;
+export default GroupSummary;

package/lib/table/src/group-summary/result.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { IColumn, IRecord } from '../table/types';
+declare type IResultProps = {
+    columns: IColumn[];
+    group: IRecord[];
+    summary: IRecord[];
+};
+declare const Result: React.FC<IResultProps>;
+export default Result;

package/lib/table/src/group-summary/setting.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare type ISettingProps = {
+    onClose: () => void;
+};
+declare const Setting: React.FC<ISettingProps>;
+export default Setting;

package/lib/table/src/header/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { IColumn, IFilter, ISorter } from '../table/types';
+declare type IHeaderProps = {
+    tableColumns: IColumn[];
+    flattenColumns: IColumn[];
+    sorter: ISorter;
+    filters: IFilter;
+};
+declare const TableHeader: React.FC<IHeaderProps>;
+export default TableHeader;

package/lib/table/src/hooks/useImperativeMethod.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { ITableRef } from './useTableRef';
+import type { getRowKeyType, IColumn, IFetchParams, IPagination, IRecord, IRowKey, IRule, IValidItem, TableBodyRef, TableRef } from '../table/types';
+declare type IExtra = {
+    getRowKey: getRowKeyType;
+    tableRef: React.MutableRefObject<ITableRef>;
+    tableBodyRef: React.RefObject<TableBodyRef>;
+    flattenColumns: IColumn[];
+    editableColumns: IColumn[];
+    pagination: IPagination;
+    fetchParams: IFetchParams;
+    isFetch: boolean;
+    dataChange: () => void;
+    getTableData: () => Promise<void>;
+    createTableData: (records: IRecord[]) => void;
+    calcTableHeight: () => void;
+    scrollXToColumn: (dataIndex: string, index?: number) => void;
+    scrollYToRecord: (rowKey: IRowKey, index?: number) => void;
+    doFieldValidate: (rules: IRule[], val: unknown, rowKey: IRowKey, columnKey: string) => void;
+    setHandleState: (option: ITableRef['handleState']) => void;
+    getTableLog: () => {
+        required: IValidItem[];
+        validate: IValidItem[];
+        inserted: IValidItem[];
+        updated: IValidItem[];
+        removed: IValidItem[];
+    };
+    clearRowSelection: () => void;
+    clearRowHighlight: () => void;
+    clearTableSorter: () => void;
+    clearTableFilter: () => void;
+    clearSuperFilters: () => void;
+    clearTableLog: () => void;
+};
+declare const useImperativeMethod: <T extends React.ForwardedRef<TableRef>>(ref: T, extra: IExtra) => void;
+export default useImperativeMethod;

package/lib/table/src/hooks/useTableCore.d.ts

@@ -0,0 +1,86 @@
+import React from 'react';
+import type { ITableRef } from './useTableRef';
+import type { ITableState } from './useTableState';
+import type { getRowKeyType, IColumn, IDerivedRowKey, IFetchParams, IFilter, IPagination, IRecord, IRowKey, IRule, ISorter, ISuperFilter, ITableProps, IValidItem, TableBodyRef } from '../table/types';
+import type { ComponentSize } from '../../../_utils/types';
+declare type IExtra = {
+    getRowKey: getRowKeyType;
+    tableRef: React.MutableRefObject<ITableRef>;
+    tableElementRef: React.RefObject<HTMLElement>;
+    tableBodyRef: React.RefObject<TableBodyRef>;
+    $size: ComponentSize;
+    tableColumns: IColumn[];
+    tableFullData: IRecord[];
+    pagination: IPagination;
+    filters: IFilter;
+    sorter: ISorter;
+    superFilters: ISuperFilter[];
+    fetchParams: IFetchParams;
+    selectionKeys: IRowKey[];
+    highlightKey: IRowKey;
+    summationColumns: IColumn[];
+    shouldUpdateHeight: boolean;
+    isFetch: boolean;
+    isTreeTable: boolean;
+    isWebPagination: boolean;
+    isScrollPagination: boolean;
+    isServiceSummation: boolean;
+    isGroupSubtotal: boolean;
+    doLayout: () => void;
+    calcTableHeight: () => void;
+    setTableData: (records: IRecord[]) => void;
+    setTableFullData: (records: IRecord[]) => void;
+    setTableOriginData: (records: IRecord[]) => void;
+    setAllTableData: (records: IRecord[]) => void;
+    setDeriveRowKeys: (records: IRecord[]) => void;
+    setPagination: <T extends IPagination>(pagination: T | ((prev: T) => T)) => void;
+    setSpinning: (value: boolean) => void;
+    setSorter: (sorter: ITableState['sorter']) => void;
+    setFilters: (sorter: ITableState['filters']) => void;
+    setSuperFilters: (options: ITableState['superFilters']) => void;
+    setSelectionKeys: (rowKeys: IRowKey[]) => void;
+    setHighlightKey: (rowKey: IRowKey) => void;
+    setScrollYLoad: (scrollYLoad: boolean) => void;
+    setScrollYStore: (option: ITableRef['scrollYStore']) => void;
+    setResizeState: (option: ITableRef['resizeState']) => void;
+    setSummaries: (option: ITableRef['summaries']) => void;
+    setPermission: <T extends ITableState['permission']>(option: T | ((prev: T) => T)) => void;
+    setRowKeysMap: (key: IRowKey, value: number) => void;
+    resetTableScroll: () => void;
+    clearElementStore: () => void;
+    clearAllRowKeysMap: () => void;
+};
+declare const useTableCore: <T extends ITableProps>(props: T, extra: IExtra) => {
+    initialTable: () => void;
+    createTableFullData: (list: IRecord[]) => void;
+    getTableData: () => Promise<void>;
+    createTableData: (list: IRecord[]) => void;
+    createGroupData: (list: IRecord[]) => IRecord<any>[];
+    createSelectionKeys: () => (string | number)[];
+    createSelectionRows: (selectedKeys: IRowKey[]) => IRecord<any>[];
+    createRowExpandedKeys: () => (string | number)[];
+    findParentRowKeys: (deriveRowKeys: IDerivedRowKey[], key: IRowKey) => (string | number)[];
+    getAllChildRowKeys: (deriveRowKeys: IDerivedRowKey[]) => (string | number)[];
+    doFieldValidate: (rules: IRule[], val: unknown, rowKey: IRowKey, columnKey: string) => void;
+    getTableLog: () => {
+        required: IValidItem[];
+        validate: IValidItem[];
+        inserted: IValidItem[];
+        updated: IValidItem[];
+        removed: IValidItem[];
+    };
+    dataChange: () => void;
+    tableChange: import("lodash").DebouncedFunc<(backTop?: boolean) => void>;
+    toLastPage: () => void;
+    pagerChangeHandle: ({ current, pageSize }: Omit<IPagination, 'total'>) => void;
+    triggerScrollYEvent: (st: number) => void;
+    scrollBottomDebouncer: import("lodash").DebouncedFunc<(ev: React.SyntheticEvent<HTMLDivElement>) => void>;
+    clearTableSorter: () => void;
+    clearTableFilter: () => void;
+    clearSuperFilters: () => void;
+    clearRowSelection: () => void;
+    clearRowHighlight: () => void;
+    clearTableLog: () => void;
+    destroy: () => void;
+};
+export default useTableCore;

package/lib/table/src/hooks/useTableEffect.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { ITableRef } from './useTableRef';
+import type { TableBodyRef, IColumn, IPagination, IRecord, IRowKey, ITableProps } from '../table/types';
+declare type IExtra = {
+    tableRef: React.MutableRefObject<ITableRef>;
+    topElementRef: React.RefObject<HTMLDivElement>;
+    tableElementRef: React.RefObject<HTMLDivElement>;
+    tableBodyRef: React.RefObject<TableBodyRef>;
+    resizableBarRef: React.RefObject<HTMLDivElement>;
+    pagination: IPagination;
+    selectionKeys: IRowKey[];
+    rowExpandedKeys: IRowKey[];
+    highlightKey: IRowKey;
+    summationRows: Record<string, number | string>[];
+    isWebPagination: boolean;
+    isScrollPagination: boolean;
+    isTreeTable: boolean;
+    toLastPage: () => void;
+    setHandleState: (option: ITableRef['handleState']) => void;
+    scrollYToRecord: (rowKey: IRowKey, index?: number) => void;
+    setOriginColumns: (columns: IColumn[]) => void;
+    setSelectionKeys: (rowKeys: IRowKey[]) => void;
+    setSelectionRows: (records: IRecord[]) => void;
+    setRowExpandedKeys: (rowKeys: IRowKey[]) => void;
+    setHighlightKey: (rowKey: IRowKey) => void;
+    createSelectionKeys: () => IRowKey[];
+    createSelectionRows: (rowKeys: IRowKey[]) => IRecord[];
+    createRowExpandedKeys: () => IRowKey[];
+    createElementStore: (option: Record<string, HTMLElement>) => void;
+    triggerScrollYEvent: (st: number) => void;
+    initialTable: () => void;
+    destroy: () => void;
+};
+declare const useTableEffect: <T extends ITableProps>(props: T, extra: IExtra) => void;
+export default useTableEffect;

package/lib/table/src/hooks/useTableLayout.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import type { IColumn, IRecord, IRowKey, ITableProps } from '../table/types';
+import type { ITableState } from './useTableState';
+import type { ITableRef } from './useTableRef';
+import type { ComponentSize } from '../../../_utils/types';
+declare type IExtra = {
+    tableRef: React.MutableRefObject<ITableRef>;
+    $size: ComponentSize;
+    tableColumns: IColumn[];
+    flattenColumns: IColumn[];
+    leftFixedColumns: IColumn[];
+    layout: ITableState['layout'];
+    scrollY: boolean;
+    showFooter: boolean;
+    showPagination: boolean;
+    isFullScreen: boolean;
+    setLayout: <T extends ITableState['layout']>(layout: T | ((prev: T) => T)) => void;
+    setScrollX: (scrollX: boolean) => void;
+    setScrollY: (scrollY: boolean) => void;
+    setElementStore: (key: string, value: HTMLElement) => void;
+    setScrollYStore: (option: ITableRef['scrollYStore']) => void;
+};
+declare const useTableLayout: <T extends ITableProps>(props: T, extra: IExtra) => {
+    createElementStore: (option: Record<string, HTMLElement>) => void;
+    tableStyles: React.CSSProperties;
+    updateColumnsWidth: () => void;
+    getSpan: (row: IRecord, column: IColumn, rowIndex: number, columnIndex: number, tableData: IRecord[]) => {
+        rowSpan: number;
+        colSpan: number;
+    };
+    getStickyLeft: (rowKey: IRowKey) => number;
+    getStickyRight: (rowKey: IRowKey) => number;
+    scrollXToColumn: (dataIndex: string, index?: number | undefined) => void;
+    scrollYToRecord: (rowKey: IRowKey, index?: number | undefined) => void;
+    calcTableHeight: () => void;
+    resetTableScroll: () => void;
+    doLayout: () => void;
+};
+export default useTableLayout;

package/lib/table/src/hooks/useTableMemo.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { ITableProps, IColumn, IRecord, IRowKey, getRowKeyType, IFetchParams, ISorter, IFilter, IPagination, ISuperFilter } from '../table/types';
+import type { ITableRef } from './useTableRef';
+declare type IExtra = {
+    getRowKey: getRowKeyType;
+    tableRef: React.MutableRefObject<ITableRef>;
+    tableFullData: IRecord[];
+    tableData: IRecord[];
+    sorter: ISorter;
+    filters: IFilter;
+    superFilters: ISuperFilter[];
+    pagination: IPagination;
+    selectionKeys: IRowKey[];
+};
+declare const useTableMemo: <T extends ITableProps>(props: T, extra: IExtra) => {
+    isFetch: boolean;
+    isWebPagination: boolean;
+    isScrollPagination: boolean;
+    showPagination: boolean;
+    shouldUpdateHeight: boolean;
+    tableColumns: IColumn[];
+    flattenColumns: IColumn[];
+    editableColumns: IColumn[];
+    summationColumns: IColumn[];
+    leftFixedColumns: IColumn[];
+    rightFixedColumns: IColumn[];
+    showSummary: boolean;
+    showFooter: boolean;
+    isHeadGroup: boolean;
+    bordered: boolean;
+    isHeadSorter: boolean;
+    isHeadFilter: boolean;
+    isServiceSummation: boolean;
+    isSelectCollection: boolean;
+    isSuperSearch: boolean;
+    isGroupSummary: boolean;
+    isGroupSubtotal: boolean;
+    isTreeTable: boolean;
+    isTableEmpty: boolean;
+    summationRows: Record<string, string | number>[];
+    fetchParams: IFetchParams;
+};
+export default useTableMemo;

package/lib/table/src/hooks/useTableRef.d.ts

@@ -0,0 +1,89 @@
+import React from 'react';
+import Store from '../store';
+import type { getRowKeyType, IColumn, IDerivedRowKey, IRecord, IRowKey, ITableProps } from '../table/types';
+import type { ComponentSize, Nullable } from '../../../_utils/types';
+export declare type ITableRef = {
+    uid: string;
+    elementStore: Record<string, Nullable<HTMLElement>>;
+    originColumns: IColumn[];
+    tableFullData: IRecord[];
+    tableOriginData: IRecord[];
+    allTableData: IRecord[];
+    allRowKeys: IRowKey[];
+    deriveRowKeys: IDerivedRowKey[];
+    scrollYStore: {
+        startIndex: number;
+        endIndex: number;
+        offsetSize: number;
+        visibleSize: number;
+        rowHeight: number;
+    };
+    store: Store;
+    resizeState: {
+        width: number;
+        height: number;
+        winHeight: number;
+    };
+    handleState: {
+        insert: boolean;
+        remove: boolean;
+    };
+    summaries: Record<string, number>;
+    scrollYLoad: boolean;
+    selectionRows: IRecord[];
+    rowKeysMap: Map<IRowKey, number>;
+    isIE: boolean;
+};
+declare type IExtra = {
+    getRowKey: getRowKeyType;
+    $size: ComponentSize;
+};
+declare const useTableRef: <T extends ITableProps>(props: T, { getRowKey, $size }: IExtra) => {
+    setElementStore: (key: string, value: HTMLElement) => void;
+    setOriginColumns: (columns: IColumn[]) => void;
+    setTableFullData: (records: IRecord[]) => void;
+    setTableOriginData: (records: IRecord[]) => void;
+    setAllTableData: (records: IRecord[]) => void;
+    setDeriveRowKeys: (records: IRecord[]) => void;
+    setScrollYStore: (option: ITableRef['scrollYStore']) => void;
+    setResizeState: (option: ITableRef['resizeState']) => void;
+    setHandleState: (option: ITableRef['handleState']) => void;
+    setSummaries: (option: ITableRef['summaries']) => void;
+    setScrollYLoad: (value: boolean) => void;
+    setSelectionRows: (selectKeys: IRecord[]) => void;
+    setRowKeysMap: (key: IRowKey, value: number) => void;
+    clearElementStore: () => void;
+    clearAllRowKeysMap: () => void;
+    uid: string;
+    elementStore: Record<string, Nullable<HTMLElement>>;
+    originColumns: IColumn[];
+    tableFullData: IRecord[];
+    tableOriginData: IRecord[];
+    allTableData: IRecord[];
+    allRowKeys: IRowKey[];
+    deriveRowKeys: IDerivedRowKey[];
+    scrollYStore: {
+        startIndex: number;
+        endIndex: number;
+        offsetSize: number;
+        visibleSize: number;
+        rowHeight: number;
+    };
+    store: Store;
+    resizeState: {
+        width: number;
+        height: number;
+        winHeight: number;
+    };
+    handleState: {
+        insert: boolean;
+        remove: boolean;
+    };
+    summaries: Record<string, number>;
+    scrollYLoad: boolean;
+    selectionRows: IRecord[];
+    rowKeysMap: Map<IRowKey, number>;
+    isIE: boolean;
+    tableRef: React.MutableRefObject<ITableRef>;
+};
+export default useTableRef;

package/lib/table/src/hooks/useTableState.d.ts

@@ -0,0 +1,94 @@
+import React from 'react';
+import type { IFilter, IPagination, IRecord, IRowKey, ISorter, ISuperFilter, ITableProps } from '../table/types';
+export declare type ITableState = {
+    tableData: IRecord[];
+    filters: IFilter;
+    sorter: ISorter;
+    superFilters: ISuperFilter[];
+    pagination: IPagination;
+    selectionKeys: IRowKey[];
+    rowExpandedKeys: IRowKey[];
+    highlightKey: IRowKey;
+    layout: {
+        gutterWidth: number;
+        tableWidth: number;
+        tableBodyWidth: number;
+        tableBodyHeight: number;
+        viewportHeight: number;
+        headerHeight: number;
+        footerHeight: number;
+        tableAutoHeight: number;
+        tableFullHeight: number;
+    };
+    permission: {
+        export: boolean;
+        print: boolean;
+    };
+    spinning: boolean;
+    scrollX: boolean;
+    scrollY: boolean;
+    isPingLeft: boolean;
+    isPingRight: boolean;
+    isFullScreen: boolean;
+};
+declare const useTableState: <T extends ITableProps>(props: T) => {
+    tableData: IRecord<any>[];
+    setTableData: React.Dispatch<React.SetStateAction<IRecord<any>[]>>;
+    filters: IFilter;
+    setFilters: React.Dispatch<IFilter>;
+    sorter: ISorter;
+    setSorter: React.Dispatch<ISorter>;
+    superFilters: ISuperFilter[];
+    setSuperFilters: React.Dispatch<ISuperFilter[]>;
+    pagination: Required<Pick<import("../table/types").IPaginationConfig, "current" | "total" | "pageSize">>;
+    setPagination: React.Dispatch<React.SetStateAction<Required<Pick<import("../table/types").IPaginationConfig, "current" | "total" | "pageSize">>>>;
+    selectionKeys: (string | number)[];
+    setSelectionKeys: React.Dispatch<(string | number)[]>;
+    rowExpandedKeys: (string | number)[];
+    setRowExpandedKeys: React.Dispatch<(string | number)[]>;
+    highlightKey: string | number;
+    setHighlightKey: React.Dispatch<React.SetStateAction<string | number>>;
+    layout: {
+        gutterWidth: number;
+        tableWidth: number;
+        tableBodyWidth: number;
+        tableBodyHeight: number;
+        viewportHeight: number;
+        headerHeight: number;
+        footerHeight: number;
+        tableAutoHeight: number;
+        tableFullHeight: number;
+    };
+    permission: {
+        export: boolean;
+        print: boolean;
+    };
+    setPermission: React.Dispatch<React.SetStateAction<{
+        export: boolean;
+        print: boolean;
+    }>>;
+    setLayout: React.Dispatch<React.SetStateAction<{
+        gutterWidth: number;
+        tableWidth: number;
+        tableBodyWidth: number;
+        tableBodyHeight: number;
+        viewportHeight: number;
+        headerHeight: number;
+        footerHeight: number;
+        tableAutoHeight: number;
+        tableFullHeight: number;
+    }>>;
+    spinning: boolean;
+    setSpinning: React.Dispatch<React.SetStateAction<boolean>>;
+    scrollX: boolean;
+    setScrollX: React.Dispatch<React.SetStateAction<boolean>>;
+    scrollY: boolean;
+    setScrollY: React.Dispatch<React.SetStateAction<boolean>>;
+    isPingLeft: boolean;
+    setPingLeft: React.Dispatch<React.SetStateAction<boolean>>;
+    isPingRight: boolean;
+    setPingRight: React.Dispatch<React.SetStateAction<boolean>>;
+    isFullScreen: boolean;
+    setFullScreen: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export default useTableState;

package/lib/table/src/icon/caretdown.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const CaretDownIcon: React.FC;
+export default CaretDownIcon;

package/lib/table/src/icon/caretup.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const CaretUpIcon: React.FC;
+export default CaretUpIcon;

package/lib/table/src/icon/filter.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const FilterIcon: React.FC;
+export default FilterIcon;

package/lib/table/src/manager/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { TableRef } from '../table/types';
+import type { Nullable } from '../../../_utils/types';
+declare type Instance = {
+    id: string;
+    vm: React.ForwardedRef<TableRef>;
+};
+declare const TableManager: {
+    getFocusInstance: () => Nullable<Instance>;
+    getInstance: (id: string) => Nullable<Instance>;
+    focus: (id: string) => void;
+    register: (id: string, instance: React.ForwardedRef<TableRef>) => void;
+    deregister: (id: string) => void;
+};
+export default TableManager;

package/lib/table/src/pager/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { IPaginationConfig } from '../table/types';
+declare type IPagerProps = {
+    current: number;
+    pageSize: number;
+    total: number;
+    config?: Pick<IPaginationConfig, 'pageSizeOptions' | 'showSizeChanger' | 'showQuickJumper'>;
+    onChange: (current: number, pageSize: number) => void;
+};
+declare const TablePager: React.FC<IPagerProps>;
+export default TablePager;

package/lib/table/src/print/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+declare type ITablePrintProps = {
+    tableColumns: IColumn[];
+};
+declare const TablePrint: React.FC<ITablePrintProps>;
+export default TablePrint;

package/lib/table/src/reload/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const Reload: React.FC;
+export default Reload;

package/lib/table/src/resizable/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+declare type IResizableProps = {
+    column: IColumn;
+};
+declare const Resizable: React.FC<IResizableProps>;
+export default Resizable;

package/lib/table/src/select-collection/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+declare type ISelectCollectionProps = {
+    columns: IColumn[];
+};
+declare const SelectCollection: React.FC<ISelectCollectionProps>;
+export default SelectCollection;

package/lib/table/src/select-collection/result.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+declare type IResultProps = {
+    columns: IColumn[];
+    onClose: () => void;
+};
+declare const Result: React.FC<IResultProps>;
+export default Result;

package/lib/table/src/selection/all.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { IRowKey } from '../table/types';
+declare type IAllSelectionProps = {
+    selectionKeys: IRowKey[];
+};
+declare const AllSelection: React.FC<IAllSelectionProps>;
+export default AllSelection;

package/lib/table/src/selection/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { IColumn, IRecord, IRowKey, ISelectionType } from '../table/types';
+declare type ISelectionProps = {
+    selectionKeys: IRowKey[];
+    column: IColumn & {
+        type?: ISelectionType;
+    };
+    record: IRecord;
+    rowKey: IRowKey;
+};
+declare const Selection: React.FC<ISelectionProps>;
+export default Selection;

package/lib/table/src/store/index.d.ts

@@ -0,0 +1,29 @@
+declare type IStoreItem = {
+    x: string;
+    y: string;
+    text: string;
+};
+declare type IStoreState = {
+    required: IStoreItem[];
+    validate: IStoreItem[];
+    inserted: IStoreItem[];
+    updated: IStoreItem[];
+    removed: IStoreItem[];
+};
+declare class Store {
+    state: IStoreState;
+    addToRequired: (data: any) => void;
+    removeFromRequired: (data: any) => void;
+    addToValidate: (data: any) => void;
+    removeFromValidate: (data: any) => void;
+    addToInserted: (data: any) => void;
+    removeFromInserted: (data: any) => void;
+    addToUpdated: (data: any) => void;
+    removeFromUpdated: (data: any) => void;
+    addToRemoved: (data: any) => void;
+    removeFromRemoved: (data: any) => void;
+    clearAllLog: () => void;
+    destroy: () => void;
+}
+export default Store;
+export type { Store };