drf-react-by-schema 0.28.7 → 0.28.9

package/dist/components/DataGridBySchemaEditable/RowEditingWatcher.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const x_data_grid_1 = require("@mui/x-data-grid");
+function RowEditingWatcher({ watchEditingRowValues }) {
+    const apiRef = (0, x_data_grid_1.useGridApiContext)();
+    const [rowEditingValues, rowId] = (0, x_data_grid_1.useGridSelector)(apiRef, (state) => {
+        const editState = (0, x_data_grid_1.gridEditRowsStateSelector)(state);
+        if (!editState || Object.keys(editState).length === 0) {
+            return [undefined, undefined];
+        }
+        const rowEditingId = Object.keys(editState)[0];
+        const rowEditState = editState[rowEditingId];
+        const onlyValues = {};
+        Object.keys(rowEditState).forEach((key) => {
+            onlyValues[key] = rowEditState[key].value;
+        });
+        return [onlyValues, rowEditingId];
+    });
+    const setRowEditingValues = (0, react_1.useCallback)((newValues) => {
+        if (!apiRef.current || !rowEditingValues || !rowId) {
+            return;
+        }
+        for (const [field, newRowEditingValue] of Object.entries(newValues)) {
+            const rowEditingValue = field in rowEditingValues ? rowEditingValues[field] : undefined;
+            if (JSON.stringify(rowEditingValue) !== JSON.stringify(newRowEditingValue))
+                apiRef.current.setEditCellValue({
+                    id: rowId,
+                    field,
+                    value: newRowEditingValue,
+                });
+        }
+    }, [apiRef, rowEditingValues, rowId]);
+    (0, react_1.useEffect)(() => {
+        if (watchEditingRowValues && rowEditingValues) {
+            watchEditingRowValues({ rowEditingValues, setRowEditingValues });
+        }
+    }, [rowEditingValues, apiRef, watchEditingRowValues, setRowEditingValues]);
+    return null;
+}
+exports.default = RowEditingWatcher;

package/dist/components/DataGridBySchemaEditable/SelectEditInputCell.d.ts

@@ -0,0 +1,24 @@
+import { JSX } from 'react';
+import { SxProps, Theme } from '@mui/material/styles';
+import { FormFieldLayout, GenericValue, Item, GridEnrichedBySchemaColDef, TField } from '../../@types';
+import { DialogType, OnEditModelType } from '../../context/APIWrapperContext';
+interface SelectEditInputCellProps {
+    field: string;
+    id: number | string;
+    value?: GenericValue;
+    column: GridEnrichedBySchemaColDef;
+    type: string;
+    options?: Item[] | (() => Promise<Item[]>) | null;
+    isIndexField: boolean;
+    multiple?: boolean;
+    onEditModel?: <U extends TField = void>(p: OnEditModelType<U>) => void;
+    fieldsLayout?: FormFieldLayout[];
+    sx?: SxProps<Theme>;
+    setDialog: (x: Partial<DialogType>) => void;
+    error?: boolean;
+    helperText?: string;
+    hasFocus?: boolean;
+}
+export default function SelectEditInputCell({ field, id, value, column, type, options, isIndexField, multiple, onEditModel, fieldsLayout, sx, setDialog, error, helperText, hasFocus, }: SelectEditInputCellProps): JSX.Element;
+export {};
+//# sourceMappingURL=SelectEditInputCell.d.ts.map

package/dist/components/DataGridBySchemaEditable/SelectEditInputCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectEditInputCell.d.ts","sourceRoot":"","sources":["../../../src/components/DataGridBySchemaEditable/SelectEditInputCell.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAE,GAAG,EAAoC,MAAM,OAAO,CAAC;AAGrE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAMtD,OAAO,EACL,eAAe,EACf,YAAY,EACZ,IAAI,EACJ,0BAA0B,EAE1B,MAAM,EACP,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAM9E,UAAU,wBAAwB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,0BAA0B,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;IAClD,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACvE,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;IACjC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACpB,SAAS,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAC1C,KAAK,EACL,EAAE,EACF,KAAK,EACL,MAAM,EACN,IAAI,EACJ,OAAO,EACP,YAAY,EACZ,QAAgB,EAChB,WAAW,EACX,YAAY,EACZ,EAAyB,EACzB,SAAS,EACT,KAAK,EACL,UAAU,EACV,QAAQ,GACT,EAAE,wBAAwB,GAAG,GAAG,CAAC,OAAO,CAgSxC"}

package/dist/components/DataGridBySchemaEditable/SelectEditInputCell.js

@@ -0,0 +1,259 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = SelectEditInputCell;
+const react_1 = __importStar(require("react"));
+const x_data_grid_1 = require("@mui/x-data-grid");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const IconButton_1 = __importDefault(require("@mui/material/IconButton"));
+const Edit_1 = __importDefault(require("@mui/icons-material/Edit"));
+const Autocomplete_1 = __importStar(require("@mui/material/Autocomplete"));
+const utils_1 = require("../../utils");
+const DialogActions_1 = __importDefault(require("../DialogActions"));
+const grid_1 = require("../../styles/grid");
+const filter = (0, Autocomplete_1.createFilterOptions)();
+function SelectEditInputCell({ field, id, value, column, type, options, isIndexField, multiple = false, onEditModel, fieldsLayout, sx = {}, setDialog, error, helperText, hasFocus, }) {
+    const [loadedOptions, setLoadedOptions] = (0, react_1.useState)(null);
+    // TODO: allow edit option label, as in formautocomplete!
+    const apiRef = (0, x_data_grid_1.useGridApiContext)();
+    const [openOptions, setOpenOptions] = (0, react_1.useState)(false);
+    const inputCallbackRef = (0, react_1.useCallback)((node) => {
+        if (node !== null && hasFocus) {
+            requestAnimationFrame(() => {
+                node.focus();
+                node.select();
+            });
+        }
+    }, [hasFocus]);
+    const handleChange = (newValue) => __awaiter(this, void 0, void 0, function* () {
+        yield apiRef.current.setEditCellValue({ id, field, value: newValue });
+        apiRef.current.stopCellEditMode({ id, field });
+    });
+    const labelKey = ['field', 'nested object'].includes(type) || isIndexField ? 'label' : 'display_name';
+    const valueKey = ['field', 'nested object'].includes(type) || isIndexField ? 'id' : 'value';
+    let creatableProps = {};
+    // if (column.creatable || isIndexField) {
+    if (column.creatable) {
+        creatableProps = {
+            freeSolo: true,
+            filterOptions: (thisOptions, params) => {
+                let filtered = filter(thisOptions, params);
+                const inputValue = params.inputValue ? params.inputValue : '';
+                const inputValueSlug = (0, utils_1.slugify)(inputValue);
+                const inputValueLength = inputValueSlug.length;
+                // Suggest the creation of a new value
+                const isExisting = thisOptions.find((option) => inputValueSlug === (0, utils_1.slugify)(option[labelKey]));
+                if (inputValue !== '' && !isExisting) {
+                    filtered.push({
+                        inputValue,
+                        [labelKey]: `Criar "${inputValue}"`,
+                    });
+                }
+                // Show first the exact match:
+                if (isExisting) {
+                    filtered = [isExisting, ...filtered.filter((option) => isExisting.id !== option.id)];
+                }
+                // Show first the options that start with inputValue:
+                const startsWith = filtered.filter((option) => inputValueSlug === (0, utils_1.slugify)(option.label).substring(0, inputValueLength));
+                if (startsWith.length > 0) {
+                    const startsWithIds = startsWith.map((option) => option.id);
+                    filtered = [
+                        ...startsWith,
+                        ...filtered.filter((option) => !startsWithIds.includes(option.id)),
+                    ];
+                }
+                return filtered;
+            },
+            handleHomeEndKeys: true,
+            getOptionLabel: (option) => {
+                // Value selected with enter, right from the input
+                if (typeof option === 'string') {
+                    return option;
+                }
+                // Criar "xxx" option created dynamically
+                if (option.inputValue) {
+                    return option.inputValue;
+                }
+                // Regular option
+                return option[labelKey];
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            renderOption: (props, option) => {
+                return (react_1.default.createElement("li", Object.assign({ key: option[valueKey] }, props), option[labelKey]));
+            },
+        };
+    }
+    const handleOpenOptions = () => {
+        setOpenOptions(true);
+    };
+    const handleCloseOptions = () => {
+        setOpenOptions(false);
+    };
+    (0, react_1.useEffect)(() => {
+        if (!options) {
+            return;
+        }
+        if (Array.isArray(options)) {
+            setLoadedOptions(options);
+            return;
+        }
+        if (!loadedOptions) {
+            options().then((newOptions) => setLoadedOptions(newOptions));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [field, options]);
+    if (!options ||
+        loadedOptions === null
+    // || (Array.isArray(options) && options.length === 0) || loadedOptions.length === 0
+    ) {
+        return react_1.default.createElement(react_1.default.Fragment, null);
+    }
+    return (react_1.default.createElement(Autocomplete_1.default, Object.assign({ key: field, open: openOptions, onOpen: handleOpenOptions, onClose: handleCloseOptions, id: field, value: value, options: loadedOptions, selectOnFocus: true, autoHighlight: true, multiple: multiple, isOptionEqualToValue: (option, val) => {
+            return option[labelKey] === val[labelKey];
+        }, getOptionLabel: (option) => {
+            if (typeof option === 'string')
+                return option;
+            if (option.inputValue)
+                return option.inputValue;
+            return option ? option[labelKey] : '';
+        }, onChange: (_e, value) => {
+            // if (!column.creatable && !isIndexField) {
+            if (!column.creatable) {
+                handleChange(value);
+                return;
+            }
+            let newValue = value;
+            if (typeof newValue === 'string') {
+                const tmpId = (0, utils_1.getTmpId)();
+                newValue = {
+                    [valueKey]: tmpId,
+                    [labelKey]: newValue,
+                };
+            }
+            if (newValue && newValue.inputValue) {
+                const tmpId = (0, utils_1.getTmpId)();
+                if (onEditModel) {
+                    // Open modal to save new item:
+                    onEditModel({
+                        model: field,
+                        id: tmpId,
+                        labelKey,
+                        setValue: (_key, updatedValue) => {
+                            handleChange(updatedValue);
+                        },
+                        getValues: () => {
+                            console.log('getValues');
+                            return newValue;
+                        },
+                        fieldsLayout,
+                        initialValuesPartial: {
+                            nome: newValue.inputValue, // TODO: make this "nome" generic!
+                        },
+                    });
+                }
+                // Define new Item as an "optimistic response"
+                newValue = {
+                    [valueKey]: tmpId,
+                    [labelKey]: newValue.inputValue,
+                };
+            }
+            handleChange(newValue);
+        }, fullWidth: true, slotProps: {
+            paper: {
+                sx: {
+                    marginTop: '1px', // Gap to show the bottom cell border
+                    boxShadow: 3,
+                    border: '1px solid #e0e0e0',
+                    '& .MuiAutocomplete-listbox': {
+                        padding: 0,
+                        fontSize: '0.875rem',
+                    },
+                },
+            },
+        }, renderInput: (params) => (react_1.default.createElement(react_1.default.Fragment, null, column.creatable ? (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { 
+            // margin="normal"
+            inputRef: inputCallbackRef, slotProps: {
+                htmlInput: Object.assign(Object.assign({}, params.inputProps), { 'aria-label': `Editar ${column.headerName || field}. Pressione Enter ou comece a digitar para ver as opções.` }),
+                input: Object.assign(Object.assign({}, params.InputProps), { endAdornment: (react_1.default.createElement(react_1.default.Fragment, null,
+                        !multiple && onEditModel && value && (react_1.default.createElement(IconButton_1.default, { size: "small", "aria-label": "Editar", onClick: () => {
+                                if ((0, utils_1.isTmpId)(value.id)) {
+                                    setDialog({
+                                        open: true,
+                                        loading: false,
+                                        title: 'Linha sendo criada',
+                                        Body: 'Esta linha está sendo criada agora por você. Para editar suas propriedades, salve antes, e depois você poderá editar!',
+                                        Actions: (react_1.default.createElement(DialogActions_1.default, { setDialog: setDialog, btnCancel: "Entendi" })),
+                                    });
+                                    return;
+                                }
+                                onEditModel({
+                                    model: field,
+                                    id: value[valueKey],
+                                    labelKey,
+                                    setValue: (_key, updatedValue) => {
+                                        handleChange(updatedValue);
+                                    },
+                                    getValues: () => {
+                                        return value;
+                                    },
+                                    fieldsLayout,
+                                });
+                            } },
+                            react_1.default.createElement(Edit_1.default, null))),
+                        params.InputProps.endAdornment)) }),
+            }, error: error, helperText: helperText, sx: [grid_1.seamlessTextFieldStyle, ...(Array.isArray(sx) ? sx : [sx])] }))) : (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { inputRef: inputCallbackRef, slotProps: {
+                htmlInput: Object.assign(Object.assign({}, params.inputProps), { 'aria-label': `Selecionar ${column.headerName || field}` }),
+            }, error: error, helperText: helperText, sx: [grid_1.seamlessTextFieldStyle, ...(Array.isArray(sx) ? sx : [sx])] }))))) }, creatableProps, { onKeyDown: (event) => {
+            if (event.key === 'Enter') {
+                if (!openOptions) {
+                    // Abrir o menu de opções
+                    event.stopPropagation();
+                    handleOpenOptions();
+                }
+            }
+        } })));
+}

package/dist/components/DataGridBySchemaEditable/geoConstants.d.ts

@@ -0,0 +1,5 @@
+export declare const GIS_THUMB_SIZE: {
+    readonly w: 150;
+    readonly h: 100;
+};
+//# sourceMappingURL=geoConstants.d.ts.map

package/dist/components/DataGridBySchemaEditable/geoConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoConstants.d.ts","sourceRoot":"","sources":["../../../src/components/DataGridBySchemaEditable/geoConstants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;CAA8B,CAAC"}

package/dist/components/DataGridBySchemaEditable/geoConstants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIS_THUMB_SIZE = void 0;
+// Shared sizing for PostGIS geometry grid cells. Matches the thumbnail image
+// height used by image/file columns (maxHeight 100px).
+exports.GIS_THUMB_SIZE = { w: 150, h: 100 };

package/dist/components/DataGridBySchemaEditable/hooks/useDataGridActions.d.ts

@@ -0,0 +1,33 @@
+import { RefObject } from 'react';
+import { GridRowId } from '@mui/x-data-grid';
+import { GridApiCommunity } from '@mui/x-data-grid/internals';
+import { Id, Item, SchemaType, BulkUpdateData, BulkDeleteData, FieldKey, PartialItem, TField, PaginationModel } from '../../../@types';
+interface UseDataGridActionsProps<T extends TField = void> {
+    apiRef: RefObject<GridApiCommunity>;
+    model: string;
+    modelParent?: string;
+    modelParentId?: Id;
+    schema: SchemaType<T>;
+    emptyItem: PartialItem<T>;
+    dataGridRows: Item<T>[];
+    setDataGridRows: (value: React.SetStateAction<Item<T>[]>) => void;
+    setSelectionModel: (value: React.SetStateAction<Item<T>[]>) => void;
+    setSelectionModelIds: (value: React.SetStateAction<GridRowId[]>) => void;
+    setSnackBar: (value: React.SetStateAction<Item>) => void;
+    setDataGridLoading: (value: boolean) => void;
+    handleStartEditing: (p?: Id) => void;
+    tableAutoHeight?: boolean;
+    indexField: FieldKey<T>;
+    defaultValues?: PartialItem<T>;
+    isRowEditing?: Id;
+    onProcessRow?: (p?: Item<T>) => void;
+}
+export declare const useDataGridActions: <T extends TField = void>({ apiRef, model, modelParent, modelParentId, schema, emptyItem, dataGridRows, setDataGridRows, setSelectionModel, setSelectionModelIds, setSnackBar, setDataGridLoading, handleStartEditing, tableAutoHeight, indexField, defaultValues, isRowEditing, onProcessRow, }: UseDataGridActionsProps<T>) => {
+    handleAddItem: () => void;
+    bulkUpdateData: BulkUpdateData<T>;
+    bulkDeleteData: BulkDeleteData;
+    bulkCreateData: (ids: Id[]) => Promise<void>;
+    handleExportExcel: (paginationModel: PaginationModel) => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useDataGridActions.d.ts.map

package/dist/components/DataGridBySchemaEditable/hooks/useDataGridActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridActions.d.ts","sourceRoot":"","sources":["../../../../src/components/DataGridBySchemaEditable/hooks/useDataGridActions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,EACL,EAAE,EACF,IAAI,EACJ,UAAU,EACV,cAAc,EACd,cAAc,EACd,QAAQ,EACR,WAAW,EACX,MAAM,EACN,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAKzB,UAAU,uBAAuB,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI;IACvD,MAAM,EAAE,SAAS,CAAC,gBAAgB,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACtB,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC1B,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACxB,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IAClE,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACpE,oBAAoB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,KAAK,IAAI,CAAC;IACzE,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;IACzD,kBAAkB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC;IACrC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxB,aAAa,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC/B,YAAY,CAAC,EAAE,EAAE,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CACtC;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,EAAE,wQAmBzD,uBAAuB,CAAC,CAAC,CAAC;;;;0BAqIQ,EAAE,EAAE;yCAWW,eAAe;CAqBlE,CAAC"}

package/dist/components/DataGridBySchemaEditable/hooks/useDataGridActions.js

@@ -0,0 +1,161 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridActions = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../../../utils");
+const APIWrapperContext_1 = require("../../../context/APIWrapperContext");
+const utils_2 = require("../utils");
+const useDataGridActions = ({ apiRef, model, modelParent, modelParentId, schema, emptyItem, dataGridRows, setDataGridRows, setSelectionModel, setSelectionModelIds, setSnackBar, setDataGridLoading, handleStartEditing, tableAutoHeight, indexField, defaultValues, isRowEditing, onProcessRow, }) => {
+    const { rawDeleteData, rawUpdateDataBySchema, exportExcelData } = (0, APIWrapperContext_1.useAPIWrapper)();
+    const handleAddItems = (n = 1) => {
+        const newRows = [];
+        for (let i = 0; i < n; i++) {
+            const id = (0, utils_1.getTmpId)();
+            const newRow = Object.assign(Object.assign(Object.assign({}, emptyItem), defaultValues), { id });
+            apiRef.current.updateRows([newRow]);
+            newRows.push(newRow);
+        }
+        const newDataGridRows = tableAutoHeight
+            ? [...dataGridRows, ...newRows]
+            : [...newRows, ...dataGridRows];
+        setDataGridRows(newDataGridRows);
+        let fieldToFocus = indexField;
+        if (!fieldToFocus) {
+            const visibleColumns = apiRef.current.getAllColumns();
+            const firstEditableCol = visibleColumns.find((col) => col.editable && col.field !== 'actions');
+            fieldToFocus = firstEditableCol === null || firstEditableCol === void 0 ? void 0 : firstEditableCol.field;
+        }
+        (0, utils_2.scrollToNewRow)(apiRef, tableAutoHeight);
+        apiRef.current.startRowEditMode({ id: newRows[0].id, fieldToFocus });
+        handleStartEditing(newRows[0].id);
+    };
+    const handleAddItem = () => {
+        if (isRowEditing) {
+            if ((0, utils_1.isTmpId)(isRowEditing)) {
+                setSnackBar({
+                    open: true,
+                    severity: 'info',
+                    msg: 'Adicione uma linha por vez',
+                });
+                return;
+            }
+            apiRef.current.stopRowEditMode({ id: isRowEditing });
+        }
+        const id = (0, utils_1.getTmpId)();
+        const newRow = Object.assign(Object.assign(Object.assign({}, emptyItem), defaultValues), { id });
+        (0, utils_2.addNewRow)({
+            newRow,
+            indexField,
+            tableAutoHeight,
+            apiRef,
+            setDataGridRows,
+        });
+        handleStartEditing(id);
+        // apiRef.current.setCellFocus(id, fieldToFocus);
+        // if (!tableAutoHeight) {
+        //   apiRef.current.scrollToIndexes({ rowIndex: 0 });
+        // }
+    };
+    const bulkUpdateData = (newData) => __awaiter(void 0, void 0, void 0, function* () {
+        const promises = [];
+        const ids = [];
+        newData.map((item) => {
+            promises.push(rawUpdateDataBySchema({
+                model,
+                modelObjectId: item.id,
+                data: item,
+                schema,
+            }));
+            ids.push(item.id);
+        });
+        const results = yield Promise.all(promises);
+        setSelectionModel([]);
+        setSelectionModelIds([]);
+        const updatedData = dataGridRows.map((item) => {
+            const index = ids.indexOf(item.id);
+            return index === -1 ? item : newData[index];
+        });
+        setDataGridRows(updatedData);
+        setSnackBar({
+            open: true,
+            severity: 'success',
+            msg: 'Alterações salvas com sucesso',
+        });
+        return results.map((result, index) => {
+            return {
+                id: ids[index],
+                success: !axios_1.default.isAxiosError(result),
+            };
+        });
+    });
+    const bulkDeleteData = (ids) => __awaiter(void 0, void 0, void 0, function* () {
+        const promises = [];
+        ids.map((id) => {
+            promises.push(rawDeleteData(model, id));
+            apiRef.current.updateRows([{ id, _action: 'delete' }]);
+        });
+        setDataGridLoading(true);
+        const results = yield Promise.all(promises);
+        setSelectionModel([]);
+        setSelectionModelIds([]);
+        const newData = dataGridRows.filter(({ id }) => !ids.includes(id));
+        setDataGridRows(newData);
+        if (onProcessRow) {
+            onProcessRow();
+        }
+        setDataGridLoading(false);
+        setSnackBar({
+            open: true,
+            severity: 'success',
+            msg: 'Itens apagados com sucesso',
+        });
+        return results.map((result, index) => {
+            return {
+                id: ids[index],
+                success: result === true,
+            };
+        });
+    });
+    const bulkCreateData = (ids) => __awaiter(void 0, void 0, void 0, function* () {
+        handleAddItems(ids.length);
+        setSelectionModel([]);
+        setSelectionModelIds([]);
+        setSnackBar({
+            open: true,
+            severity: 'success',
+            msg: 'Linhas adicionadas com sucesso',
+        });
+    });
+    const handleExportExcel = (paginationModel) => __awaiter(void 0, void 0, void 0, function* () {
+        setDataGridLoading(true);
+        const result = yield exportExcelData({ model, modelParent, modelParentId, paginationModel });
+        setDataGridLoading(false);
+        if (result !== true) {
+            setSnackBar({
+                open: true,
+                severity: 'error',
+                msg: 'Erro ao exportar para Excel',
+            });
+        }
+    });
+    return {
+        handleAddItem,
+        bulkUpdateData,
+        bulkDeleteData,
+        bulkCreateData,
+        handleExportExcel,
+    };
+};
+exports.useDataGridActions = useDataGridActions;

package/dist/components/DataGridBySchemaEditable/hooks/useOptionsAC.d.ts

@@ -0,0 +1,14 @@
+import { SchemaType, OptionsAC, GridEnrichedBySchemaColDef, FieldKey, TField } from '../../../@types';
+interface UseOptionsACProps<T extends TField = void> {
+    columns: GridEnrichedBySchemaColDef<T>[];
+    schema: SchemaType<T>;
+    optionsACExternal?: OptionsAC<T>;
+    indexField?: FieldKey<T>;
+    addExistingModel?: string;
+}
+export declare const useOptionsAC: <T extends TField = void>({ columns, schema, optionsACExternal, indexField, addExistingModel, }: UseOptionsACProps<T>) => {
+    optionsAC: OptionsAC<T>;
+    updateOptionsAC: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useOptionsAC.d.ts.map

package/dist/components/DataGridBySchemaEditable/hooks/useOptionsAC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOptionsAC.d.ts","sourceRoot":"","sources":["../../../../src/components/DataGridBySchemaEditable/hooks/useOptionsAC.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EACV,SAAS,EACT,0BAA0B,EAC1B,QAAQ,EAGR,MAAM,EACP,MAAM,iBAAiB,CAAC;AAGzB,UAAU,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI;IACjD,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC,EAAE,CAAC;IACzC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACtB,iBAAiB,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,EAAE,uEAMnD,iBAAiB,CAAC,CAAC,CAAC;;;CAmDtB,CAAC"}

package/dist/components/DataGridBySchemaEditable/hooks/useOptionsAC.js

@@ -0,0 +1,69 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOptionsAC = void 0;
+const react_1 = require("react");
+const axios_1 = __importDefault(require("axios"));
+const APIWrapperContext_1 = require("../../../context/APIWrapperContext");
+const useOptionsAC = ({ columns, schema, optionsACExternal, indexField, addExistingModel, }) => {
+    const { getAutoComplete } = (0, APIWrapperContext_1.useAPIWrapper)();
+    const [optionsAC, setOptionsAC] = (0, react_1.useState)({});
+    const updateOptionsAC = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const newOptionsAC = {};
+        for (const col of columns) {
+            if (optionsACExternal && col.field in optionsACExternal) {
+                newOptionsAC[col.field] = optionsACExternal[col.field];
+                continue;
+            }
+            if (!(col.field in schema)) {
+                continue;
+            }
+            const fieldSchema = schema[col.field];
+            if (!fieldSchema) {
+                continue;
+            }
+            if (['field', 'nested object'].includes(fieldSchema.type) && !(col.field in newOptionsAC)) {
+                const options = yield getAutoComplete(col.field);
+                if (!axios_1.default.isAxiosError(options)) {
+                    newOptionsAC[col.field] = options;
+                    continue;
+                }
+                console.log(`Couldn't load autocomplete options from '${col.field}'`);
+                continue;
+            }
+            if (fieldSchema.type === 'choice' && !(col.field in newOptionsAC)) {
+                newOptionsAC[col.field] = fieldSchema.choices || [];
+                continue;
+            }
+            if (fieldSchema.type === 'list' && !(col.field in newOptionsAC)) {
+                newOptionsAC[col.field] = ((_a = fieldSchema.child) === null || _a === void 0 ? void 0 : _a.choices) || [];
+                continue;
+            }
+            if (col.field === indexField && addExistingModel && !(col.field in newOptionsAC)) {
+                const options = yield getAutoComplete(addExistingModel);
+                if (!axios_1.default.isAxiosError(options)) {
+                    newOptionsAC[col.field] = options;
+                    continue;
+                }
+            }
+        }
+        setOptionsAC(newOptionsAC);
+    }), [columns, schema, optionsACExternal, indexField, addExistingModel]);
+    (0, react_1.useEffect)(() => {
+        updateOptionsAC();
+    }, [columns]);
+    return { optionsAC, updateOptionsAC };
+};
+exports.useOptionsAC = useOptionsAC;

package/dist/components/DataGridBySchemaEditable/hooks/usePreparedColumns.d.ts

@@ -0,0 +1,9 @@
+import { GridEnrichedBySchemaColDef, TField } from '../../../@types';
+import { BuildPreparedColumnsProps } from '../utils/columnFactory';
+export declare const usePreparedColumns: <T extends TField = void>({ apiRef, schema, columns, isEditable, actions, LinkComponent, stateToLink, validationErrors, optionsAC, onEditModel, customFieldFormLayouts, setDialog, indexField, indexFieldMinWidth, minWidth, customColumnOperations, customLinkDestination, indexFieldBasePath, }: Omit<BuildPreparedColumnsProps<T>, "columns" | "serverEndPoint" | "conditionalVisible"> & {
+    columns: GridEnrichedBySchemaColDef<T>[];
+}) => {
+    preparedColumns: GridEnrichedBySchemaColDef<T>[] | null;
+    setPreparedColumns: import("react").Dispatch<import("react").SetStateAction<GridEnrichedBySchemaColDef<T>[] | null>>;
+};
+//# sourceMappingURL=usePreparedColumns.d.ts.map

package/dist/components/DataGridBySchemaEditable/hooks/usePreparedColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePreparedColumns.d.ts","sourceRoot":"","sources":["../../../../src/components/DataGridBySchemaEditable/hooks/usePreparedColumns.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAwB,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAIzF,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,EAAE,yQAmBzD,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,gBAAgB,GAAG,oBAAoB,CAAC,GAAG;IAC3F,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC,EAAE,CAAC;CAC1C;;;CA4DA,CAAC"}