drf-react-by-schema 0.6.5 → 0.7.1

package/dist/components/forms/inputs/AutocompleteFieldBySchema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FieldBySchemaProps } from '../../../utils';
+export default function AutocompleteFieldBySchema({ fieldKey, index, name, schema, control, errors, optionIdKey, optionLabelKey, options, isSemaphoric, sx, label, ...other }: FieldBySchemaProps): JSX.Element;

package/dist/components/forms/inputs/AutocompleteFieldBySchema.js

@@ -0,0 +1,86 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const Autocomplete_1 = __importDefault(require("@mui/material/Autocomplete"));
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const utils_1 = require("../../../utils");
+const DRFReactBySchemaContext_1 = require("../../../context/DRFReactBySchemaContext");
+const renderInput = (_a) => {
+    var { control, options, optionLabelKey, schema, name, errors, fieldKey, index, isSemaphoric, label, theme } = _a, params = __rest(_a, ["control", "options", "optionLabelKey", "schema", "name", "errors", "fieldKey", "index", "isSemaphoric", "label", "theme"]);
+    const model = name;
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? errors[name].message : schema[name].help_text || '',
+        };
+    let sx = undefined;
+    if (isSemaphoric && options && optionLabelKey) {
+        let tipo;
+        switch (params.inputProps.value) {
+            case options[0][optionLabelKey]:
+                tipo = 'success';
+                break;
+            case options[1][optionLabelKey]:
+                tipo = 'warning';
+                break;
+            case options[2][optionLabelKey]:
+                tipo = 'error';
+                break;
+        }
+        if (tipo) {
+            sx = { backgroundColor: theme.palette[tipo].semaphoric };
+        }
+    }
+    return (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { label: label || schema[model].label, required: schema[model].required, margin: "normal", error: error, helperText: helperText, sx: sx })));
+};
+function AutocompleteFieldBySchema(_a) {
+    var { fieldKey, index, name, schema, control, errors, optionIdKey = 'id', optionLabelKey = 'label', options, isSemaphoric = false, sx = { mr: 2 }, label } = _a, other = __rest(_a, ["fieldKey", "index", "name", "schema", "control", "errors", "optionIdKey", "optionLabelKey", "options", "isSemaphoric", "sx", "label"]);
+    const model = name;
+    const { theme } = (0, DRFReactBySchemaContext_1.useDRFReactBySchema)();
+    if (!options) {
+        options = schema[model].choices;
+    }
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => (react_1.default.createElement(Autocomplete_1.default, Object.assign({}, field, { key: name, id: name, options: options || [], selectOnFocus: true, autoHighlight: true, isOptionEqualToValue: (option, value) => {
+                return option[optionIdKey] === value[optionIdKey];
+            }, getOptionLabel: (option) => {
+                return option[optionLabelKey];
+            }, onChange: (e, value) => {
+                field.onChange(value);
+            }, fullWidth: true, renderInput: (params) => {
+                return renderInput(Object.assign(Object.assign({}, params), { control,
+                    isSemaphoric,
+                    options,
+                    optionLabelKey,
+                    schema,
+                    name,
+                    errors,
+                    fieldKey,
+                    index,
+                    theme }));
+            }, sx: sx }, other))) }));
+}
+exports.default = AutocompleteFieldBySchema;

package/dist/components/forms/inputs/BooleanFieldBySchema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FieldBySchemaProps } from '../../../utils';
+export default function BooleanFieldBySchema({ name, schema, control, errors, fieldKey, index, sx, ...other }: FieldBySchemaProps): JSX.Element;

package/dist/components/forms/inputs/BooleanFieldBySchema.js

@@ -0,0 +1,41 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const Checkbox_1 = __importDefault(require("@mui/material/Checkbox"));
+const FormControlLabel_1 = __importDefault(require("@mui/material/FormControlLabel"));
+function BooleanFieldBySchema(_a) {
+    var { name, schema, control, errors, fieldKey, index, sx = { mr: 2 } } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "fieldKey", "index", "sx"]);
+    const model = name;
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    // const { error, helperText } =
+    //     fieldKey && index >= 0
+    //         ? errorProps({
+    //               fieldKey,
+    //               index,
+    //               fieldKeyProp: name,
+    //               errors,
+    //           })
+    //         : {
+    //               error: errors && Boolean(errors[name]),
+    //               helperText: errors && errors[name] ? errors[name].message : schema[name].help_text || '',
+    //           };
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => (react_1.default.createElement(FormControlLabel_1.default, { control: react_1.default.createElement(Checkbox_1.default, Object.assign({}, field, other, { value: field.value || false, checked: field.value || false, inputProps: { 'aria-label': 'controlled' } })), label: schema[model].label, required: schema[model].required })) }));
+}
+exports.default = BooleanFieldBySchema;

package/dist/components/forms/inputs/DesktopDatePickerBySchema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FieldBySchemaProps } from '../../../utils';
+export default function DesktopDatePickerBySchema({ name, schema, control, errors, fieldKey, index, sx, ...other }: FieldBySchemaProps): JSX.Element;

package/dist/components/forms/inputs/DesktopDatePickerBySchema.js

@@ -0,0 +1,49 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const DesktopDatePicker_1 = require("@mui/x-date-pickers/DesktopDatePicker");
+const utils_1 = require("drf-react-by-schema/dist/utils");
+const utils_2 = require("../../../utils");
+function DesktopDatePickerBySchema(_a) {
+    var { name, schema, control, errors, fieldKey = null, index = null, sx } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "fieldKey", "index", "sx"]);
+    if (!sx) {
+        sx = { minWidth: 200 };
+    }
+    if (!sx.hasOwnProperty('minWidth')) {
+        sx = Object.assign(Object.assign({}, sx), { minWidth: 200 });
+    }
+    const model = name;
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    const inputFormat = (0, utils_1.buildDateFormatBySchema)(schema[model].date_views);
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_2.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? errors[name].message : schema[name].help_text || '',
+        };
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => (react_1.default.createElement(DesktopDatePicker_1.DesktopDatePicker, Object.assign({}, field, { label: schema[model].label, views: schema[model].date_views, inputFormat: inputFormat, renderInput: (params) => (react_1.default.createElement(TextField_1.default, Object.assign({}, params, other, { sx: sx, margin: "normal", error: error, helperText: helperText }))) }))) }));
+}
+exports.default = DesktopDatePickerBySchema;

package/dist/components/forms/inputs/DesktopDateTimePickerBySchema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FieldBySchemaProps } from '../../../utils';
+export default function DesktopDateTimePickerBySchema({ name, schema, control, errors, multiline, fieldKey, index, sx, ...other }: FieldBySchemaProps): JSX.Element;

package/dist/components/forms/inputs/DesktopDateTimePickerBySchema.js

@@ -0,0 +1,41 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const DesktopDateTimePicker_1 = require("@mui/x-date-pickers/DesktopDateTimePicker");
+const utils_1 = require("../../../utils");
+function DesktopDateTimePickerBySchema(_a) {
+    var { name, schema, control, errors, multiline = false, fieldKey = null, index = null, sx = { mr: 2 } } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "multiline", "fieldKey", "index", "sx"]);
+    const model = name;
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? errors[name].message : schema[name].help_text || '',
+        };
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => (react_1.default.createElement(DesktopDateTimePicker_1.DesktopDateTimePicker, Object.assign({}, field, { label: schema[model].label, inputFormat: "DD/MM/yyyy HH:mm", renderInput: (params) => (react_1.default.createElement(TextField_1.default, Object.assign({}, params, other, { sx: sx, margin: "normal", error: error, helperText: helperText }))) }))) }));
+}
+exports.default = DesktopDateTimePickerBySchema;

package/dist/components/forms/inputs/EditableAutocompleteFieldBySchema.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FieldBySchemaProps } from '../../../utils';
+declare const EditableAutocompleteFieldBySchema: React.ForwardRefExoticComponent<FieldBySchemaProps & React.RefAttributes<any>>;
+export default EditableAutocompleteFieldBySchema;

package/dist/components/forms/inputs/EditableAutocompleteFieldBySchema.js

@@ -0,0 +1,203 @@
+"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 (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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const Autocomplete_1 = __importStar(require("@mui/material/Autocomplete"));
+const Edit_1 = __importDefault(require("@mui/icons-material/Edit"));
+const IconButton_1 = __importDefault(require("@mui/material/IconButton"));
+const Chip_1 = __importDefault(require("@mui/material/Chip"));
+const utils_1 = require("../../../utils");
+const DialogActions_1 = __importDefault(require("../../DialogActions"));
+const APIWrapperContext_1 = require("../../../context/APIWrapperContext");
+const filter = (0, Autocomplete_1.createFilterOptions)();
+const EditableAutocompleteFieldBySchema = react_1.default.forwardRef((_a, ref) => {
+    var { control, schema, errors, setValue, getValues, fieldKey, labelKey = 'nome', index, name = 'name', optionsAC, optionsModel, getOptionLabel, renderOption, onEditModel, sx = { mr: 2 }, multiple = false } = _a, other = __rest(_a, ["control", "schema", "errors", "setValue", "getValues", "fieldKey", "labelKey", "index", "name", "optionsAC", "optionsModel", "getOptionLabel", "renderOption", "onEditModel", "sx", "multiple"]);
+    const { setDialog } = (0, APIWrapperContext_1.useAPIWrapper)();
+    const model = name;
+    const label = schema[model].label;
+    if (!optionsModel) {
+        optionsModel = model;
+    }
+    const options = optionsAC ? optionsAC[optionsModel] : [];
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    (0, react_1.useEffect)(() => {
+        if (!getValues || !setValue) {
+            return;
+        }
+        const valuesInitial = getValues(model);
+        if (!valuesInitial) {
+            return;
+        }
+        if (multiple) {
+            const harmonizedValues = [];
+            for (const valueInitial of valuesInitial) {
+                const harmonizedValue = options.find((option) => option.id === valueInitial.id);
+                if (harmonizedValue) {
+                    harmonizedValues.push(harmonizedValue);
+                }
+            }
+            setValue(model, harmonizedValues);
+            return;
+        }
+        const harmonizedValues = options.find((option) => option.id === valuesInitial.id);
+        setValue(model, harmonizedValues);
+    }, []);
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name]
+                ? errors[name].message
+                : schema[name].help_text || '',
+        };
+    if (!schema[model].disabled && onEditModel && optionsModel) {
+        return (react_1.default.createElement(react_hook_form_1.Controller, { control: control, name: name, render: ({ field }) => (react_1.default.createElement(Autocomplete_1.default, Object.assign({ key: name }, field, { id: name, options: options, disabled: options.length === 0 || schema[model].disabled === true, autoHighlight: true, isOptionEqualToValue: (option, value) => option.id === value.id, fullWidth: true, multiple: multiple, sx: sx, onChange: (e, value) => {
+                    let valueAr = value;
+                    if (!multiple) {
+                        valueAr = [value];
+                    }
+                    const newValueAr = [];
+                    if (valueAr) {
+                        for (let newValue of valueAr) {
+                            if (typeof newValue === 'string') {
+                                const tmpId = (0, utils_1.getTmpId)();
+                                newValue = {
+                                    id: tmpId,
+                                    label: newValue,
+                                    [labelKey]: newValue,
+                                };
+                            }
+                            if (newValue && newValue.inputValue) {
+                                const tmpId = (0, utils_1.getTmpId)();
+                                newValue = {
+                                    id: tmpId,
+                                    label: newValue.inputValue,
+                                    [labelKey]: newValue.inputValue,
+                                };
+                            }
+                            newValueAr.push(newValue);
+                        }
+                    }
+                    field.onChange(multiple ? newValueAr : newValueAr[0]);
+                }, renderInput: (params) => (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { label: label, required: schema[model].required, margin: "normal", error: error, helperText: helperText, InputProps: Object.assign(Object.assign({}, params.InputProps), { endAdornment: (react_1.default.createElement(react_1.default.Fragment, null,
+                            !multiple && field.value && (react_1.default.createElement(IconButton_1.default, { size: "small", onClick: () => {
+                                    if ((0, utils_1.isTmpId)(field.value.id)) {
+                                        setDialog({
+                                            open: true,
+                                            loading: false,
+                                            title: 'Item sendo criado',
+                                            Body: 'Este item está sendo criado 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;
+                                    }
+                                    if (optionsModel) {
+                                        onEditModel({
+                                            fieldKey,
+                                            index,
+                                            model: optionsModel,
+                                            id: field.value.id,
+                                            labelKey,
+                                            setValue,
+                                            getValues,
+                                        });
+                                    }
+                                } },
+                                react_1.default.createElement(Edit_1.default, null))),
+                            params.InputProps.endAdornment)) }) }, other))), freeSolo: true, filterOptions: (options, params) => {
+                    const filtered = filter(options, params);
+                    const { inputValue } = params;
+                    // Suggest the creation of a new value
+                    const isExisting = options.some((option) => inputValue === option.label);
+                    if (inputValue !== '' && !isExisting) {
+                        filtered.push({
+                            inputValue,
+                            label: `Criar "${inputValue}"`,
+                        });
+                    }
+                    return filtered;
+                }, handleHomeEndKeys: true, getOptionLabel: getOptionLabel
+                    ? 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.label;
+                    }, renderOption: renderOption
+                    ? renderOption
+                    : (props, option) => (react_1.default.createElement("li", Object.assign({ key: option.id }, props), option.label)), renderTags: multiple
+                    ? (tagValue, getTagProps) => {
+                        return tagValue.map((option, index) => (react_1.default.createElement(Chip_1.default, Object.assign({}, getTagProps({ index }), { label: option.label, icon: (0, utils_1.isTmpId)(option.id) ? (react_1.default.createElement(react_1.default.Fragment, null)) : (react_1.default.createElement(IconButton_1.default, { size: "small", onClick: () => {
+                                    if (optionsModel) {
+                                        onEditModel({
+                                            fieldKey,
+                                            index,
+                                            model: optionsModel,
+                                            id: option.id,
+                                            labelKey,
+                                            setValue,
+                                            getValues,
+                                        });
+                                    }
+                                } },
+                                react_1.default.createElement(Edit_1.default, null))) }))));
+                    }
+                    : undefined }))) }));
+    }
+    return (react_1.default.createElement(react_hook_form_1.Controller, { control: control, name: name, render: ({ field }) => (react_1.default.createElement(Autocomplete_1.default, Object.assign({ key: name }, field, { id: name, options: options, disabled: options.length === 0 || schema[model].disabled === true, autoHighlight: true, isOptionEqualToValue: (option, value) => option.id === value.id, fullWidth: true, multiple: multiple, sx: sx, onChange: (e, value) => {
+                field.onChange(value);
+            }, renderInput: (params) => (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { label: label, required: schema[model].required, margin: "normal", error: error, helperText: helperText }, other))), getOptionLabel: getOptionLabel, renderOption: renderOption }))) }));
+});
+EditableAutocompleteFieldBySchema.displayName = 'EditableAutocompleteFieldBySchema';
+exports.default = EditableAutocompleteFieldBySchema;

package/dist/components/forms/inputs/FloatFieldBySchema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FieldBySchemaProps } from '../../../utils';
+export default function FloatFieldBySchema({ fieldKey, index, name, control, schema, errors, onValueChange, decimalScale, label, ...other }: Omit<FieldBySchemaProps, 'type'>): JSX.Element;

package/dist/components/forms/inputs/FloatFieldBySchema.js

@@ -0,0 +1,60 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_number_format_1 = require("react-number-format");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const react_hook_form_1 = require("react-hook-form");
+const utils_1 = require("../../../utils");
+function FloatFieldBySchema(_a) {
+    var { fieldKey, index, name, control, schema, errors, onValueChange, decimalScale, label } = _a, other = __rest(_a, ["fieldKey", "index", "name", "control", "schema", "errors", "onValueChange", "decimalScale", "label"]);
+    const model = name;
+    if (!label) {
+        label = schema[model].label;
+    }
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? errors[name].message : schema[name].help_text || '',
+        };
+    const prefix = schema[model].is_currency
+        ? 'R$ '
+        : schema[model].prefix !== ''
+            ? `${schema[model].prefix} `
+            : '';
+    const suffix = schema[model].suffix !== '' ? ` ${schema[model].suffix}` : '';
+    const decimals = decimalScale || schema[model].decimal_places || 2;
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: (_a) => {
+            var _b = _a.field, { ref } = _b, field = __rest(_b, ["ref"]);
+            const moedaInputProps = Object.assign(Object.assign({}, field), { onChange: undefined });
+            return (react_1.default.createElement(react_number_format_1.NumericFormat, Object.assign({}, moedaInputProps, other, { label: label, required: schema[model].required, onValueChange: (values, sourceInfo) => {
+                    field.onChange(values.floatValue);
+                    if (onValueChange) {
+                        onValueChange(values.floatValue);
+                    }
+                }, thousandSeparator: ".", decimalSeparator: ",", decimalScale: decimals, fixedDecimalScale: true, valueIsNumericString: true, prefix: prefix, suffix: suffix, error: error, helperText: helperText, margin: "normal", customInput: TextField_1.default })));
+        } }));
+}
+exports.default = FloatFieldBySchema;

package/dist/components/forms/inputs/TextFieldBySchema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FieldBySchemaProps } from '../../../utils';
+export default function TextFieldBySchema({ name, schema, control, errors, multiline, minRows, fieldKey, index, sx, isPassword, type, autocomplete, ...other }: FieldBySchemaProps): JSX.Element;

package/dist/components/forms/inputs/TextFieldBySchema.js

@@ -0,0 +1,44 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const utils_1 = require("../../../utils");
+function TextFieldBySchema(_a) {
+    var { name, schema, control, errors, multiline = false, minRows, fieldKey, index, sx = { mr: 2 }, isPassword = false, type, autocomplete } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "multiline", "minRows", "fieldKey", "index", "sx", "isPassword", "type", "autocomplete"]);
+    const model = name;
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    if (isPassword) {
+        type = 'password';
+        autocomplete = 'off';
+    }
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? errors[name].message : schema[name].help_text || '',
+        };
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => (react_1.default.createElement(TextField_1.default, Object.assign({}, field, other, { id: name, key: name, label: schema[model].label, required: schema[model].required, disabled: schema[model].disabled === true, margin: "normal", fullWidth: true, multiline: multiline, error: error, helperText: helperText, sx: sx, type: type, autoComplete: autocomplete, minRows: minRows }))) }));
+}
+exports.default = TextFieldBySchema;

package/dist/context/APIWrapper.d.ts

@@ -1,12 +1,12 @@
 import React from 'react';
 import { DialogType, SnackBarType } from './APIWrapperContext';
 interface APIWrapperProps {
-    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
-    handleLoading: (p: boolean) => void;
-    setSnackBar: React.Dispatch<React.SetStateAction<SnackBarType>>;
-    setDialog: React.Dispatch<React.SetStateAction<DialogType>>;
+    setLoading: (x: boolean) => void;
+    handleLoading: (x: boolean) => void;
+    setSnackBar: (x: Partial<SnackBarType>) => void;
+    setDialog: (x: Partial<DialogType>) => void;
     children: React.ReactNode;
 }
-declare function APIWrapper({ setLoading, handleLoading, setSnackBar, setDialog, children }: APIWrapperProps): JSX.Element;
+declare function APIWrapper({ setLoading, handleLoading, setSnackBar, setDialog, children, }: APIWrapperProps): JSX.Element;
 declare const _default: React.MemoExoticComponent<typeof APIWrapper>;
 export default _default;