argous 1.2.134 → 1.2.135

package/dist/components/ArgousComplexTable/ArgousComplexTable.d.ts

@@ -0,0 +1,131 @@
+import { ArgousComplexPaginationPrivateProps, ArgousComplexPaginationProps } from '../ArgousComplexPagination/ArgousComplexPagination';
+import { ArgousComplexTableBodyPrivateProps, ArgousComplexTableBodyProps } from '../ArgousComplexTableBody/ArgousComplexTableBody';
+import { ArgousComplexTableHeadPrivateProps, ArgousComplexTableHeadProps } from '../ArgousComplexTableHead/ArgousComplexTableHead';
+import { ArgousComplexTableToolBarPrivateProps, ArgousComplexTableToolBarProps } from '../ArgousComplexTableToolbar/ArgousComplexTableToolBar';
+import { TableContainerProps, TableProps } from '@material-ui/core';
+import React from 'react';
+
+export interface ArgousComplexTableProps extends ArgousComplexTableBodyProps, ArgousComplexPaginationProps, ArgousComplexPaginationProps, ArgousComplexTableHeadProps, ArgousComplexTableToolBarProps {
+  /**
+   * Componente para substituir a Toolbar padrão
+   */ 
+  ToolbarComponent?: (props: ArgousComplexTableToolBarPrivateProps) => JSX.Element,
+  /**
+   * Componente para substituir o Header padrão
+   */ 
+  HeadComponent?: (props: ArgousComplexTableHeadPrivateProps) => JSX.Element,
+  /**
+   * Componente para substituir o Body padrão
+   */ 
+  BodyComponent?: (props: ArgousComplexTableBodyPrivateProps) => JSX.Element,
+  /**
+   * Componente para substituir a pagination padrão
+   */ 
+  PaginationComponent?: (props: ArgousComplexPaginationPrivateProps) => JSX.Element,
+  /**
+   * Adiciona um Footer à tabela
+   */ 
+  FooterComponent?: React.ReactNode,
+  /**
+   * Props repassados ao componente de footer
+   */ 
+  footerProps?: object,
+  /**
+   * Array de dados fornecido paa a tabela
+   */ 
+  dados?: Array<Array<any> | Object>,
+  /**
+   * Número de linhas padrão por página
+   */ 
+  defaultRowsPerPage?: number,
+  /**
+   * Estilos aplicados à tabela
+   */ 
+  style?: React.CSSProperties,
+  /**
+   * Classes aplicadas à tabela
+   */ 
+  className?: string,
+  /**
+   * Tamanho da tabela
+   */ 
+  size?: 'small' | 'normal',
+  /**
+   * Função chamada ao abrir um item
+   * 
+   * @param linhaOriginal - Linha original 
+   * @param linhaFormatada - Linha formatada
+   * 
+   * @returns {void} Sem retorno
+   */ 
+  onOpen?: (linhaOriginal: Array<any> | object, linhaFormatada: Array<any>) => void,
+  /**
+   * Função chamada ao fechar um item
+   * 
+   * @param linhaOriginal - Linha original 
+   * @param linhaFormatada - Linha formatada
+   * 
+   * @returns {void} Sem retorno
+   */ 
+  onClose?: (linhaOriginal: Array<any> | object, linhaFormatada: Array<any>) => void,
+  /**
+   * Nome de metódo utilizando o padrão de caminhador argous para prover os dados para a tabela
+   */ 
+  method?: string,
+  /**
+   * Objeto de parâmetros passados para o método
+   */ 
+  methodPrms?: object,
+  /**
+   * Nome da chave do objeto de resposta do método (lista por padrão)
+   */ 
+  methodResultList?: string,
+  /**
+   * Função chamada apos o metodo receber uma resposta 
+   * 
+   * @param response - Resposta
+   * 
+   * @returns {void} Sem retorno
+   */
+  onMethodResponse?: (response: Object) => void,
+  /**
+   * @deprecated
+   * 
+   * Field contendo os dados a serem providos para a tabela
+   */ 
+  field?: string,
+  /**
+   * Função que é chamada sempre que os itens selecionados mudam
+   * 
+   * @param itensSelecionados - Array com os itens selecionados
+   * 
+   * @returns {void} Sem retorno
+   */ 
+  onSelect?: (itensSelecionados: Array<any>) => void,
+  /**
+   * Referência utilizada para salvar o estado da tabela quando ela é descarregada
+   */ 
+  //TODO criar interface para o savedstate
+  savedState?: React.RefObject<any>,
+  /**
+   * Referencia passada ao componente
+   */
+  //TODO criar interface para a referencia
+  ref?: React.RefObject<any>,
+  /**
+   * Props repassados ao componente container
+   */
+  containerProps?: TableContainerProps,
+  /**
+   * Props repassados ao componente table
+   */
+  tableProps?: TableProps,
+  /**
+   * Props repassados ao toolbar
+   */
+  toolbarProps?: any
+}
+
+declare function ArgousComplexTable(props: ArgousComplexTableProps): JSX.Element
+
+export default ArgousComplexTable;

package/dist/components/ArgousComplexTable/ArgousComplexTable.js

@@ -0,0 +1,333 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableContext = void 0;
+var __1 = require("../");
+var fieldsRedux_1 = require("../../fieldsRedux");
+var api_1 = require("../../utils/api");
+var core_1 = require("@material-ui/core");
+var clsx_1 = __importDefault(require("clsx"));
+var lodash_1 = require("lodash");
+var moment_1 = __importDefault(require("moment"));
+var prop_types_1 = __importDefault(require("prop-types"));
+var react_1 = __importStar(require("react"));
+var useStyles = core_1.makeStyles({
+    root: {
+        '& [class*="smooth-dnd-container"]': {
+            display: 'table-row-group'
+        },
+        '& [class*="smooth-dnd-draggable-wrapper"]': {
+            display: 'table-row !important'
+        }
+    }
+});
+exports.TableContext = react_1.createContext();
+var ehData = function (valor) {
+    var retorno = function (format) { return moment_1.default(valor, format).format('YYYYMMDDHHmmss'); };
+    if (/[0-9]{2}\/[0-9]{2}\/[0-9]{4}/.test(valor))
+        return retorno('DD/MM/YYYY');
+    if (/\d{2}\/\d{2}\/\d{4} \d{2}:\d{2}/.test(valor))
+        return retorno('DD/MM/YYYY HH:mm');
+    if (/\d{2}\/\d{2}\/\d{4} \d{2}:\d{2}:\d{2}/.test(valor))
+        return retorno('DD/MM/YYYY HH:mm:ss');
+    if (/\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(.\d)*/.test(valor))
+        return retorno('YYYY-MM-DD HH:mm:ss');
+    return valor;
+};
+function descendingComparator(a, b, orderBy) {
+    var aO = ehData(a[orderBy]);
+    var bO = ehData(b[orderBy]);
+    if (bO < aO)
+        return -1;
+    if (bO > aO)
+        return 1;
+    return 0;
+}
+function getComparator(order, orderBy) {
+    return order === 'desc'
+        ? function (a, b) { return descendingComparator(a, b, orderBy); }
+        : function (a, b) { return -descendingComparator(a, b, orderBy); };
+}
+function stableSort(array, comparator, line) {
+    var stabilizedThis = array.map(function (el, index) { return [el, line(el), index]; });
+    stabilizedThis.sort(function (a, b) {
+        var order = comparator(a[1], b[1]);
+        if (order !== 0)
+            return order;
+        return a[2] - b[2];
+    });
+    return stabilizedThis.map(function (el) { return el[0]; });
+}
+var reducer = function (state, action) {
+    switch (action.type) {
+        case 'setSelected':
+            return __assign(__assign({}, state), { selected: action.value });
+        case 'setPage':
+            return __assign(__assign({}, state), { page: action.value });
+        case 'decremmentPage':
+            return __assign(__assign({}, state), { page: state.page === 0 ? 0 : state.page - 1 });
+        case 'setRowsPerPage':
+            return __assign(__assign({}, state), { rowsPerPage: action.value });
+        case 'setOrder':
+            return __assign(__assign({}, state), { order: action.value });
+        case 'setOrderBy':
+            return __assign(__assign({}, state), { orderBy: action.value });
+        case 'setFilter':
+            return __assign(__assign({}, state), { filter: action.value });
+        case 'setOpen':
+            return __assign(__assign({}, state), { open: action.value });
+        case 'setLoading':
+            return __assign(__assign({}, state), { loading: action.value });
+        case 'mount':
+            if (!action.value)
+                return state;
+            return action.value;
+        default:
+            return state;
+    }
+};
+var initialState = function (defaultRowsPerPage) { return ({
+    selected: [],
+    page: 0,
+    rowsPerPage: defaultRowsPerPage,
+    order: 'asc',
+    orderBy: -1,
+    filter: '',
+    open: undefined,
+    loading: false
+}); };
+var ArgousComplexTable = react_1.forwardRef(function (_a, ref) {
+    var _b = _a.ToolbarComponent, ToolbarComponent = _b === void 0 ? __1.ArgousComplexTableToolbar : _b, _c = _a.HeadComponent, HeadComponent = _c === void 0 ? __1.ArgousComplexTableHead : _c, _d = _a.BodyComponent, BodyComponent = _d === void 0 ? __1.ArgousComplexTableBody : _d, _e = _a.PaginationComponent, PaginationComponent = _e === void 0 ? __1.ArgousComplexPagination : _e, _f = _a.FooterComponent, FooterComponent = _f === void 0 ? undefined : _f, footerProps = _a.footerProps, dados = _a.dados, _g = _a.head, head = _g === void 0 ? [] : _g, _h = _a.line, line = _h === void 0 ? function (i) { return i; } : _h, actions = _a.actions, title = _a.title, _j = _a.defaultRowsPerPage, defaultRowsPerPage = _j === void 0 ? 10 : _j, _k = _a.rowsPerPageOptions, rowsPerPageOptions = _k === void 0 ? [10, 25, 50] : _k, checkEnabled = _a.enableCheck, disableCheckIf = _a.disableCheckIf, showCount = _a.showCount, lineStyle = _a.lineStyle, _l = _a.lineClass, lineClass = _l === void 0 ? function () { return undefined; } : _l, onClick = _a.onClick, onDoubleClick = _a.onDoubleClick, _m = _a.children, children = _m === void 0 ? undefined : _m, style = _a.style, className = _a.className, columnStyles = _a.columnStyles, headerColumnStyles = _a.headerColumnStyles, columnOptions = _a.columnOptions, disableFilter = _a.disableFilter, _o = _a.filterLabel, filterLabel = _o === void 0 ? 'Filtro' : _o, _p = _a.indexToSelect, indexToSelect = _p === void 0 ? 0 : _p, _q = _a.disableSorting, disableSorting = _q === void 0 ? [] : _q, _r = _a.size, size = _r === void 0 ? 'small' : _r, onOpen = _a.onOpen, lineTitle = _a.lineTitle, onClose = _a.onClose, method = _a.method, methodPrms = _a.methodPrms, _s = _a.methodResultList, methodResultList = _s === void 0 ? 'lista' : _s, onMethodResponse = _a.onMethodResponse, field = _a.field, fixedToolbar = _a.fixedToolbar, onSelect = _a.onSelect, customKey = _a.customKey, _t = _a.columnProps, columnProps = _t === void 0 ? function () { return ''; } : _t, _u = _a.rowProps, rowProps = _u === void 0 ? function () { return ''; } : _u, _v = _a.savedState, savedState = _v === void 0 ? {} : _v, containerProps = _a.containerProps, _w = _a.onClickAway, onClickAway = _w === void 0 ? function () { return undefined; } : _w, enableCheckIfSelected = _a.enableCheckIfSelected, enableDrag = _a.enableDrag, onDrop = _a.onDrop, tableProps = _a.tableProps, toolbarProps = _a.toolbarProps;
+    var classes = useStyles();
+    var _x = react_1.useReducer(reducer, initialState(defaultRowsPerPage)), state = _x[0], dispatch = _x[1];
+    var memoState = react_1.useMemo(function () { return (__assign(__assign({}, state), { dispatch: dispatch })); }, [state, dispatch]);
+    var selected = memoState.selected, page = memoState.page, rowsPerPage = memoState.rowsPerPage, order = memoState.order, orderBy = memoState.orderBy, filter = memoState.filter, open = memoState.open;
+    var _y = react_1.useState(dados /*.map(linha => isArray(linha) ? linha : Object.values(linha))*/ || []), lista = _y[0], setLista = _y[1];
+    var _z = react_1.useState({ qtRegs: defaultRowsPerPage, pgAtl: 1 }), ctrlPgn = _z[0], setCtrlPgn = _z[1];
+    var qtRegs = ctrlPgn.qtRegs, pgAtl = ctrlPgn.pgAtl, ordCols = ctrlPgn.ordCols;
+    var enableCheck = checkEnabled || (enableCheckIfSelected && !!selected.length);
+    react_1.useEffect(function () {
+        dispatch({ type: 'mount', value: savedState.current });
+    }, []);
+    react_1.useEffect(function () {
+        return function () { return savedState.current = state; };
+    }, [state]);
+    react_1.useEffect(function () {
+        if (lodash_1.isArray(dados))
+            setLista(dados /*.map(linha => isArray(linha) ? linha : Object.values(linha))*/ || []);
+    }, [dados]);
+    var retornaAcao = react_1.useCallback(function (pgAtl, page) {
+        if (page === pgAtl)
+            return undefined;
+        else if (page === pgAtl + 1)
+            return 'N';
+        else if (page === pgAtl - 1)
+            return 'P';
+        else if (page === ctrlPgn.recordCount)
+            return 'L';
+        else if (page === 0)
+            return 'F';
+        return "S=" + page;
+    }, [ctrlPgn.recordCount]);
+    var buscaMetodo = react_1.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        var _a, _b, _c, _d, _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    if (!method)
+                        return [2 /*return*/];
+                    dispatch({ type: 'setLoading', value: true });
+                    return [4 /*yield*/, api_1.serverAction(method, __assign({ ctrlPgn: {
+                                qtRegs: qtRegs, pgAtl: pgAtl,
+                                acao: retornaAcao(ctrlPgn.pgAtl, page + 1),
+                                tpOrdem: orderBy >= 0 ? (order === 'asc' ? 'A' : 'D') : undefined,
+                                indOrdem: orderBy >= 0 ? orderBy : undefined
+                            } }, methodPrms), true)];
+                case 1:
+                    res = _g.sent();
+                    onMethodResponse && onMethodResponse(res);
+                    if (res.status) {
+                        setCtrlPgn(__assign(__assign({}, res.ctrlPgn), { recordCount: ((_a = res.ctrlPgn) === null || _a === void 0 ? void 0 : _a.recordCount) || ((_b = res[methodResultList]) === null || _b === void 0 ? void 0 : _b.length) < ((_c = res.ctrlPgn) === null || _c === void 0 ? void 0 : _c.qtRegs) ? (_d = res[methodResultList]) === null || _d === void 0 ? void 0 : _d.length : ((_e = res.ctrlPgn) === null || _e === void 0 ? void 0 : _e.qtPaginas) * ((_f = res.ctrlPgn) === null || _f === void 0 ? void 0 : _f.qtRegs) }));
+                        setLista(res[methodResultList] || []);
+                    }
+                    dispatch({ type: 'setLoading', value: false });
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [method, qtRegs, pgAtl, order, orderBy, retornaAcao, ctrlPgn.pgAtl, page, methodPrms, methodResultList]);
+    react_1.useEffect(function () {
+        buscaMetodo();
+    }, [buscaMetodo]);
+    var fielValue = react_1.useMemo(function () { /*isArray(getField(field, 'value')) ? */ return fieldsRedux_1.getField(field, 'value'); } /*?.map(item => isArray(item) ? item : Object.values(item)) : []*/, [field]);
+    react_1.useEffect(function () {
+        if (field && !lodash_1.isEqual(lista, fielValue))
+            setLista(fielValue || []);
+    }, [field, lista, fielValue]);
+    react_1.useEffect(function () {
+        if (method || field)
+            return;
+        if (lodash_1.isArray(lista) && lista.length > 0 && page === Math.ceil(method ? ctrlPgn.recordCount : lista.length / parseInt(rowsPerPage, 10)))
+            dispatch({ type: 'decremmentPage' });
+    }, [page, method, lista.length, rowsPerPage, ctrlPgn.recordCount, lista, field]);
+    react_1.useEffect(function () { return dispatch({ type: 'setSelected', value: [] }); }, [lista]);
+    react_1.useEffect(function () {
+        if (onSelect)
+            onSelect(selected);
+    }, [selected]);
+    var dadosNaoCortados = react_1.useMemo(function () {
+        if (method)
+            return lista || [];
+        if (lodash_1.isArray(lista) && lista.length > 0)
+            return stableSort(lista, getComparator(order, orderBy), line)
+                .filter(function (linha) { return lodash_1.isArray(line(linha)) ? line(linha).filter(function (item) { return filter ? new RegExp(".*" + filter + ".*", 'gi').test(item === null || item === void 0 ? void 0 : item.toString()) : true; }).length > 0 : true; }) || [];
+        return [];
+    }, [lista, filter, order, orderBy, method, line]);
+    var cortaDados = react_1.useCallback(function (dados) { return dados === null || dados === void 0 ? void 0 : dados.slice(defaultRowsPerPage === 0 ? (undefined) : page * rowsPerPage, defaultRowsPerPage === 0 ? (undefined) : page * rowsPerPage + rowsPerPage); }, [page, rowsPerPage, defaultRowsPerPage]);
+    var dadosMostrados = react_1.useMemo(function () {
+        if (method)
+            return lista || [];
+        return cortaDados(dadosNaoCortados) || [];
+    }, [method, lista, dadosNaoCortados, cortaDados]);
+    var handleOpenClose = react_1.useCallback(function (index) {
+        if (index === open || (!index && index !== 0)) {
+            dispatch({ type: 'setOpen', value: undefined });
+            if (onClose && (index || open))
+                onClose({ linhaOriginal: dadosMostrados[index || open], linhaFormatada: line(dadosMostrados[index || open]) });
+        }
+        else {
+            dispatch({ type: 'setOpen', value: index });
+            if (onOpen)
+                onOpen({ linhaOriginal: dadosMostrados[index], linhaFormatada: line(dadosMostrados[index]) });
+        }
+    }, [open, onClose, onOpen, dadosMostrados, dispatch, line]);
+    react_1.useImperativeHandle(ref, function () { return ({
+        setOpen: function (index) { return handleOpenClose(index); },
+        getOpen: dadosMostrados[open],
+        getSelected: selected,
+        setSelected: function (s) { return dispatch({ type: 'setSelected', value: lodash_1.isFunction(s) ? s(selected, dadosMostrados) : s }); },
+        setLoading: function (value) { return dispatch({ type: 'setLoading', value: value }); }
+    }); });
+    return (react_1.default.createElement(exports.TableContext.Provider, { value: __assign(__assign({}, memoState), { dadosMostrados: dadosMostrados, lista: lista, indexToSelect: indexToSelect, method: method }) },
+        react_1.default.createElement(core_1.ClickAwayListener, { onClickAway: onClickAway },
+            react_1.default.createElement(core_1.TableContainer, __assign({ component: core_1.Paper, variant: 'outlined', style: style }, containerProps, { className: clsx_1.default(classes.root, className) }),
+                react_1.default.createElement(ToolbarComponent, __assign({ numSelected: selected.length, disableFilter: disableFilter || !!method }, __assign({ actions: actions, title: title, selected: selected, filter: filter, filterLabel: filterLabel, lista: lista, indexToSelect: indexToSelect, fixedToolbar: fixedToolbar }, toolbarProps))),
+                react_1.default.createElement(core_1.Table, __assign({}, __assign(__assign({}, tableProps), { size: size })),
+                    react_1.default.createElement(HeadComponent, __assign({ size: method ? ctrlPgn.recordCount : dadosNaoCortados.length, numSelected: selected.length, rowCount: (rowsPerPage > (method ? ctrlPgn.recordCount : dadosNaoCortados.length)) ? method ? ctrlPgn.recordCount : dadosNaoCortados.length : rowsPerPage || dadosNaoCortados.length }, { head: head, order: order, orderBy: orderBy, enableCheck: enableCheck, headerColumnStyles: headerColumnStyles, disableSorting: disableSorting, ordCols: ordCols, method: method, cortaDados: cortaDados, disableCheckIf: disableCheckIf, line: line, enableDrag: enableDrag })),
+                    react_1.default.createElement(BodyComponent, __assign({}, {
+                        children: children, line: line, lineStyle: lineStyle, lineTitle: lineTitle, handleOpenClose: handleOpenClose, lineClass: lineClass, enableDrag: enableDrag,
+                        enableCheck: enableCheck, columnStyles: columnStyles, head: head, columnOptions: columnOptions, columnProps: columnProps, rowProps: rowProps, onDrop: onDrop,
+                        onClick: onClick, onDoubleClick: onDoubleClick, indexToSelect: indexToSelect, open: open, dadosMostrados: dadosMostrados, customKey: customKey, disableCheckIf: disableCheckIf
+                    })),
+                    FooterComponent && react_1.default.createElement(FooterComponent, __assign({}, footerProps))),
+                rowsPerPageOptions !== 0 && Math.ceil(method ? ctrlPgn.recordCount : dadosNaoCortados.length / parseInt(rowsPerPageOptions[0], 10)) > 1 && (react_1.default.createElement(PaginationComponent, __assign({ count: method ? ctrlPgn.recordCount : dadosNaoCortados.length, onChangePage: function (_, value) {
+                        dispatch({ type: 'setPage', value: value });
+                        setCtrlPgn(__assign(__assign({}, ctrlPgn), { pgAtl: value + 1 }));
+                    }, onChangeRowsPerPage: function (e) {
+                        dispatch({ type: 'setRowsPerPage', value: parseInt(e.target.value, 10) });
+                        dispatch({ type: 'setPage', value: 0 });
+                        setCtrlPgn(__assign(__assign({}, ctrlPgn), { pgAtl: 1, qtRegs: parseInt(e.target.value, 10) }));
+                    } }, { showCount: showCount, page: page, rowsPerPageOptions: rowsPerPageOptions, rowsPerPage: rowsPerPage })))))));
+});
+ArgousComplexTable.propTypes = {
+    dados: prop_types_1.default.array,
+    head: prop_types_1.default.array,
+    line: prop_types_1.default.func,
+    actions: prop_types_1.default.array,
+    title: prop_types_1.default.string,
+    defaultRowsPerPage: prop_types_1.default.number,
+    rowsPerPageOptions: prop_types_1.default.oneOfType([prop_types_1.default.array, prop_types_1.default.oneOf([0])]),
+    enableCheck: prop_types_1.default.bool,
+    showCount: prop_types_1.default.bool,
+    lineStyle: prop_types_1.default.func,
+    lineTitle: prop_types_1.default.string,
+    lineClass: prop_types_1.default.func,
+    onClick: prop_types_1.default.func,
+    children: prop_types_1.default.func,
+    style: prop_types_1.default.object,
+    className: prop_types_1.default.string,
+    columnStyles: prop_types_1.default.array,
+    headerColumnStyles: prop_types_1.default.array,
+    columnOptions: prop_types_1.default.array,
+    disableFilter: prop_types_1.default.bool,
+    filterLabel: prop_types_1.default.string,
+    indexToSelect: prop_types_1.default.number,
+    disableSorting: prop_types_1.default.array,
+    size: prop_types_1.default.oneOf(['small', 'normal']),
+    onOpen: prop_types_1.default.func,
+    onClose: prop_types_1.default.func,
+    method: prop_types_1.default.string,
+    methodPrms: prop_types_1.default.object,
+    field: prop_types_1.default.string,
+    fixedToolbar: prop_types_1.default.bool,
+    onSelect: prop_types_1.default.func
+};
+exports.default = react_1.memo(ArgousComplexTable, lodash_1.isEqual);

package/dist/components/ArgousComplexTable/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ArgousComplexTable';
+export * from './ArgousComplexTable'; 

package/dist/components/ArgousComplexTable/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var ArgousComplexTable_1 = require("./ArgousComplexTable");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(ArgousComplexTable_1).default; } });

package/dist/components/ArgousComplexTableBody/ArgousComplexTableBody.d.ts

@@ -0,0 +1,177 @@
+import { TableCellBaseProps, TableRowProps } from '@material-ui/core';
+import * as React from 'react';
+
+export declare interface ChildrenFunction {
+  /**
+   * Função sera executada quando for clicado em alguma linha, seu retorno aparecerá abaixo da linha clicada
+   * 
+   * @param linhaOriginal - Linha original, antes de ser formatada pela função line
+   * @param linha - Linha ja formatada pela função line
+   * @param index - Índice da linha
+   * 
+   * @returns {React.ReactNode} Componente react 
+   */ 
+  (props: {linhaOriginal: Array<any> | object, linha: Array<any>, index:number}): React.ReactNode
+}
+
+export declare interface ColumnOptions {
+  /**
+   * Indice da coluna a ser modificada
+   */ 
+  alias: number,
+  /**
+   * JSX Customizado para a coluna
+   * 
+   * @param itemFormatado - Item retornado pela funcao line no indice selecionado
+   * @param linhaOriginal - Linha original, antes de ser formatada pela função line
+   * @param linhaFormatada - Linha ja formatada pela função line
+   * @param index - Índice da linha
+   * 
+   * @returns {React.ReactNode} Componente react 
+   */ 
+  customJsx: (props: {index: number, itemFormatado: any, linhaFormatada: Array<any>, linhaOriginal: Array<any> | object}) => React.ReactNode
+}
+
+export interface ArgousComplexTableBodyProps {
+  /**
+   * @ignore
+   */
+  children?: React.ReactNode | ChildrenFunction,
+  /**
+   * Função que converte a linha original em um array com os dados a serem exibidos
+   * 
+   * @param linhaOriginal - linha a ser formatada
+   * 
+   * @returns {Array<any>} Retorna array
+   */ 
+  line: (linhaOriginal: Array<Array<any> | Object>) => Array<any>, 
+  /**
+   * Estilo que pode ser aplicado por linhas dependendo do conteúdo ou do índice da linha 
+   * 
+   * @param linhaOriginal - Linha original
+   * @param linhaFormatada - Linha formatada
+   * @param index - Índice da linha
+   * 
+   * @returns {React.CSSProperties} Estilos para a linha
+   */ 
+  lineStyle?: (linhaOriginal: Array<any> | object, linhaFormatada: Array<any>, index:number) => React.CSSProperties,
+  /**
+   * Classe que pode ser aplicada por linhas dependendo do conteúdo ou do índice da linha 
+   * 
+   * @param linhaFormatada - Linha formatada
+   * @param linhaOriginal - Linha original
+   * @param index - Índice da linha
+   * 
+   * @returns {string} Classe para a linha
+   */ 
+  lineClass?: (linhaFormatada: Array<any>, linhaOriginal: Array<any> | object, index: number) => string,
+  /**
+   * Habilita a seleção de linhas da lista 
+   */ 
+  enableCheck?: boolean,
+  /**
+   * Habilita o drag and drop das linhas
+   */ 
+  enableDrag?: boolean,
+  /**
+   * Função chamada ao clicar em uma linha
+   * 
+   * @param evento - Evento do drop
+   * 
+   * @returns {void} Sem retorno
+   */ 
+  onDrop?: (evento: React.DragEventHandler<HTMLDivElement>) => void,
+  /**
+   * Função que decide se a seleção de determinada linha está habilitada
+   * 
+   * @param linhaOriginal - Linha original, antes de ser formatada pela função line
+   * @param linhaFormatada - Linha ja formatada pela função line
+   * @param index - Índice da linha
+   * 
+   * @returns {boolean} Booleano
+   */ 
+  disableCheckIf?: (linhaOriginal: Array<any> | object, linhaFormatada: Array<any>, index: number) => boolean,
+  /**
+   * Array de estilos para cada coluna da linha
+   */ 
+  columnStyles?: Array<React.CSSProperties>,
+  /**
+   * Função chamada ao clicar em uma linha
+   * 
+   * @param evento - Evento do click
+   * @param linhaOriginal - Linha original
+   * @param linhaFormatada - Linha formatada
+   * @param index - Índice da linha clicada
+   * 
+   * @returns {void} Sem retorno
+   */ 
+  onClick?: (evento: EventTarget, linhaOriginal: Array<any> | object, linhaFormatada: Array<any>, index:number) => void,
+  /**
+   * Ìndice da linha original a ser utilizado como ID primário na hora das seleções e que será retornado pelas actions
+   */ 
+  indexToSelect?: number | string,
+  /**
+   * Array de opções para as colunas
+   * 
+   * @param alias - Índice da coluna
+   * @param customJsx - Função que retorna o JSX customizado
+   */ 
+  columnOptions?: Array<ColumnOptions>,
+  /**
+   * Title que aparecerá ao dar hover na linha
+   */ 
+  lineTitle?: string,
+  /**
+   * Item da linha original a ser utilizado como key no map
+   */ 
+  customKey?: string | number,
+  /**
+   * Props a serem repassados para a celula da tabela
+   * 
+   * @param index - Index da coluna sendo testada
+   * @param coluna - Item da coluna sendo testada
+   * @param linhaOriginal - Linha original sendo testada
+   * @param linhaFormatada - Linha formatada sendo testada
+   * 
+   * @returns {TableCellBaseProps} Props a serem passados para a coluna
+   */ 
+  columnProps?: (index: number, coluna: any, linhaOriginal: Array<any> | object, linhaFormatada: Array<any>) => TableCellBaseProps,
+  /**
+   * Props a serem repassados para a linha da tabela
+   * 
+   * @param index - Index da coluna sendo testada
+   * @param linhaOriginal - Linha original sendo testada
+   * @param linhaFormatada - Linha formatada sendo testada
+   * @param itensSelecionados - Linha formatada sendo testada
+   * 
+   * @returns {TableRowProps} Props a serem passados para a linha
+   */ 
+  rowProps?: (props: {index: number, linhaOriginal: Array<any> | object, linhaFormatada: Array<any>, itensSelecionados: any[]}) => TableRowProps
+}
+
+export interface ArgousComplexTableBodyPrivateProps extends ArgousComplexTableBodyProps {
+  /**
+   * Função que abre a linha clicada
+   * 
+   * @param index - Índice da linha clicada
+   * 
+   * @returns {void} Sem retorno
+   */
+  handleOpenClose: (index: number) => void,
+  /**
+   * Array de títulos para o cabeçalho da tabela
+   */ 
+  head?: Array<string>, 
+  /**
+   * Índice aberto 
+   */
+  open: number,
+  /**
+   * Array de dados que estão visíveis no momento
+   */
+  dadosMostrados: Array<Array<any> | Object>,
+}
+
+declare function ArgousComplexTableBody(props: ArgousComplexTableBodyPrivateProps): JSX.Element
+
+export default ArgousComplexTableBody;