@pdg/react-table 1.0.140 → 1.1.0

package/dist/@types/types.d.ts

@@ -1,11 +1,11 @@
 import { CSSProperties, ReactNode } from 'react';
 import { SxProps } from '@mui/system';
 import { Theme } from '@mui/material/styles';
-export interface TableCommonProps {
+export interface PTableCommonProps {
     children?: ReactNode;
     className?: string;
     style?: CSSProperties;
 }
-export interface TableCommonSxProps extends TableCommonProps {
+export interface PTableCommonSxProps extends PTableCommonProps {
     sx?: SxProps<Theme>;
 }

package/dist/PInfoTable/PInfoTable.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { PInfoTableProps as Props, PInfoTableInfo } from './PInfoTable.types';
+interface WithType<T = PInfoTableInfo> extends React.FC<Props<T>> {
+    <T = PInfoTableInfo>(props: Props<T>): ReturnType<React.FC<Props<T>>>;
+}
+declare const PInfoTable: WithType;
+export default PInfoTable;

package/dist/{InfoTable/InfoTable.types.d.ts → PInfoTable/PInfoTable.types.d.ts}

@@ -1,16 +1,16 @@
 import { ReactNode } from 'react';
 import { BoxProps, GridProps, IconButtonProps, TypographyProps } from '@mui/material';
-import { TableCommonSxProps } from '../@types';
-import { PdgIconProps } from '@pdg/react-component';
-export interface InfoTableInfo {
+import { PTableCommonSxProps } from '../@types';
+import { PIconProps } from '@pdg/react-component';
+export interface PInfoTableInfo {
     [key: string]: any;
 }
-export type InfoTableItemType = 'text' | 'number' | 'tel' | 'url' | 'email' | 'date' | 'datetime' | 'date-hour' | 'date-minute' | 'business_no' | 'personal_no' | 'divider';
-export interface InfoTableItem<T = InfoTableInfo> {
-    icon?: PdgIconProps['children'];
+export type PInfoTableItemType = 'text' | 'number' | 'tel' | 'url' | 'email' | 'date' | 'datetime' | 'date-hour' | 'date-minute' | 'business_no' | 'personal_no' | 'divider';
+export interface PInfoTableItem<T = PInfoTableInfo> {
+    icon?: PIconProps['children'];
     label?: ReactNode;
     name?: keyof T;
-    type?: InfoTableItemType;
+    type?: PInfoTableItemType;
     ellipsis?: boolean;
     className?: string;
     dateFormat?: string;
@@ -19,15 +19,15 @@ export interface InfoTableItem<T = InfoTableInfo> {
     numberSuffix?: string;
     dividerColor?: TypographyProps['color'];
     dividerLine?: boolean;
-    style?: TableCommonSxProps['style'];
+    style?: PTableCommonSxProps['style'];
     sx?: BoxProps['sx'];
     labelClassName?: string;
     labelColor?: TypographyProps['color'];
-    labelStyle?: TableCommonSxProps['style'];
+    labelStyle?: PTableCommonSxProps['style'];
     labelSx?: BoxProps['sx'];
     valueClassName?: string;
-    valueStyle?: TableCommonSxProps['style'];
-    valueSx?: TableCommonSxProps['sx'];
+    valueStyle?: PTableCommonSxProps['style'];
+    valueSx?: PTableCommonSxProps['sx'];
     xs?: number;
     sm?: number;
     md?: number;
@@ -46,33 +46,33 @@ export interface InfoTableItem<T = InfoTableInfo> {
     onLg?(info: T): number;
     onXl?(info: T): number;
 }
-export type InfoTableItems<T = InfoTableInfo> = (InfoTableItem<T> | false | undefined | null)[];
-export type InfoTableCols = 1 | 2 | 3 | 4 | 6 | 12;
-export interface InfoTableProps<T = InfoTableInfo> {
-    cols: InfoTableCols | {
-        xs?: InfoTableCols;
-        sm?: InfoTableCols;
-        md?: InfoTableCols;
-        lg?: InfoTableCols;
-        xl?: InfoTableCols;
+export type PInfoTableItems<T = PInfoTableInfo> = (PInfoTableItem<T> | false | undefined | null)[];
+export type PInfoTableCols = 1 | 2 | 3 | 4 | 6 | 12;
+export interface PInfoTableProps<T = PInfoTableInfo> {
+    cols: PInfoTableCols | {
+        xs?: PInfoTableCols;
+        sm?: PInfoTableCols;
+        md?: PInfoTableCols;
+        lg?: PInfoTableCols;
+        xl?: PInfoTableCols;
     };
     spacing?: GridProps['spacing'];
     columnSpacing?: GridProps['spacing'];
     rowSpacing?: GridProps['spacing'];
     className?: string;
-    style?: TableCommonSxProps['style'];
-    sx?: TableCommonSxProps['sx'];
+    style?: PTableCommonSxProps['style'];
+    sx?: PTableCommonSxProps['sx'];
     labelClassName?: string;
     labelColor?: TypographyProps['color'];
-    labelStyle?: TableCommonSxProps['style'];
+    labelStyle?: PTableCommonSxProps['style'];
     labelSx?: BoxProps['sx'];
     dividerColor?: TypographyProps['color'];
     valueClassName?: string;
-    valueStyle?: TableCommonSxProps['style'];
-    valueSx?: TableCommonSxProps['sx'];
+    valueStyle?: PTableCommonSxProps['style'];
+    valueSx?: PTableCommonSxProps['sx'];
     ellipsis?: boolean;
     valueUnderline?: boolean;
     info: T;
-    items: InfoTableItems<T>;
-    onCopyToClipboard?(item: InfoTableItem<T>, text: string): void;
+    items: PInfoTableItems<T>;
+    onCopyToClipboard?(item: PInfoTableItem<T>, text: string): void;
 }

package/dist/PInfoTable/index.d.ts

@@ -0,0 +1,4 @@
+import PInfoTable from './PInfoTable';
+export default PInfoTable;
+export { PInfoTable };
+export * from './PInfoTable.types';

package/dist/PSearchTable/PSearchTable.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { PSearchTableProps, PSearchTableCommands } from './PSearchTable.types';
+import { PTableItem } from '../PTable';
+interface WithForwardRefType<T = PTableItem> extends React.FC<PSearchTableProps<T>> {
+    <T = PTableItem>(props: PSearchTableProps<T> & React.RefAttributes<PSearchTableCommands<T>>): ReturnType<React.FC<PSearchTableProps<T>>>;
+}
+declare const PSearchTable: WithForwardRefType;
+export default PSearchTable;

package/dist/PSearchTable/PSearchTable.types.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { PTableProps, PTableCommands, PTableItem } from '../PTable';
+import { PFormValueMap, PSearchCommands, PSearchProps } from '@pdg/react-form';
+import { ReactNode } from 'react';
+import { PTableCommonSxProps } from '../@types';
+export interface PSearchInfo {
+    ref?: PSearchTableSearchProps['ref'];
+    searchGroups?: PSearchTableSearchProps['searchGroups'];
+    props?: Omit<PSearchTableSearchProps, 'ref' | 'searchGroups'>;
+}
+export interface PTableInfo {
+    ref?: PSearchTableTableProps['ref'];
+    props?: Omit<PSearchTableTableProps, 'ref'>;
+}
+export interface PSearchTableData<T = PTableItem> {
+    items: PTableProps<T>['items'];
+    paging?: PTableProps<T>['paging'];
+}
+export interface PSearchTableSearchProps extends Omit<PSearchProps, 'ref' | 'color' | 'autoSubmit' | 'onSubmit'> {
+    ref?: React.ForwardedRef<PSearchCommands>;
+    searchGroups?: ReactNode;
+}
+export interface PSearchTableTableProps<T = PTableItem> extends Omit<PTableProps<T>, 'ref' | 'items' | 'paging' | 'onPageChange'> {
+    ref?: React.ForwardedRef<PTableCommands<T>>;
+}
+export interface PSearchTableProps<T = PTableItem> extends PTableCommonSxProps {
+    color?: PSearchProps['color'];
+    hash?: boolean;
+    stickyHeader?: boolean;
+    fullHeight?: boolean;
+    search?: PSearchTableSearchProps;
+    table: PSearchTableTableProps<T>;
+    betweenSearchTableComponent?: ReactNode;
+    onGetData?(data: PFormValueMap): Promise<PSearchTableData<T>>;
+    onRequestHashChange?(hash: string): void;
+}
+export interface PSearchTableCommands<T = PTableItem> {
+    reload(page?: number): void;
+    getLastLoadData(): PFormValueMap;
+    getSearch(): PSearchCommands | undefined;
+    getTable(): PTableCommands<T> | undefined;
+}

package/dist/PSearchTable/index.d.ts

@@ -0,0 +1,4 @@
+import PSearchTable from './PSearchTable';
+export default PSearchTable;
+export { PSearchTable };
+export * from './PSearchTable.types';

package/dist/PTable/PTable.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { PTableProps, PTableCommands, PTableItem } from './PTable.types';
+interface WithForwardRefType<T = PTableItem> extends React.FC<PTableProps<T>> {
+    <T = PTableItem>(props: PTableProps<T> & React.RefAttributes<PTableCommands<T>>): ReturnType<React.FC<PTableProps<T>>>;
+}
+declare const PTable: WithForwardRefType;
+export default PTable;

package/dist/{Table/Table.types.d.ts → PTable/PTable.types.d.ts}

@@ -1,26 +1,26 @@
 import { CSSProperties, ReactNode } from 'react';
 import { TableCellProps, TooltipProps } from '@mui/material';
-import { TablePaginationProps } from '../TablePagination/TablePagination.types';
-import { TableCommonSxProps } from '../@types';
-import { TableTopHeadProps } from '../TableTopHead';
+import { PTablePaginationProps } from '../PTablePagination/PTablePagination.types';
+import { PTableCommonSxProps } from '../@types';
+import { PTableTopHeadProps } from '../PTableTopHead';
 /********************************************************************************************************************
- * TableItem
+ * PTableItem
  * ******************************************************************************************************************/
-export interface TableItem {
+export interface PTableItem {
     [key: string]: any;
 }
 /********************************************************************************************************************
- * TableProgressiveVisibleInfo
+ * PTableProgressiveVisibleInfo
  * ******************************************************************************************************************/
-export interface TableProgressiveVisibleInfo {
+export interface PTableProgressiveVisibleInfo {
     rowHeight: number;
     blockSize?: number;
     delay?: number;
 }
 /********************************************************************************************************************
- * TableColumn
+ * PTableColumn
  * ******************************************************************************************************************/
-export interface TableColumn<T = TableItem> {
+export interface PTableColumn<T = PTableItem> {
     id?: string;
     type?: 'text' | 'number' | 'tel' | 'date' | 'datetime' | 'date-hour' | 'date-minute' | 'business_no' | 'personal_no' | 'img' | 'button' | 'buttons' | 'check';
     label?: ReactNode;
@@ -45,33 +45,33 @@ export interface TableColumn<T = TableItem> {
     paddingLeft?: number;
     paddingRight?: number;
     head?: {
-        className?: TableCommonSxProps['className'];
-        style?: TableCommonSxProps['style'];
+        className?: PTableCommonSxProps['className'];
+        style?: PTableCommonSxProps['style'];
         backgroundColor?: CSSProperties['backgroundColor'];
-        sx?: TableCommonSxProps['sx'];
-        onGetClassName?(items?: T[]): TableCommonSxProps['className'];
-        onGetStyle?(items?: T[]): TableCommonSxProps['style'];
-        onGetSx?(items?: T[]): TableCommonSxProps['sx'];
+        sx?: PTableCommonSxProps['sx'];
+        onGetClassName?(items?: T[]): PTableCommonSxProps['className'];
+        onGetStyle?(items?: T[]): PTableCommonSxProps['style'];
+        onGetSx?(items?: T[]): PTableCommonSxProps['sx'];
         onRender?(items?: T[]): ReactNode;
     };
     footer?: {
         value?: ReactNode;
-        className?: TableCommonSxProps['className'];
-        style?: TableCommonSxProps['style'];
+        className?: PTableCommonSxProps['className'];
+        style?: PTableCommonSxProps['style'];
         backgroundColor?: CSSProperties['backgroundColor'];
-        sx?: TableCommonSxProps['sx'];
-        onGetClassName?(items?: T[]): TableCommonSxProps['className'];
-        onGetStyle?(items?: T[]): TableCommonSxProps['style'];
-        onGetSx?(items?: T[]): TableCommonSxProps['sx'];
+        sx?: PTableCommonSxProps['sx'];
+        onGetClassName?(items?: T[]): PTableCommonSxProps['className'];
+        onGetStyle?(items?: T[]): PTableCommonSxProps['style'];
+        onGetSx?(items?: T[]): PTableCommonSxProps['sx'];
         onRender?(items?: T[]): ReactNode;
     };
-    className?: TableCommonSxProps['className'];
-    style?: TableCommonSxProps['style'];
+    className?: PTableCommonSxProps['className'];
+    style?: PTableCommonSxProps['style'];
     backgroundColor?: CSSProperties['backgroundColor'];
-    sx?: TableCommonSxProps['sx'];
-    onGetClassName?(item: T, index: number): TableCommonSxProps['className'];
-    onGetStyle?(item: T, index: number): TableCommonSxProps['style'];
-    onGetSx?(item: T, index: number): TableCommonSxProps['sx'];
+    sx?: PTableCommonSxProps['sx'];
+    onGetClassName?(item: T, index: number): PTableCommonSxProps['className'];
+    onGetStyle?(item: T, index: number): PTableCommonSxProps['style'];
+    onGetSx?(item: T, index: number): PTableCommonSxProps['sx'];
     onHide?(item: T, index: number): boolean;
     onGetTooltip?(item: T, index: number): ReactNode;
     onRender?(item: T, index: number): ReactNode;
@@ -81,20 +81,20 @@ export interface TableColumn<T = TableItem> {
     onCheckChange?(item: T, checked: boolean): void;
     onCheckDisabledChange?(item: T, checkDisabled: boolean): void;
 }
-export type TableColumns<T = TableItem> = (TableColumn<T> | false | undefined | null)[];
+export type PTableColumns<T = PTableItem> = (PTableColumn<T> | false | undefined | null)[];
 /********************************************************************************************************************
  * TableProps
  * ******************************************************************************************************************/
-export interface TableProps<T = TableItem> extends TableCommonSxProps {
+export interface PTableProps<T = PTableItem> extends PTableCommonSxProps {
     caption?: ReactNode;
-    topHeadRows?: TableTopHeadProps['rows'];
-    columns?: TableColumns<T>;
+    topHeadRows?: PTableTopHeadProps['rows'];
+    columns?: PTableColumns<T>;
     defaultAlign?: TableCellProps['align'];
     defaultEllipsis?: boolean;
     stickyHeader?: boolean;
     items?: T[];
-    paging?: TablePaginationProps['paging'];
-    pagingAlign?: TablePaginationProps['align'];
+    paging?: PTablePaginationProps['paging'];
+    pagingAlign?: PTablePaginationProps['align'];
     height?: string | number;
     maxHeight?: string | number;
     minHeight?: string | number;
@@ -105,33 +105,33 @@ export interface TableProps<T = TableItem> extends TableCommonSxProps {
     footer?: boolean;
     noData?: ReactNode;
     pagination?: {
-        className?: TableCommonSxProps['className'];
-        style?: TableCommonSxProps['style'];
-        sx?: TableCommonSxProps['sx'];
+        className?: PTableCommonSxProps['className'];
+        style?: PTableCommonSxProps['style'];
+        sx?: PTableCommonSxProps['sx'];
     };
-    progressiveVisible?: TableProgressiveVisibleInfo;
+    progressiveVisible?: PTableProgressiveVisibleInfo;
     sortable?: boolean;
     onClick?(item: T, index: number): void;
-    onGetBodyRowClassName?(item: T, index: number): TableCommonSxProps['className'] | undefined;
-    onGetBodyRowStyle?(item: T, index: number): TableCommonSxProps['style'] | undefined;
-    onGetBodyRowSx?(item: T, index: number): TableCommonSxProps['sx'] | undefined;
-    onGetBodyColumnClassName?(column: TableColumn<T>, item: T, index: number): TableCommonSxProps['className'] | undefined;
-    onGetBodyColumnStyle?(column: TableColumn<T>, item: T, index: number): TableCommonSxProps['style'] | undefined;
-    onGetBodyColumnSx?(column: TableColumn<T>, item: T, index: number): TableCommonSxProps['sx'] | undefined;
+    onGetBodyRowClassName?(item: T, index: number): PTableCommonSxProps['className'] | undefined;
+    onGetBodyRowStyle?(item: T, index: number): PTableCommonSxProps['style'] | undefined;
+    onGetBodyRowSx?(item: T, index: number): PTableCommonSxProps['sx'] | undefined;
+    onGetBodyColumnClassName?(column: PTableColumn<T>, item: T, index: number): PTableCommonSxProps['className'] | undefined;
+    onGetBodyColumnStyle?(column: PTableColumn<T>, item: T, index: number): PTableCommonSxProps['style'] | undefined;
+    onGetBodyColumnSx?(column: PTableColumn<T>, item: T, index: number): PTableCommonSxProps['sx'] | undefined;
     onPageChange?(page: number): void;
     onSortChange?(items: T[]): void;
     onCheckChange?(columnId: string, items: T[]): void;
 }
 /********************************************************************************************************************
- * TableCommands
+ * PTableCommands
  * ******************************************************************************************************************/
-export interface TableCommands<T = TableItem> {
-    getColumns(): TableProps<T>['columns'];
-    setColumns(columns: TableProps<T>['columns']): void;
-    getItems(): TableProps<T>['items'];
-    setItems(items: TableProps<T>['items']): void;
-    getPaging(): TableProps<T>['paging'];
-    setItemsPaging(items: TableProps<T>['items'], paging: TableProps<T>['paging']): void;
+export interface PTableCommands<T = PTableItem> {
+    getColumns(): PTableProps<T>['columns'];
+    setColumns(columns: PTableProps<T>['columns']): void;
+    getItems(): PTableProps<T>['items'];
+    setItems(items: PTableProps<T>['items']): void;
+    getPaging(): PTableProps<T>['paging'];
+    setItemsPaging(items: PTableProps<T>['items'], paging: PTableProps<T>['paging']): void;
     resetSort(): void;
     getCheckedItems(columnId: string): T[];
     getChecked(itemKey: string, itemValue: any, columnId: string): boolean;

package/dist/PTable/index.d.ts

@@ -0,0 +1,4 @@
+import PTable from './PTable';
+export default PTable;
+export { PTable };
+export * from './PTable.types';

package/dist/PTableBodyRow/PTableBodyRow.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { PTableBodyRowProps as Props } from './PTableBodyRow.types';
+export declare const PStyledBodyRow: import("@emotion/styled").StyledComponent<import("@mui/material").TableRowOwnProps & import("@mui/material/OverridableComponent").CommonProps & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "className" | "style" | "classes" | "children" | "hover" | "selected" | "sx"> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
+declare const PTableBodyRow: React.FC<Props>;
+export default PTableBodyRow;

package/dist/PTableBodyRow/PTableBodyRow.types.d.ts

@@ -0,0 +1,18 @@
+import { TableCellProps, TableRowProps } from '@mui/material';
+import { PTableColumn, PTableItem, PTableProps } from '../PTable';
+import { PTableBodyCellProps } from '../TableBodyCell';
+import { PTableCommonSxProps } from '../@types';
+export interface PTableBodyRowProps extends Omit<TableRowProps, 'id' | 'onClick'> {
+    id: string | number;
+    index: number;
+    defaultAlign?: TableCellProps['align'];
+    defaultEllipsis?: boolean;
+    sortable?: boolean;
+    columns: PTableColumn[];
+    item: PTableItem;
+    onClick: PTableProps['onClick'];
+    onCheckChange: PTableBodyCellProps['onCheckChange'];
+    onGetColumnClassName?(column: PTableColumn, item: PTableItem, index: number): PTableCommonSxProps['className'] | undefined;
+    onGetColumnStyle?(column: PTableColumn, item: PTableItem, index: number): PTableCommonSxProps['style'] | undefined;
+    onGetColumnSx?(column: PTableColumn, item: PTableItem, index: number): PTableCommonSxProps['sx'] | undefined;
+}

package/dist/PTableBodyRow/index.d.ts

@@ -0,0 +1,4 @@
+import PTableBodyRow from './PTableBodyRow';
+export default PTableBodyRow;
+export { PTableBodyRow };
+export * from './PTableBodyRow.types';

package/dist/{TableButton/TableButton.d.ts → PTableButton/PTableButton.d.ts}

@@ -1,4 +1,4 @@
 import React from 'react';
-import { TableButtonProps as Props } from './TableButton.types';
+import { PTableButtonProps as Props } from './PTableButton.types';
 declare const _default: React.NamedExoticComponent<Props & React.RefAttributes<HTMLButtonElement>>;
 export default _default;

package/dist/PTableButton/PTableButton.types.d.ts

@@ -0,0 +1,3 @@
+import { PButtonProps } from '@pdg/react-component';
+export interface PTableButtonProps extends Omit<PButtonProps, 'size'> {
+}

package/dist/PTableButton/index.d.ts

@@ -0,0 +1,4 @@
+import PTableButton from './PTableButton';
+export default PTableButton;
+export { PTableButton };
+export * from './PTableButton.types';

package/dist/PTableCommonCell/PTableCommonCell.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableCommonCellProps } from './PTableCommonCell.types';
+declare const PTableCommonCell: React.ForwardRefExoticComponent<PTableCommonCellProps & React.RefAttributes<HTMLTableCellElement>>;
+export default PTableCommonCell;

package/dist/PTableCommonCell/PTableCommonCell.types.d.ts

@@ -0,0 +1,11 @@
+import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+import { PTableCommonSxProps } from '../@types';
+export interface PTableCommonCellProps extends PTableCommonSxProps {
+    type: 'head' | 'body' | 'footer';
+    column: PTableColumn;
+    defaultAlign?: PTableProps['defaultAlign'];
+    defaultEllipsis?: boolean;
+    index?: number;
+    item?: PTableItem;
+    onClick?: PTableProps['onClick'];
+}

package/dist/PTableCommonCell/index.d.ts

@@ -0,0 +1,4 @@
+import PTableCommonCell from './PTableCommonCell';
+export default PTableCommonCell;
+export { PTableCommonCell };
+export * from './PTableCommonCell.types';

package/dist/PTableContext/PTableContext.d.ts

@@ -0,0 +1,3 @@
+import { PTableContextValue } from './PTableContext.types';
+declare const PTableContext: import("react").Context<PTableContextValue>;
+export default PTableContext;

package/dist/PTableContext/PTableContext.types.d.ts

@@ -0,0 +1,15 @@
+import { PTableColumn, PTableItem, PTableProgressiveVisibleInfo } from '../PTable';
+import { PTableBodyCellCommands } from '../TableBodyCell';
+import { PTableHeadCellCommands } from '../PTableHeadCell';
+export interface PTableContextValue {
+    menuOpen: boolean;
+    openMenuId?: string;
+    progressiveVisible?: PTableProgressiveVisibleInfo;
+    setMenuOpen(menuOpen: boolean, openMenuId?: string): void;
+    setItemColumnChecked(item: PTableItem, column: PTableColumn, checked: boolean): void;
+    setItemColumnCheckDisabled(item: PTableItem, column: PTableColumn, checkDisabled: boolean): void;
+    setItemColumnCommands(item: PTableItem, column: PTableColumn, commands: PTableBodyCellCommands): void;
+    setHeadColumnChecked(column: PTableColumn, checked: boolean): void;
+    setHeadColumnCommands(column: PTableColumn, commands: PTableHeadCellCommands): void;
+}
+export declare const PTableContextDefaultValue: PTableContextValue;

package/dist/PTableContext/index.d.ts

@@ -0,0 +1,5 @@
+import PTableContext from './PTableContext';
+export default PTableContext;
+export { PTableContext };
+export * from './PTableContext.types';
+export { default as useFormState } from './useTableState';

package/dist/PTableContext/useTableState.d.ts

@@ -0,0 +1,2 @@
+import { PTableContextValue } from './PTableContext.types';
+export default function useTableState(): PTableContextValue;

package/dist/PTableContextProvider/PTableContextProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableContextProviderProps as Props } from './PTableContextProvider.types';
+declare const PTableContextProvider: React.FC<Props>;
+export default PTableContextProvider;

package/dist/PTableContextProvider/PTableContextProvider.types.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { PTableContextValue } from '../PTableContext';
+export interface PTableContextProviderProps {
+    value: PTableContextValue;
+    children: ReactNode;
+}

package/dist/PTableContextProvider/index.d.ts

@@ -0,0 +1,4 @@
+import PTableContextProvider from './PTableContextProvider';
+export default PTableContextProvider;
+export { PTableContextProvider };
+export * from './PTableContextProvider.types';

package/dist/PTableFooterCell/PTableFooterCell.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableFooterCellProps } from './PTableFooterCell.types';
+declare const PTableFooterCell: React.FC<PTableFooterCellProps>;
+export default PTableFooterCell;

package/dist/PTableFooterCell/PTableFooterCell.types.d.ts

@@ -0,0 +1,6 @@
+import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+export interface PTableFooterCellProps<T = PTableItem> {
+    column: PTableColumn;
+    items?: T[];
+    defaultAlign?: PTableProps['defaultAlign'];
+}

package/dist/PTableFooterCell/index.d.ts

@@ -0,0 +1,4 @@
+import PTableFooterCell from './PTableFooterCell';
+export default PTableFooterCell;
+export { PTableFooterCell };
+export * from './PTableFooterCell.types';

package/dist/PTableHeadCell/PTableHeadCell.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableHeadCellProps } from './PTableHeadCell.types';
+declare const PTableHeadCell: React.FC<PTableHeadCellProps>;
+export default PTableHeadCell;

package/dist/PTableHeadCell/PTableHeadCell.types.d.ts

@@ -0,0 +1,12 @@
+import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+export interface PTableHeadCellCommands {
+    setChecked(checked: boolean): void;
+    setCheckDisabled(checkDisabled: boolean): void;
+}
+export interface PTableHeadCellProps<T = PTableItem> {
+    column: PTableColumn;
+    items?: T[];
+    defaultAlign?: PTableProps['defaultAlign'];
+    top?: number;
+    onCheckChange(column: PTableColumn, checked: boolean): void;
+}

package/dist/PTableHeadCell/index.d.ts

@@ -0,0 +1,4 @@
+import PTableHeadCell from './PTableHeadCell';
+export default PTableHeadCell;
+export { PTableHeadCell };
+export * from './PTableHeadCell.types';

package/dist/PTableMenuButton/PTableMenuButton.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableMenuButtonProps as Props } from './PTableMenuButton.types';
+declare const PTableMenuButton: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLButtonElement>>;
+export default PTableMenuButton;

package/dist/{TableMenuButton/TableMenuButton.types.d.ts → PTableMenuButton/PTableMenuButton.types.d.ts}

@@ -1,7 +1,7 @@
 import { ReactElement } from 'react';
-import { PdgButtonProps } from '@pdg/react-component';
+import { PButtonProps } from '@pdg/react-component';
 import { PopperPlacementType, MenuListProps } from '@mui/material';
-export interface TableMenuButtonProps extends Omit<PdgButtonProps, 'size' | 'onClick'> {
+export interface PTableMenuButtonProps extends Omit<PButtonProps, 'size' | 'onClick'> {
     placement?: PopperPlacementType;
     inModal?: boolean;
     zIndex?: number;

package/dist/PTableMenuButton/index.d.ts

@@ -0,0 +1,4 @@
+import PTableMenuButton from './PTableMenuButton';
+export default PTableMenuButton;
+export { PTableMenuButton };
+export * from './PTableMenuButton.types';

package/dist/PTablePagination/PTablePagination.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTablePaginationProps } from './PTablePagination.types';
+declare const PTablePagination: React.FC<PTablePaginationProps>;
+export default PTablePagination;

package/dist/PTablePagination/PTablePagination.types.d.ts

@@ -0,0 +1,13 @@
+import { StackProps } from '@mui/material';
+import { PTableCommonSxProps } from '../@types';
+export interface PTablePaging {
+    current_page: number;
+    per_page: number;
+    last_page: number;
+    total: number;
+}
+export interface PTablePaginationProps extends Pick<PTableCommonSxProps, 'className' | 'style' | 'sx'> {
+    paging: PTablePaging;
+    align?: StackProps['alignItems'];
+    onChange?(page: number): void;
+}

package/dist/PTablePagination/index.d.ts

@@ -0,0 +1,4 @@
+import PTablePagination from './PTablePagination';
+export default PTablePagination;
+export { PTablePagination };
+export * from './PTablePagination.types';

package/dist/PTableSortableBody/PTableSortableBody.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableSortableBodyProps as Props } from './PTableSortableBody.types';
+export declare const PTableSortableBody: ({ items, columns, showOddColor, showEvenColor, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyRowClassName, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, defaultAlign, defaultEllipsis, sortable, onClick, onCheckChange, }: Props) => React.JSX.Element;
+export default PTableSortableBody;

package/dist/PTableSortableBody/PTableSortableBody.types.d.ts

@@ -0,0 +1,8 @@
+import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+import { PTableBodyRowProps } from '../PTableBodyRow';
+export interface PTableSortableBodyProps extends Pick<PTableProps, 'showOddColor' | 'showEvenColor' | 'onGetBodyRowSx' | 'onGetBodyRowClassName' | 'onGetBodyRowStyle' | 'onGetBodyColumnClassName' | 'onGetBodyColumnSx' | 'onGetBodyColumnStyle' | 'defaultAlign' | 'defaultEllipsis' | 'sortable' | 'onClick'>, Pick<PTableBodyRowProps, 'onCheckChange'> {
+    items: (PTableItem & {
+        id: number | string;
+    })[];
+    columns: PTableColumn[];
+}

package/dist/PTableSortableBody/index.d.ts

@@ -0,0 +1,4 @@
+import PTableSortableBody from './PTableSortableBody';
+export default PTableSortableBody;
+export { PTableSortableBody };
+export * from './PTableSortableBody.types';

package/dist/PTableSortableBodyBlock/PTableSortableBodyBlock.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PTableSortableBodyBlockProps as Props } from './PTableSortableBodyBlock.types';
+export declare const PTableSortableBodyBlock: ({ items, baseIndex, columns, showOddColor, showEvenColor, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyRowClassName, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, defaultAlign, defaultEllipsis, sortable, onClick, onCheckChange, }: Props) => React.JSX.Element;
+export default PTableSortableBodyBlock;