drf-react-by-schema 0.28.8 → 0.28.9

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

@@ -0,0 +1,272 @@
+"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 __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, _) => {
+    var _b;
+    var { control, schema, errors, setValue, getValues, fieldKey, labelKey = 'nome', index, name = 'name', optionsAC, optionsModel, getOptionLabel, renderOption, onEditModel, sx = { mr: 2 }, onValueChange, multiple = false, disabled, fieldsLayout, autoFocus } = _a, other = __rest(_a, ["control", "schema", "errors", "setValue", "getValues", "fieldKey", "labelKey", "index", "name", "optionsAC", "optionsModel", "getOptionLabel", "renderOption", "onEditModel", "sx", "onValueChange", "multiple", "disabled", "fieldsLayout", "autoFocus"]);
+    const { setDialog } = (0, APIWrapperContext_1.useAPIWrapper)();
+    const [options, setOptions] = (0, react_1.useState)(null);
+    const model = name;
+    (0, react_1.useEffect)(() => {
+        if (optionsAC && optionsModel && optionsAC[optionsModel]) {
+            setOptions(optionsAC[optionsModel]);
+        }
+    }, [optionsAC, optionsModel]);
+    (0, react_1.useEffect)(() => {
+        if (!getValues || !setValue || !options) {
+            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);
+    }, [options, setValue, getValues, model, multiple]);
+    if (!(name in schema)) {
+        console.error(`EditableAutocompleteFieldBySchema: could not find schema for ${name}! Not rendering`);
+        return;
+    }
+    const fieldSchema = schema[name];
+    const label = fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.label;
+    if (!optionsModel) {
+        optionsModel = model;
+    }
+    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] ? (_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message : (fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.help_text) || '',
+        };
+    if (!options) {
+        return null;
+    }
+    if (!disabled &&
+        !(fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.disabled) &&
+        fieldSchema.related_editable !== false &&
+        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: (fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.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)();
+                                if (onEditModel) {
+                                    // Open modal to save new item:
+                                    onEditModel({
+                                        fieldKey,
+                                        index,
+                                        model: optionsModel,
+                                        id: tmpId,
+                                        labelKey,
+                                        setValue,
+                                        getValues,
+                                        fieldsLayout,
+                                        initialValuesPartial: {
+                                            [labelKey]: newValue.inputValue,
+                                        },
+                                    });
+                                }
+                                // Define new Item as an "optimistic response"
+                                newValue = {
+                                    id: tmpId,
+                                    label: newValue.inputValue,
+                                    [labelKey]: newValue.inputValue,
+                                };
+                            }
+                            newValueAr.push(newValue);
+                        }
+                    }
+                    field.onChange(multiple ? newValueAr : newValueAr[0]);
+                    if (onValueChange) {
+                        onValueChange(e);
+                    }
+                }, renderInput: (params) => (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { label: label, required: (0, utils_1.isFieldRequired)(fieldSchema) && !multiple, margin: "normal", error: error, autoFocus: autoFocus, 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", "aria-label": "Editar", 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,
+                                            fieldsLayout,
+                                        });
+                                    }
+                                } },
+                                react_1.default.createElement(Edit_1.default, null))),
+                            params.InputProps.endAdornment)) }) }, other))), freeSolo: true, filterOptions: (filteredOptions, params) => {
+                    let filtered = filter(filteredOptions, params);
+                    const { inputValue } = params;
+                    const inputValueSlug = (0, utils_1.slugify)(inputValue);
+                    const inputValueLength = inputValueSlug.length;
+                    // Suggest the creation of a new value
+                    const isExisting = filteredOptions.find((option) => inputValueSlug === (0, utils_1.slugify)(option.label));
+                    if (inputValue !== '' && !isExisting) {
+                        filtered.push({
+                            inputValue,
+                            label: `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, getOptionKey: ({ id }) => id, 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({}, props), option.label), renderTags: multiple
+                    ? (tagValue, getTagProps) => {
+                        return tagValue.map((option, index) => (
+                        // eslint-disable-next-line react/jsx-key
+                        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", "aria-label": "Editar", onClick: () => {
+                                    if (optionsModel) {
+                                        onEditModel({
+                                            fieldKey,
+                                            index,
+                                            model: optionsModel,
+                                            id: option.id,
+                                            labelKey,
+                                            setValue,
+                                            getValues,
+                                            fieldsLayout,
+                                        });
+                                    }
+                                } },
+                                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: (fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.disabled) === true || disabled === true, autoHighlight: true, isOptionEqualToValue: (option, value) => option.id === value.id, fullWidth: true, multiple: multiple, sx: sx, onChange: (e, value) => {
+                field.onChange(value);
+                if (onValueChange) {
+                    onValueChange(e);
+                }
+            }, renderInput: (params) => (react_1.default.createElement(TextField_1.default, Object.assign({}, params, { label: label, required: (0, utils_1.isFieldRequired)(fieldSchema) && !multiple, margin: "normal", error: error, autoFocus: autoFocus, helperText: helperText }, other))), getOptionKey: ({ id }) => id, getOptionLabel: getOptionLabel, renderOption: renderOption }))) }));
+});
+EditableAutocompleteFieldBySchema.displayName = 'EditableAutocompleteFieldBySchema';
+exports.default = EditableAutocompleteFieldBySchema;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FieldBySchemaProps } from '../../../@types';
+export default function FileFieldBySchema({ name, schema, control, errors, fieldKey, index, sx, onValueChange, autoFocus, disabled, ...other }: FieldBySchemaProps): React.JSX.Element | undefined;
+//# sourceMappingURL=FileFieldBySchema.d.ts.map

package/dist/components/forms/inputs/FileFieldBySchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileFieldBySchema.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/FileFieldBySchema.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAc1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAgBrD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EACxC,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,QAAQ,EACR,KAAK,EACL,EAAc,EACd,aAAa,EACb,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,kBAAkB,iCAgJpB"}

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

@@ -0,0 +1,144 @@
+"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 });
+exports.default = FileFieldBySchema;
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const styles_1 = require("@mui/material/styles");
+const Button_1 = __importDefault(require("@mui/material/Button"));
+const FormControlLabel_1 = __importDefault(require("@mui/material/FormControlLabel"));
+const FormControl_1 = __importDefault(require("@mui/material/FormControl"));
+const FormLabel_1 = __importDefault(require("@mui/material/FormLabel"));
+const FormHelperText_1 = __importDefault(require("@mui/material/FormHelperText"));
+const Typography_1 = __importDefault(require("@mui/material/Typography"));
+const Box_1 = __importDefault(require("@mui/material/Box"));
+const CloudUpload_1 = __importDefault(require("@mui/icons-material/CloudUpload"));
+const utils_1 = require("../../../utils");
+const DRFReactBySchemaContext_1 = require("../../../context/DRFReactBySchemaContext");
+const VisuallyHiddenInput = (0, styles_1.styled)('input')({
+    clip: 'rect(0 0 0 0)',
+    clipPath: 'inset(50%)',
+    height: 1,
+    overflow: 'hidden',
+    position: 'absolute',
+    bottom: 0,
+    left: 0,
+    whiteSpace: 'nowrap',
+    width: 1,
+});
+function FileFieldBySchema(_a) {
+    var _b;
+    var { name, schema, control, errors, fieldKey, index, sx = { mr: 2 }, onValueChange, autoFocus, disabled } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "fieldKey", "index", "sx", "onValueChange", "autoFocus", "disabled"]);
+    const { serverEndPoint } = (0, DRFReactBySchemaContext_1.useDRFReactBySchema)();
+    if (!(name in schema)) {
+        console.error(`FileFieldBySchema: could not find schema for ${name}! Not rendering`);
+        return;
+    }
+    const fieldSchema = schema[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] ? (_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message : fieldSchema.help_text || '',
+        };
+    const fileTypeStr = fieldSchema.type === 'image upload' ? 'imagem' : 'documento';
+    const accept = fieldSchema.allowed_mime_types
+        ? fieldSchema.allowed_mime_types.join(', ')
+        : fieldSchema.type === 'image upload'
+            ? '/image*'
+            : '*';
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => {
+            var _a, _b, _c, _d;
+            return (react_1.default.createElement(Box_1.default, { sx: Object.assign({ width: '100%' }, sx) },
+                react_1.default.createElement(FormControl_1.default, { component: "fieldset", sx: { width: '100%' } },
+                    react_1.default.createElement(FormLabel_1.default, { component: "legend" }, fieldSchema.label),
+                    react_1.default.createElement(FormControlLabel_1.default, { control: react_1.default.createElement(Box_1.default, { sx: {
+                                display: 'flex',
+                                flexDirection: 'column',
+                                alignItems: 'center',
+                                width: '100%',
+                            } },
+                            (((_a = field.value) === null || _a === void 0 ? void 0 : _a.url) || ((_b = field.value) === null || _b === void 0 ? void 0 : _b.src)) &&
+                                fieldSchema.type === 'image upload' && (react_1.default.createElement("img", { src: field.value.url
+                                    ? `${serverEndPoint === null || serverEndPoint === void 0 ? void 0 : serverEndPoint.url}${field.value.url}`
+                                    : field.value.src, alt: field.value.name, title: field.value.name, style: {
+                                    width: '100%',
+                                    maxHeight: '200px',
+                                    objectFit: 'cover',
+                                    maxWidth: '450px',
+                                } })),
+                            ((_c = field.value) === null || _c === void 0 ? void 0 : _c.name) && (react_1.default.createElement(Typography_1.default, { variant: "body2", sx: { mb: 1 } },
+                                field.value.name.split('/').pop(),
+                                " (",
+                                (0, utils_1.formatFileSize)(field.value.size),
+                                ")")),
+                            react_1.default.createElement(Button_1.default, { component: "label", variant: "outlined", startIcon: react_1.default.createElement(CloudUpload_1.default, null), disabled: fieldSchema.disabled === true || disabled === true, color: error ? 'error' : 'primary' },
+                                field.value ? `Trocar ${fileTypeStr}` : `Enviar ${fileTypeStr}`,
+                                react_1.default.createElement(VisuallyHiddenInput, Object.assign({ type: "file", onChange: (e) => {
+                                        var _a;
+                                        const file = (_a = e.target.files) === null || _a === void 0 ? void 0 : _a[0];
+                                        if (file) {
+                                            if (file.type.startsWith('image/')) {
+                                                const reader = new FileReader();
+                                                reader.onload = (event) => {
+                                                    const src = event.target ? event.target.result : undefined;
+                                                    const newValue = {
+                                                        name: file.name,
+                                                        size: file.size,
+                                                        type: file.type,
+                                                        src,
+                                                        file,
+                                                    };
+                                                    field.onChange(newValue);
+                                                    if (onValueChange) {
+                                                        onValueChange(newValue);
+                                                    }
+                                                };
+                                                reader.readAsDataURL(file);
+                                                return;
+                                            }
+                                            const newValue = {
+                                                name: file.name,
+                                                size: file.size,
+                                                type: file.type,
+                                                file,
+                                            };
+                                            field.onChange(newValue);
+                                            if (onValueChange) {
+                                                onValueChange(newValue);
+                                            }
+                                        }
+                                    }, accept: accept, autoFocus: autoFocus }, other)))), label: '', 
+                        // labelPlacement="top"
+                        required: (0, utils_1.isFieldRequired)(fieldSchema), sx: {
+                            width: '100%',
+                            alignItems: 'flex-start',
+                            marginLeft: 0,
+                        } }),
+                    react_1.default.createElement(FormHelperText_1.default, { error: error, sx: {
+                            ml: 'calc(14px + 1em)',
+                            mt: ((_d = field.value) === null || _d === void 0 ? void 0 : _d.name) ? 0 : 1, // Adjust spacing if no file is selected
+                        } }, helperText))));
+        } }));
+}

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FieldBySchemaProps } from '../../../@types';
+export default function FloatFieldBySchema({ name, schema, control, errors, fieldKey, index, onValueChange, decimalScale, label, autoFocus, disabled, ...other }: Omit<FieldBySchemaProps, 'type'>): React.JSX.Element | undefined;
+//# sourceMappingURL=FloatFieldBySchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FloatFieldBySchema.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/FloatFieldBySchema.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EACzC,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,QAAQ,EACR,KAAK,EACL,aAAa,EACb,YAAY,EACZ,KAAK,EACL,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,iCA0ElC"}

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

@@ -0,0 +1,64 @@
+"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 });
+exports.default = FloatFieldBySchema;
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const react_number_format_1 = require("react-number-format");
+const utils_1 = require("../../../utils");
+function FloatFieldBySchema(_a) {
+    var _b;
+    var { name, schema, control, errors, fieldKey, index, onValueChange, decimalScale, label, autoFocus, disabled } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "fieldKey", "index", "onValueChange", "decimalScale", "label", "autoFocus", "disabled"]);
+    if (!(name in schema)) {
+        console.error(`FloatFieldBySchema: could not find schema for ${name}! Not rendering`);
+        return;
+    }
+    const fieldSchema = schema[name];
+    if (!label) {
+        label = fieldSchema.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] ? (_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message : fieldSchema.help_text || '',
+        };
+    const prefix = fieldSchema.is_currency
+        ? 'R$ '
+        : fieldSchema.prefix !== ''
+            ? `${fieldSchema.prefix} `
+            : '';
+    const suffix = fieldSchema.suffix !== '' ? ` ${fieldSchema.suffix}` : '';
+    const decimals = decimalScale || fieldSchema.decimal_places || 2;
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => {
+            const moedaInputProps = Object.assign(Object.assign({}, field), { ref: undefined, onChange: undefined });
+            return (react_1.default.createElement(react_number_format_1.NumericFormat, Object.assign({}, moedaInputProps, other, { label: label, disabled: fieldSchema.disabled === true || disabled === true, required: (0, utils_1.isFieldRequired)(fieldSchema), onValueChange: (values) => {
+                    field.onChange(values.floatValue);
+                    if (onValueChange) {
+                        onValueChange(values.floatValue);
+                    }
+                }, style: { width: '100%' }, thousandSeparator: ".", decimalSeparator: ",", decimalScale: decimals, fixedDecimalScale: true, valueIsNumericString: true, prefix: prefix, suffix: suffix, error: error, helperText: helperText, margin: "normal", customInput: TextField_1.default, autoFocus: autoFocus })));
+        } }));
+}

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { FieldBySchemaProps, GeometryFieldType, TField } from '../../../@types';
+export interface GeometryFieldBySchemaProps<T extends TField = void> extends FieldBySchemaProps<T> {
+    geometry: GeometryFieldType;
+    height?: number;
+}
+export default function GeometryFieldBySchema({ name, schema, control, errors, geometry, fieldKey, index, sx, autoFocus, disabled, height, onValueChange, ...other }: GeometryFieldBySchemaProps): React.JSX.Element | undefined;
+//# sourceMappingURL=GeometryFieldBySchema.d.ts.map

package/dist/components/forms/inputs/GeometryFieldBySchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeometryFieldBySchema.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/GeometryFieldBySchema.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAW1B,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGhF,MAAM,WAAW,0BAA0B,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAChG,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAC5C,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,EAAc,EACd,SAAS,EACT,QAAQ,EACR,MAAM,EACN,aAAa,EACb,GAAG,KAAK,EACT,EAAE,0BAA0B,iCAyE5B"}

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

@@ -0,0 +1,61 @@
+"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 });
+exports.default = GeometryFieldBySchema;
+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");
+const MapGeometryPicker_1 = __importDefault(require("./MapGeometryPicker"));
+function GeometryFieldBySchema(_a) {
+    var _b;
+    var { name, schema, control, errors, geometry, fieldKey, index, sx = { mr: 2 }, autoFocus, disabled, height, onValueChange } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "geometry", "fieldKey", "index", "sx", "autoFocus", "disabled", "height", "onValueChange"]);
+    if (!(name in schema)) {
+        console.error(`GeometryFieldBySchema: could not find schema for ${name}! Not rendering`);
+        return;
+    }
+    const fieldSchema = schema[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] ? (_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message : fieldSchema.help_text || '',
+        };
+    const mapAvailable = Boolean((0, utils_1.getMapLibraries)());
+    const multiline = geometry !== 'point';
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => {
+            const currentValue = (0, utils_1.geometryValueToString)(field.value);
+            if (mapAvailable) {
+                return (react_1.default.createElement(MapGeometryPicker_1.default, { geometry: geometry, value: currentValue, onChange: (geoJSON) => {
+                        // The picker emits GeoJSON as a string; the form (and yup)
+                        // expects a GeoJSON object, so normalize it back.
+                        const normalized = (0, utils_1.parseGeoJSON)(geometry, geoJSON);
+                        field.onChange(normalized);
+                        if (onValueChange)
+                            onValueChange(normalized);
+                    }, label: fieldSchema.label, error: error, helperText: helperText, height: height }));
+            }
+            return (react_1.default.createElement(TextField_1.default, Object.assign({}, other, { id: name, value: currentValue, label: fieldSchema.label, required: (0, utils_1.isFieldRequired)(fieldSchema), disabled: fieldSchema.disabled === true || disabled, onChange: (e) => {
+                    const normalized = (0, utils_1.parseGeoJSON)(geometry, e.target.value);
+                    field.onChange(normalized);
+                    if (onValueChange)
+                        onValueChange(normalized);
+                }, margin: "normal", fullWidth: true, multiline: multiline, minRows: multiline ? 4 : 0, error: error, helperText: helperText, sx: sx, autoFocus: autoFocus })));
+        } }));
+}

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import { SxProps, Theme } from '@mui/material/styles';
+import 'leaflet/dist/leaflet.css';
+import 'leaflet-draw';
+import 'leaflet-draw/dist/leaflet.draw.css';
+import { GeometryFieldType } from '../../../@types';
+interface MapGeometryPickerProps {
+    geometry: GeometryFieldType;
+    value: string;
+    label?: string;
+    onChange: (geoJSON: string | null) => void;
+    error?: boolean;
+    helperText?: string;
+    sx?: SxProps<Theme>;
+    height?: number;
+}
+export default function MapGeometryPicker({ geometry, value, label, onChange, error, helperText, sx, height, }: MapGeometryPickerProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=MapGeometryPicker.d.ts.map

package/dist/components/forms/inputs/MapGeometryPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapGeometryPicker.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/MapGeometryPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAIjD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAY,MAAM,sBAAsB,CAAC;AAGhE,OAAO,0BAA0B,CAAC;AAElC,OAAO,cAAc,CAAC;AACtB,OAAO,oCAAoC,CAAC;AAI5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMpD,UAAU,sBAAsB;IAC9B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC3C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,EAAE,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAwRD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EACxC,QAAQ,EACR,KAAK,EACL,KAAK,EACL,QAAQ,EACR,KAAK,EACL,UAAU,EACV,EAAE,EACF,MAAY,GACb,EAAE,sBAAsB,qBAuDxB"}