drf-react-by-schema 0.28.8 → 0.28.9

package/dist/utils/utils.js

@@ -0,0 +1,957 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToFormData = exports.slugify = exports.slugToCamelCase = exports.getPatternFormat = exports.isTmpId = exports.getTmpId = exports.errorProps = exports.toChoiceItem = exports.getChoiceByValue = exports.emptyByType = void 0;
+exports.enrichChoices = enrichChoices;
+exports.populateValues = populateValues;
+exports.buildGenericYupValidationSchema = buildGenericYupValidationSchema;
+exports.loadSinglePageDataHelper = loadSinglePageDataHelper;
+exports.getFieldErrorsFromResponse = getFieldErrorsFromResponse;
+exports.reducer = reducer;
+exports.buildDateFormatBySchema = buildDateFormatBySchema;
+exports.mergeFilterItems = mergeFilterItems;
+exports.initViewColumns = initViewColumns;
+exports.deepEqual = deepEqual;
+exports.shouldMemoUpdate = shouldMemoUpdate;
+exports.formatFileSize = formatFileSize;
+exports.getFieldsFromFieldsLayout = getFieldsFromFieldsLayout;
+exports.isFieldRequired = isFieldRequired;
+exports.extractFieldValue = extractFieldValue;
+exports.buildConditionalVisibleBySchema = buildConditionalVisibleBySchema;
+exports.showConditionalVisibleField = showConditionalVisibleField;
+exports.showConditionalVisibleFieldObj = showConditionalVisibleFieldObj;
+exports.getMapLibraries = getMapLibraries;
+exports.geometryValueToString = geometryValueToString;
+exports.parseGeoJSON = parseGeoJSON;
+const dayjs_1 = __importDefault(require("dayjs"));
+const Yup = __importStar(require("yup"));
+const string_mask_1 = __importDefault(require("string-mask"));
+const emptyByType = (field, forDatabase = false) => {
+    if (field.model_default) {
+        return field.model_default;
+    }
+    switch (field.type) {
+        case 'nested object':
+            // emptyByType must be an empty object for the database, but must be null for the mui-autocomplete component. So I had to make this ugly hack here, when we're preparing to sendo to the database:
+            return forDatabase ? {} : null;
+        case 'field':
+            if (field.child) {
+                return [];
+            }
+            return forDatabase ? undefined : null;
+        case 'list':
+        case 'multiple choice':
+            return [];
+        case 'string':
+        case 'email':
+            return '';
+        case 'integer':
+            return 0;
+        case 'array':
+            return [];
+        case 'boolean':
+            return false;
+        default:
+            return null;
+    }
+};
+exports.emptyByType = emptyByType;
+const getChoiceByValue = (value, choices) => {
+    if (!choices) {
+        return null;
+    }
+    for (const choice of choices) {
+        if (choice.value === value) {
+            return choice.display_name;
+        }
+    }
+};
+exports.getChoiceByValue = getChoiceByValue;
+// Shapes a raw choice value into a {value, display_name} object; objects that are
+// already enriched pass through unchanged.
+const toChoiceItem = (rawValue, choices) => typeof rawValue === 'object' && rawValue !== null
+    ? rawValue
+    : {
+        value: rawValue,
+        display_name: (0, exports.getChoiceByValue)(rawValue, choices),
+    };
+exports.toChoiceItem = toChoiceItem;
+// Backends return choice fields as raw values. Reshape a single 'choice' into a
+// {value, display_name} object and a 'list'/'multiple choice' into an array of
+// them, so forms and grid rows are consistent. list options live under
+// field.child?.choices (FieldBySchema reads the same source).
+function enrichChoices(rawData, schema) {
+    const out = Object.assign({}, rawData);
+    for (const [key, field] of Object.entries(schema)) {
+        if (!(key in rawData)) {
+            continue;
+        }
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'choice') {
+            const rawValue = rawData[key];
+            out[key] = rawValue ? (0, exports.toChoiceItem)(rawValue, field.choices) : (0, exports.emptyByType)(field);
+        }
+        else if ((field === null || field === void 0 ? void 0 : field.type) === 'list' || (field === null || field === void 0 ? void 0 : field.type) === 'multiple choice') {
+            const rawValue = rawData[key];
+            if (Array.isArray(rawValue)) {
+                out[key] = rawValue.map((entry) => { var _a; return (0, exports.toChoiceItem)(entry, (_a = field.child) === null || _a === void 0 ? void 0 : _a.choices); });
+            }
+        }
+    }
+    return out;
+}
+function populateValues({ data, schema }) {
+    var _a;
+    const values = {};
+    for (const [key, field] of Object.entries(schema)) {
+        if (key === 'id' && (0, exports.isTmpId)(data[key])) {
+            continue;
+        }
+        if (!data[key] && data[key] !== false && data[key] !== 0) {
+            values[key] = (0, exports.emptyByType)(field);
+            continue;
+        }
+        if (field.type === 'field' && ((_a = field.child) === null || _a === void 0 ? void 0 : _a.children)) {
+            if (Array.isArray(data[key])) {
+                const arValues = [];
+                for (const row of data[key]) {
+                    const value = populateValues({
+                        data: row,
+                        schema: field.child.children,
+                    });
+                    arValues.push(value);
+                }
+                values[key] = arValues;
+                continue;
+            }
+            values[key] = populateValues({
+                data: data[key],
+                schema: field.child.children,
+            });
+            continue;
+        }
+        if (field.type === 'choice') {
+            values[key] = data[key] ? (0, exports.toChoiceItem)(data[key], field.choices) : (0, exports.emptyByType)(field);
+            continue;
+        }
+        if (field.type === 'list' || field.type === 'multiple choice') {
+            values[key] = Array.isArray(data[key])
+                ? data[key].map((entry) => { var _a; return (0, exports.toChoiceItem)(entry, (_a = field.child) === null || _a === void 0 ? void 0 : _a.choices); })
+                : (0, exports.emptyByType)(field);
+            continue;
+        }
+        values[key] = data[key];
+    }
+    return values;
+}
+const getYupValidator = (type) => {
+    let yupFunc;
+    try {
+        switch (type) {
+            case 'slug':
+                yupFunc = Yup.string();
+                break;
+            case 'email':
+                yupFunc = Yup.string().email('Este campo deve ser um e-mail válido.');
+                break;
+            case 'integer':
+                yupFunc = Yup.number().integer('Este campo deve ser um número inteiro');
+                break;
+            case 'choice':
+                yupFunc = Yup.object();
+                break;
+            case 'list':
+                yupFunc = Yup.array();
+                break;
+            case 'field':
+                yupFunc = Yup.mixed();
+                break;
+            case 'nested object':
+                yupFunc = Yup.object();
+                break;
+            case 'date':
+                yupFunc = Yup.date();
+                break;
+            case 'string':
+                yupFunc = Yup.string();
+                break;
+            case 'number':
+            case 'float':
+                yupFunc = Yup.number();
+                break;
+            case 'decimal':
+                yupFunc = Yup.string();
+                break;
+            case 'boolean':
+                yupFunc = Yup.bool();
+                break;
+            case 'array':
+            case 'multiple choice':
+                yupFunc = Yup.array();
+                break;
+            case 'object':
+            case 'image':
+            case 'image upload':
+            case 'file':
+            case 'file upload':
+                yupFunc = Yup.object();
+                break;
+            // PostGIS geometry fields arrive as GeoJSON objects (e.g.
+            // { type: 'Point', coordinates: [...] }), so they must validate as
+            // objects rather than falling through to the default string schema.
+            case 'point':
+            case 'polygon':
+            case 'multipoint':
+            case 'multipolygon':
+            case 'geometrycollection':
+                yupFunc = Yup.object();
+                break;
+            // String-like types produced by SimpleMetadata but not needing
+            // specialized validation behave as plain strings:
+            case 'url':
+            case 'regex':
+            case 'time':
+            case 'duration':
+            case 'password':
+                yupFunc = Yup.string();
+                break;
+            default:
+                yupFunc = Yup.string();
+                break;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        yupFunc = Yup.string();
+    }
+    return yupFunc.transform((v) => (v === '' ? null : v)).nullable();
+};
+function buildGenericYupValidationSchema({ data, schema, many = false, skipFields = [], extraValidators, uiFields, }) {
+    var _a, _b;
+    const yupValidator = {};
+    for (const entry of Object.entries(schema)) {
+        const [field, fieldSchema] = entry;
+        if (!data || !(field in data) || field === 'id' || skipFields.includes(field)) {
+            continue;
+        }
+        // OneToMany or ManyToMany (built as an array-of-object schema):
+        if (fieldSchema.type === 'field' && ((_a = fieldSchema.child) === null || _a === void 0 ? void 0 : _a.children)) {
+            yupValidator[field] =
+                extraValidators && field in extraValidators
+                    ? extraValidators[field]
+                    : buildGenericYupValidationSchema({
+                        schema: fieldSchema.child.children,
+                        many: true,
+                        data: data[field],
+                        uiFields,
+                    });
+        }
+        else {
+            yupValidator[field] =
+                extraValidators && field in extraValidators
+                    ? extraValidators[field]
+                    : getYupValidator(fieldSchema.type);
+        }
+        if (isFieldRequired(fieldSchema, (uiFields || []).includes(field))) {
+            yupValidator[field] = yupValidator[field].required('Este campo é obrigatório');
+            // For required many-fields the selected items live in an array, and yup's
+            // `.required()` still allows `[]`; enforce at least one selection instead.
+            if (fieldSchema.type === 'field' && ((_b = fieldSchema.child) === null || _b === void 0 ? void 0 : _b.children)) {
+                yupValidator[field] = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    yupValidator[field].min(1, 'Este campo é obrigatório');
+            }
+        }
+        if (fieldSchema.max_length && fieldSchema.type === 'string') {
+            yupValidator[field] = yupValidator[field].max(parseInt(fieldSchema.max_length), `Este campo só pode ter no máximo ${fieldSchema.max_length} caracteres`);
+        }
+        if (fieldSchema.max_digits && fieldSchema.type === 'decimal') {
+            const maxDigits = fieldSchema.max_digits;
+            yupValidator[field] = yupValidator[field].test('max-digits', `Este número pode ter no máximo ${maxDigits} dígitos`, (val) => {
+                if (!val) {
+                    return true;
+                }
+                const digitCount = val.replace(/[^0-9]/g, '').length;
+                return digitCount <= maxDigits;
+            });
+        }
+        if (!fieldSchema.read_only && fieldSchema.validators_regex) {
+            for (const validator of fieldSchema.validators_regex) {
+                yupValidator[field] = yupValidator[field].matches(validator.regex, validator.message);
+            }
+        }
+    }
+    return many ? Yup.array().of(Yup.object().shape(yupValidator)) : Yup.object().shape(yupValidator);
+}
+function loadSinglePageDataHelper({ data, schema, columns, fieldsLayout, defaults, extraValidators, }) {
+    const mergedData = Object.assign({}, data);
+    if (defaults) {
+        for (const [field, value] of Object.entries(defaults)) {
+            if (!data[field] && typeof data[field] !== 'boolean') {
+                mergedData[field] = value;
+            }
+        }
+    }
+    const values = populateValues({ data: mergedData, schema });
+    const uiFields = fieldsLayout
+        ? getFieldsFromFieldsLayout(fieldsLayout)
+        : columns
+            ? Object.keys(columns)
+            : undefined;
+    const validationSchema = buildGenericYupValidationSchema({
+        data: values,
+        schema,
+        extraValidators,
+        uiFields,
+    });
+    const customFieldLabelsAr = fieldsLayout === null || fieldsLayout === void 0 ? void 0 : fieldsLayout.map((fieldLayout) => fieldLayout.customLabels);
+    const finalSchema = Object.assign({}, schema);
+    if (customFieldLabelsAr) {
+        for (const customFieldLabels of customFieldLabelsAr) {
+            if (!customFieldLabels) {
+                continue;
+            }
+            for (const key of Object.keys(customFieldLabels)) {
+                if (customFieldLabels[key] && (!uiFields || uiFields.includes(key))) {
+                    finalSchema[key].label = customFieldLabels[key];
+                }
+            }
+        }
+    }
+    return { values, finalSchema, validationSchema };
+}
+const errorProps = ({ errors, fieldKey, fieldKeyProp, index, }) => {
+    let error;
+    let helperText;
+    if (index) {
+        const hasErrors = errors &&
+            errors[fieldKey] &&
+            errors[fieldKey][index] &&
+            Boolean(errors[fieldKey][index][fieldKeyProp]);
+        error = hasErrors;
+        helperText = hasErrors ? errors[fieldKey][index][fieldKeyProp].message : null;
+        return { error, helperText };
+    }
+    const hasErrors = errors && errors[fieldKey] && Boolean(errors[fieldKey][fieldKeyProp]);
+    error = hasErrors;
+    helperText = hasErrors ? errors[fieldKey][fieldKeyProp].message : null;
+    return { error, helperText };
+};
+exports.errorProps = errorProps;
+/**
+ * Normalizes a DRF (Django REST Framework) validation error payload into a
+ * react-hook-form `setError`-compatible map: `{ fieldKey: { type, message } }`.
+ *
+ * DRF returns per-field errors both as `{ field: "message" }` and
+ * `{ field: ["message 1", "message 2"] }`, plus `{ non_field_errors: [...] }`.
+ * Only fields present in the given `schema` are mapped, so backend-only keys
+ * (or `non_field_errors`) are skipped and remain surfaced through the generic
+ * error message instead. This is what allows a `validate()` raised
+ * `ValidationError({"field": "..."})` to be rendered under the offending field,
+ * exactly like a yup validation error.
+ */
+function getFieldErrorsFromResponse(response, schema) {
+    const result = {};
+    if (!response || typeof response !== 'object' || Array.isArray(response)) {
+        return result;
+    }
+    for (const [key, value] of Object.entries(response)) {
+        if (key === 'non_field_errors') {
+            continue;
+        }
+        if (schema && !(key in schema)) {
+            continue;
+        }
+        const message = Array.isArray(value) ? value[0] : value;
+        if (typeof message === 'string' && message.length > 0) {
+            result[key] = { type: 'server', message };
+        }
+    }
+    return result;
+}
+const getTmpId = () => {
+    return 'tmp' + Math.floor(Math.random() * 1000000);
+};
+exports.getTmpId = getTmpId;
+const isTmpId = (id) => {
+    if (!id) {
+        return true;
+    }
+    return id === 'novo' || id.toString().slice(0, 3) === 'tmp';
+};
+exports.isTmpId = isTmpId;
+function reducer(state, newState) {
+    if (newState === null) {
+        return null;
+    }
+    if (state === null) {
+        return newState;
+    }
+    return Object.assign(Object.assign({}, state), newState);
+}
+const getPatternFormat = (type) => {
+    let format = '';
+    switch (type) {
+        case 'telefone':
+        case 'fone':
+        case 'phone':
+        case 'contact':
+        case 'contato':
+            format = '(##)#####-####';
+            break;
+        case 'cpf':
+            format = '###.###.###-##';
+            break;
+        case 'cnpj':
+            format = '##.###.###/####-##';
+            break;
+        case 'cep':
+            format = '##.###-###';
+            break;
+    }
+    return format;
+};
+exports.getPatternFormat = getPatternFormat;
+function buildDateFormatBySchema(dateViews) {
+    const defaultFormat = 'DD/MM/YYYY';
+    if (!dateViews) {
+        return defaultFormat;
+    }
+    const hasDay = dateViews.includes('day');
+    const hasMonth = dateViews.includes('month');
+    const hasYear = dateViews.includes('year');
+    if (hasDay && hasMonth && hasYear) {
+        return defaultFormat;
+    }
+    if (!hasDay && hasMonth && hasYear) {
+        return 'MM/YYYY';
+    }
+    if (!hasDay && !hasMonth && hasYear) {
+        return 'YYYY';
+    }
+    if (!hasDay && hasMonth && !hasYear) {
+        return 'MM';
+    }
+    if (hasDay && !hasMonth && !hasYear) {
+        return 'DD';
+    }
+    return defaultFormat;
+}
+const slugToCamelCase = (str, includeFirst = false) => {
+    if (!str) {
+        return '';
+    }
+    const ret = str.replace(/_([a-z])/g, function (g) {
+        return g[1].toUpperCase();
+    });
+    if (includeFirst) {
+        return ret[0].toUpperCase() + ret.slice(1);
+    }
+    return ret;
+};
+exports.slugToCamelCase = slugToCamelCase;
+const slugify = (text) => {
+    if (!text) {
+        return '';
+    }
+    return text
+        .toString()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^\w-]+/g, '')
+        .replace(/--+/g, '-');
+};
+exports.slugify = slugify;
+function mergeFilterItems(defaultFilter, filter) {
+    if (!filter && defaultFilter) {
+        return defaultFilter;
+    }
+    if (!defaultFilter && filter) {
+        return filter;
+    }
+    if (filter && defaultFilter) {
+        const items = filter.items;
+        const defaultItems = defaultFilter.items;
+        const mergedItems = defaultItems.map((defaultItem) => {
+            const itemFound = items.find((item) => item.field === defaultItem.field);
+            if (itemFound) {
+                return itemFound;
+            }
+            return defaultItem;
+        });
+        const unMergedItems = items.filter((item) => !defaultItems.map((defaultItem) => defaultItem.field).includes(item.field));
+        return Object.assign(Object.assign({}, filter), { items: [...mergedItems, ...unMergedItems] });
+    }
+    return undefined;
+}
+function initViewColumns(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ schema, columns, customColumnOperations, }) {
+        const colsPromises = columns.map((column) => __awaiter(this, void 0, void 0, function* () {
+            const field = column.field;
+            if (!schema[field]) {
+                return column;
+            }
+            const fieldSchema = schema[field];
+            // const isIndexField = indexField !== '' && field === indexField;
+            // let column = col;
+            // if (isIndexField) {
+            //   col.isIndexField = true;
+            // }
+            switch (fieldSchema.type) {
+                case 'date':
+                    column.type = 'date';
+                    const dateFormat = buildDateFormatBySchema(fieldSchema.date_views);
+                    column.valueFormatter = (value) => (value ? (0, dayjs_1.default)(value).format(dateFormat) : '');
+                    break;
+                case 'datetime':
+                    column.type = 'dateTime';
+                    column.valueFormatter = (value) => (value ? (0, dayjs_1.default)(value).format('DD/MM/YYYY HH:mm') : '');
+                    break;
+                case 'nested object':
+                    column.valueFormatter = (value) => {
+                        return !value ? '' : value.label;
+                    };
+                    break;
+                case 'field':
+                    column.valueFormatter = (value) => {
+                        return !value || !Array.isArray(value) ? '' : value.map((val) => val.label).join(', ');
+                    };
+                    break;
+                case 'choice':
+                    column.valueFormatter = (value) => {
+                        return !value ? '' : value.display_name;
+                    };
+                    break;
+                case 'list':
+                    column.valueFormatter = (value) => {
+                        return !value || !Array.isArray(value)
+                            ? ''
+                            : value.map((val) => val.display_name).join(', ');
+                    };
+                    break;
+                case 'boolean':
+                    column.valueFormatter = (value) => {
+                        return value ? 'Sim' : 'Não';
+                    };
+                    break;
+                case 'decimal':
+                case 'float':
+                    const decimalScale = fieldSchema.decimal_places || 2;
+                    column.type = 'number';
+                    column.valueFormatter = (value) => {
+                        return !value
+                            ? ''
+                            : parseFloat(value).toLocaleString('pt-BR', {
+                                minimumFractionDigits: decimalScale,
+                                maximumFractionDigits: decimalScale,
+                            });
+                    };
+                    break;
+                case 'number':
+                case 'integer':
+                    column.type = 'number';
+                    if (fieldSchema.pattern_format) {
+                        column.patternFormat = fieldSchema.pattern_format;
+                    }
+                    break;
+                case 'file upload':
+                case 'image upload':
+                    column.valueFormatter = (value) => {
+                        return !value ? '' : `${value.name.split('/').pop()} (${formatFileSize(value.size)})`;
+                    };
+                    break;
+                case 'point':
+                case 'polygon':
+                case 'multipoint':
+                case 'multipolygon':
+                case 'geometrycollection':
+                    // PostGIS geometry (GeoJSON object) is not a renderable React child;
+                    // stringify it for read-only views (detail page / mobile list).
+                    column.valueFormatter = (value) => !value ? '' : typeof value === 'string' ? value : JSON.stringify(value);
+                    break;
+                default:
+                    if (fieldSchema.pattern_format) {
+                        column.patternFormat = fieldSchema.pattern_format;
+                    }
+            }
+            // format numbers:
+            if (column.patternFormat) {
+                column.valueFormatter = (value) => {
+                    if (!value || typeof value !== 'string') {
+                        return value;
+                    }
+                    const formattedValue = new string_mask_1.default(column.patternFormat, {}).apply(value);
+                    return formattedValue;
+                };
+            }
+            // Custom column operations:
+            if (customColumnOperations) {
+                column = yield customColumnOperations(column);
+            }
+            // Finally!
+            return column;
+        }));
+        const finalCols = yield Promise.all(colsPromises);
+        return finalCols;
+    });
+}
+function deepEqual(a, b, maxIterations = 10000) {
+    const stack = [[a, b, 0]];
+    let iterations = 0;
+    while (stack.length > 0) {
+        iterations++;
+        if (iterations > maxIterations)
+            return false;
+        const [currentA, currentB] = stack.pop();
+        // 1. Strict equality (handles same reference, same primitives)
+        if (currentA === currentB)
+            continue;
+        // 2. Handle Functions (toString comparison)
+        if (typeof currentA === 'function' && typeof currentB === 'function') {
+            if (currentA.toString() !== currentB.toString())
+                return false;
+            continue;
+        }
+        // 3. Handle Dates (Object.keys doesn't work on Dates)
+        if (currentA instanceof Date && currentB instanceof Date) {
+            if (currentA.getTime() !== currentB.getTime())
+                return false;
+            continue;
+        }
+        // 4. Handle Null/Undefined/Primitives that failed the === check
+        if (currentA === null ||
+            currentB === null ||
+            typeof currentA !== 'object' ||
+            typeof currentB !== 'object') {
+            return false;
+        }
+        // 5. Handle Arrays
+        if (Array.isArray(currentA) && Array.isArray(currentB)) {
+            if (currentA.length !== currentB.length)
+                return false;
+            for (let i = currentA.length - 1; i >= 0; i--) {
+                stack.push([currentA[i], currentB[i], 0]);
+            }
+            continue;
+        }
+        // 6. Handle Objects
+        const keysA = Object.keys(currentA);
+        const keysB = Object.keys(currentB);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!Object.prototype.hasOwnProperty.call(currentB, key))
+                return false;
+            stack.push([currentA[key], currentB[key], 0]);
+        }
+    }
+    return true;
+}
+function shouldMemoUpdate(prevProps, nextProps) {
+    const propKeys = new Set([...Object.keys(prevProps), ...Object.keys(nextProps)]);
+    for (const key of propKeys) {
+        if (typeof key === 'string' && key.startsWith('_'))
+            continue;
+        const prevVal = prevProps[key];
+        const nextVal = nextProps[key];
+        // Fast path for identical references
+        if (prevVal === nextVal)
+            continue;
+        // Handle null/undefined mismatches
+        if (prevVal == null || nextVal == null) {
+            return false;
+        }
+        // Special handling for functions
+        if (typeof prevVal === 'function' && typeof nextVal === 'function') {
+            if (prevVal.toString() !== nextVal.toString()) {
+                return false;
+            }
+            continue;
+        }
+        // Deep compare objects
+        if (typeof prevVal === 'object' && typeof nextVal === 'object') {
+            if (!deepEqual(prevVal, nextVal)) {
+                return false;
+            }
+            continue;
+        }
+        // Final comparison for primitives
+        if (prevVal !== nextVal) {
+            return false;
+        }
+    }
+    return true;
+}
+const convertToFormData = (data) => {
+    const formData = new FormData();
+    Object.entries(data).forEach(([key, value]) => {
+        if (value === null) {
+            formData.append(key, ''); // Handle null values
+        }
+        else if (Array.isArray(value)) {
+            value.forEach((item) => {
+                if (typeof item === 'object') {
+                    formData.append(`${key}[]`, JSON.stringify(item));
+                }
+            });
+        }
+        else if (typeof value === 'object') {
+            formData.append(key, 'file' in value ? value.file : JSON.stringify(value));
+        }
+        else {
+            formData.append(key, value);
+        }
+    });
+    return formData;
+};
+exports.convertToFormData = convertToFormData;
+function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB'];
+    const k = 1024;
+    const dm = 1;
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const value = bytes / Math.pow(k, i);
+    const formattedValue = value.toLocaleString('pt-BR', {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: dm,
+    });
+    return `${formattedValue} ${units[i]}`;
+}
+function getFieldsFromFieldsLayout(fieldsLayout) {
+    const fields = [];
+    for (const section of fieldsLayout) {
+        if (!section.rows) {
+            continue;
+        }
+        for (const row of section.rows) {
+            if (typeof row === 'string') {
+                fields.push(row);
+                continue;
+            }
+            if (Array.isArray(row)) {
+                for (const field of row) {
+                    if (typeof field === 'string') {
+                        fields.push(field);
+                        continue;
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    return fields;
+}
+function isFieldRequired(fieldSchema, isInForm) {
+    if (!fieldSchema || (fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.type) === 'boolean') {
+        return false;
+    }
+    if (fieldSchema.required) {
+        return true;
+    }
+    if (fieldSchema.model_required) {
+        return true;
+    }
+    if (fieldSchema.ui_required && (typeof isInForm === 'undefined' || isInForm === true)) {
+        return true;
+    }
+    return false;
+}
+function extractFieldValue(genericValue) {
+    if (!genericValue) {
+        return null;
+    }
+    if (Array.isArray(genericValue)) {
+        return genericValue.map(({ value }) => (typeof value === 'object' ? value.value : value));
+    }
+    if (typeof genericValue === 'object') {
+        if ('id' in genericValue) {
+            return genericValue.id;
+        }
+        const value = genericValue.value;
+        if (typeof value === 'object') {
+            return value.value;
+        }
+        return value;
+    }
+    return genericValue;
+}
+function buildConditionalVisibleBySchema(schema) {
+    var _a;
+    const conditionalVisible = [];
+    if (!schema) {
+        return conditionalVisible;
+    }
+    for (const fieldKey of Object.keys(schema)) {
+        const thisConditionalVisible = (_a = schema[fieldKey]) === null || _a === void 0 ? void 0 : _a.conditional_visible;
+        if (!thisConditionalVisible || thisConditionalVisible.length === 0) {
+            continue;
+        }
+        if (typeof thisConditionalVisible[0] === 'string') {
+            conditionalVisible.push({
+                target: fieldKey,
+                source: thisConditionalVisible[0],
+                sourceValue: thisConditionalVisible[1],
+            });
+            continue;
+        }
+        for (const subConditionalVisible of thisConditionalVisible) {
+            if (typeof subConditionalVisible === 'string') {
+                continue;
+            }
+            conditionalVisible.push({
+                target: fieldKey,
+                source: subConditionalVisible[0],
+                sourceValue: subConditionalVisible[1],
+            });
+        }
+    }
+    return conditionalVisible;
+}
+function showConditionalVisibleField(field, conditionalVisible, values) {
+    if (typeof field !== 'string' ||
+        !conditionalVisible ||
+        conditionalVisible.filter((item) => item.target === field).length === 0 ||
+        !values) {
+        return true;
+    }
+    const sources = conditionalVisible
+        .map((item, index) => {
+        const refField = item.target;
+        const refValue = item.sourceValue;
+        const value = values[index];
+        return refField === field &&
+            (value === refValue ||
+                (value && value.value === refValue) ||
+                (Array.isArray(value) &&
+                    value.find((singleValue) => singleValue === refValue ||
+                        (typeof singleValue === 'object' && singleValue.value === refValue))))
+            ? item
+            : { target: false };
+    })
+        .filter((item) => item.target === field);
+    return sources.length > 0;
+}
+function showConditionalVisibleFieldObj(field, conditionalVisible, values) {
+    if (typeof field !== 'string' ||
+        !conditionalVisible ||
+        conditionalVisible.filter((item) => item.target === field).length === 0 ||
+        !values) {
+        return true;
+    }
+    const sources = conditionalVisible
+        .map((item) => {
+        const refField = item.target;
+        const refValue = item.sourceValue;
+        const value = extractFieldValue(values[item.source]);
+        return refField === field &&
+            (value === refValue || (Array.isArray(value) && value.includes(refValue)))
+            ? item
+            : { target: false };
+    })
+        .filter((item) => item.target === field);
+    return sources.length > 0;
+}
+// --- Optional OSM (leaflet) geometry support --------------------------------
+// PostGIS geometry fields arrive from the backend as GeoJSON (type point /
+// polygon / multipoint / multipolygon / geometrycollection). Editing them uses
+// leaflet + leaflet-draw when those optional libraries are installed in the
+// consuming app; otherwise the UI falls back to plain text editing.
+/**
+ * Detect whether the consuming app has installed leaflet + leaflet-draw.
+ * Uses CJS require so that the bundler does not fail to build when they are
+ * absent; returns null so callers can fall back to text inputs.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getMapLibraries() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const L = require('leaflet');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('leaflet-draw');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('react-leaflet');
+        if (L && L.map && L.Control && typeof L.Control.Draw === 'function') {
+            return L;
+        }
+    }
+    catch (_a) {
+        // leaflet / leaflet-draw / react-leaflet not installed -> no map support
+    }
+    return null;
+}
+/** Normalize a GeoJSON value (object, JSON string or null) to a string. */
+function geometryValueToString(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch (_a) {
+        return '';
+    }
+}
+/** Parse a GeoJSON value (object or JSON string) into an object, or null. */
+function parseGeoJSON(geoType, rawValue) {
+    const text = geometryValueToString(rawValue);
+    if (!text) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed.type === 'string' && (0, exports.slugify)(parsed.type) === geoType
+            ? parsed
+            : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}