drf-react-by-schema 0.6.4 → 0.7.0

package/dist/components/forms/FormBySchema.js

@@ -0,0 +1,164 @@
+"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 __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 __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 Box_1 = __importDefault(require("@mui/material/Box"));
+const Card_1 = __importDefault(require("@mui/material/Card"));
+const CardHeader_1 = __importDefault(require("@mui/material/CardHeader"));
+const CardContent_1 = __importDefault(require("@mui/material/CardContent"));
+const CircularProgress_1 = __importDefault(require("@mui/material/CircularProgress"));
+const FieldBySchema_1 = __importDefault(require("./FieldBySchema"));
+const styles_1 = require("../../styles");
+const APIWrapperContext_1 = require("../../context/APIWrapperContext");
+function FormBySchema(_a) {
+    var { schema, control, errors, register, multiline = false, setValue, getValues, fieldKey, labelKey = 'nome', index, optionsAC, setOptionsAC, forceReload, optionsModel, getOptionLabel, renderOption, onEditModel, sx = { mr: 0 }, options, isSemaphoric = false, label, onValueChange, decimalScale = 2, fieldsLayout: fieldsLayoutInitial, hiddenFields = [], isolatedGetAutoComplete } = _a, props = __rest(_a, ["schema", "control", "errors", "register", "multiline", "setValue", "getValues", "fieldKey", "labelKey", "index", "optionsAC", "setOptionsAC", "forceReload", "optionsModel", "getOptionLabel", "renderOption", "onEditModel", "sx", "options", "isSemaphoric", "label", "onValueChange", "decimalScale", "fieldsLayout", "hiddenFields", "isolatedGetAutoComplete"]);
+    const { getAutoComplete } = (0, APIWrapperContext_1.useAPIWrapper)();
+    const [fieldsLayout, setFieldsLayout] = (0, react_1.useState)([]);
+    const [localOptionsAC, setLocalOptionsAC] = (0, react_1.useState)(undefined);
+    const getColumns = () => {
+        const optionsACModels = [];
+        if (fieldsLayoutInitial && fieldsLayoutInitial.length > 0) {
+            for (const section of fieldsLayoutInitial) {
+                if (!section.rows) {
+                    continue;
+                }
+                for (const row of section.rows) {
+                    if (typeof row === 'string') {
+                        const field = row;
+                        if (['field', 'nested object'].includes(schema[field].type) &&
+                            !optionsACModels.includes(field)) {
+                            optionsACModels.push(field);
+                        }
+                        continue;
+                    }
+                    for (const field of row) {
+                        if (['field', 'nested object'].includes(schema[field].type) &&
+                            !optionsACModels.includes(field)) {
+                            optionsACModels.push(field);
+                        }
+                    }
+                }
+            }
+            return { newFieldsLayout: fieldsLayoutInitial, optionsACModels };
+        }
+        const rows = [];
+        for (const [key, field] of Object.entries(schema)) {
+            if (['field', 'nested object'].includes(field.type)) {
+                rows.push(key);
+                if (!optionsACModels.includes(key)) {
+                    optionsACModels.push(key);
+                }
+                continue;
+            }
+            if (!field.read_only) {
+                rows.push(key);
+            }
+        }
+        return { newFieldsLayout: [{ rows }], optionsACModels };
+    };
+    const populateOptionsAC = (optionsACModels) => __awaiter(this, void 0, void 0, function* () {
+        const newOptionsAC = {};
+        for (const model of optionsACModels) {
+            const ret = isolatedGetAutoComplete
+                ? yield isolatedGetAutoComplete(model)
+                : yield getAutoComplete(model);
+            if (ret !== false) {
+                newOptionsAC[model] = ret;
+            }
+        }
+        if (setOptionsAC) {
+            setOptionsAC(newOptionsAC);
+            return;
+        }
+        setLocalOptionsAC(newOptionsAC);
+    });
+    (0, react_1.useEffect)(() => {
+        const { newFieldsLayout, optionsACModels } = getColumns();
+        setFieldsLayout(newFieldsLayout);
+        populateOptionsAC(optionsACModels);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (forceReload) {
+            const { newFieldsLayout, optionsACModels } = getColumns();
+            setFieldsLayout(newFieldsLayout);
+            populateOptionsAC(optionsACModels);
+        }
+    }, [forceReload]);
+    if (fieldsLayout.length === 0 ||
+        (setOptionsAC && !optionsAC) ||
+        (!setOptionsAC && !localOptionsAC)) {
+        return (react_1.default.createElement(Card_1.default, { sx: styles_1.Layout.formCard },
+            react_1.default.createElement(CardContent_1.default, null,
+                react_1.default.createElement(Box_1.default, { sx: styles_1.Layout.loadingBoxWhite },
+                    react_1.default.createElement(CircularProgress_1.default, null)))));
+    }
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        register &&
+            hiddenFields.map((hiddenField) => (react_1.default.createElement("input", Object.assign({ hidden: true }, register(hiddenField), { value: getValues ? getValues(hiddenField) : null, key: hiddenField })))),
+        fieldsLayout.map((section, sectionIndex) => {
+            return (react_1.default.createElement(Card_1.default, { sx: styles_1.Layout.formCard, key: `section_${sectionIndex}` },
+                section.title && react_1.default.createElement(CardHeader_1.default, { title: section.title }),
+                react_1.default.createElement(CardContent_1.default, null,
+                    section.CustomElement && react_1.default.createElement(react_1.default.Fragment, null, section.CustomElement),
+                    section.rows && (react_1.default.createElement(react_1.default.Fragment, null, section.rows.map((row, rowIndex) => {
+                        if (typeof row === 'string') {
+                            const field = row;
+                            return (react_1.default.createElement(react_1.default.Fragment, { key: field },
+                                react_1.default.createElement(FieldBySchema_1.default, Object.assign({ name: field, schema: schema, control: control, errors: errors, multiline: multiline, setValue: setValue, getValues: getValues, fieldKey: fieldKey, labelKey: labelKey, index: index, optionsAC: setOptionsAC
+                                        ? optionsAC
+                                        : localOptionsAC, optionsModel: optionsModel, getOptionLabel: getOptionLabel, renderOption: renderOption, onEditModel: onEditModel, sx: sx, options: options, isSemaphoric: isSemaphoric, label: label, onValueChange: onValueChange, decimalScale: decimalScale }, props))));
+                        }
+                        return (react_1.default.createElement(Box_1.default, { sx: styles_1.Layout.inLineForm, key: `row_${rowIndex}` },
+                            react_1.default.createElement(react_1.default.Fragment, null, row.map((field, i, j) => (react_1.default.createElement(react_1.default.Fragment, { key: field },
+                                react_1.default.createElement(FieldBySchema_1.default, Object.assign({ name: field, schema: schema, control: control, errors: errors, multiline: multiline, setValue: setValue, getValues: getValues, fieldKey: fieldKey, labelKey: labelKey, index: index, optionsAC: optionsAC, optionsModel: optionsModel, getOptionLabel: getOptionLabel, renderOption: renderOption, onEditModel: onEditModel, sx: {
+                                        mr: i + 1 === j.length ? 0 : 2,
+                                    }, options: options, isSemaphoric: isSemaphoric, label: label, onValueChange: onValueChange, decimalScale: decimalScale }, props))))))));
+                    }))))));
+        })));
+}
+exports.default = FormBySchema;

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;