@arquimedes.co/eureka-forms 3.0.71-test → 3.0.72

package/dist/Shared/ErkLocationField/ErkLocationField.js

@@ -0,0 +1,128 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import { Dialog, DialogActions, DialogContent, DialogTitle } from '@mui/material';
+import { AddressFieldMode, LocationInputMode, } from '../../@Types/LocationFormStep';
+import ErkAddressAutocomplete from '../ErkAddressAutocomplete/ErkAddressAutocomplete';
+import { reverseGeocode } from '../ErkAddressAutocomplete/googlePlaces';
+import { applyAddressFields, fieldConfig } from './addressFields';
+import ErkTextField from '../ErkTextField/ErkTextField';
+import ErkButton from '../ErkButton/ErkButton';
+import ErkIconButton from '../ErkIconButton/ErkIconButton';
+import LocationIcon from '../../Icons/LocationIcon';
+import EditIcon from '../../Icons/EditIcon';
+import CloseIcon from '../../Icons/CloseIcon';
+import styles from './ErkLocationField.module.css';
+/** Claves que el formulario manual exige (si no están omitidas ni fijas). */
+const MANUAL_REQUIRED_KEYS = ['street', 'city', 'country'];
+/** Dirección legible a partir del desglose, en el orden natural de una dirección. */
+function composeAddress(detail) {
+    return [
+        detail.street,
+        detail.streetNumber,
+        detail.unit ? `Apto/Int ${detail.unit}` : '',
+        detail.neighborhood,
+        detail.city,
+        detail.state,
+        detail.country,
+    ]
+        .filter(Boolean)
+        .join(', ');
+}
+/**
+ * Campo de ubicación: una sola fila con el buscador de direcciones (Base UI +
+ * Google Places) y botones de acción — GPS y edición manual (en modal). Al
+ * seleccionar, el campo muestra la dirección con opciones de editar/limpiar.
+ * La config por campo (fijo / omitir) se aplica a todos los modos.
+ */
+function ErkLocationField({ value, onChange, allowedModes, addressFields, regionCodes = ['co'], error = false, helperText, required = false, readOnly = false, inputRef, }) {
+    const apiKey = import.meta.env.VITE_GOOGLE_MAPS_API_KEY ?? '';
+    const canGoogle = allowedModes.includes(LocationInputMode.GOOGLE_PLACES);
+    const canGps = allowedModes.includes(LocationInputMode.GPS);
+    const canManual = allowedModes.includes(LocationInputMode.MANUAL);
+    const [gpsLoading, setGpsLoading] = useState(false);
+    const [gpsError, setGpsError] = useState(null);
+    const [manualOpen, setManualOpen] = useState(false);
+    const [manualDetail, setManualDetail] = useState({});
+    const handleGoogle = useCallback((resolved) => {
+        onChange({ ...resolved, addressDetail: applyAddressFields(resolved.addressDetail ?? {}, addressFields) });
+    }, [onChange, addressFields]);
+    const handleGps = useCallback(() => {
+        if (!navigator.geolocation) {
+            setGpsError('La geolocalización no es compatible con este navegador.');
+            return;
+        }
+        setGpsLoading(true);
+        setGpsError(null);
+        navigator.geolocation.getCurrentPosition((position) => {
+            const lat = position.coords.latitude;
+            const lng = position.coords.longitude;
+            void reverseGeocode(apiKey, lat, lng)
+                .then(({ address, addressDetail }) => {
+                onChange({
+                    source: LocationInputMode.GPS,
+                    latitude: lat,
+                    longitude: lng,
+                    address: address ?? `${lat.toFixed(6)}, ${lng.toFixed(6)}`,
+                    addressDetail: applyAddressFields(addressDetail, addressFields),
+                });
+            })
+                .finally(() => setGpsLoading(false));
+        }, (err) => {
+            let message = 'No se pudo obtener la ubicación GPS.';
+            if (err.code === err.PERMISSION_DENIED) {
+                message =
+                    'Permiso denegado para acceder a la ubicación. Asegúrate de habilitar los permisos en tu navegador y en los Ajustes del Sistema (Privacidad y seguridad > Localización).';
+            }
+            else if (err.code === err.TIMEOUT) {
+                message =
+                    'Tiempo de espera agotado al obtener la ubicación. Si estás en Mac, asegúrate de activar el Wi-Fi para ayudar a la localización, o introduce la dirección manualmente.';
+            }
+            setGpsError(message);
+            setGpsLoading(false);
+        }, { enableHighAccuracy: false, timeout: 15000, maximumAge: 300000 });
+    }, [apiKey, onChange, addressFields]);
+    const openManual = useCallback(() => {
+        setManualDetail(value?.addressDetail ?? {});
+        setManualOpen(true);
+    }, [value]);
+    const manualFieldValue = useCallback((key) => {
+        const config = fieldConfig(addressFields, key);
+        if (config.mode === AddressFieldMode.FIXED)
+            return config.fixedValue ?? '';
+        return manualDetail[key] ?? '';
+    }, [addressFields, manualDetail]);
+    const canSaveManual = MANUAL_REQUIRED_KEYS.every((key) => {
+        const config = fieldConfig(addressFields, key);
+        if (config.mode === AddressFieldMode.OMIT)
+            return true;
+        if (config.mode === AddressFieldMode.FIXED)
+            return !!config.fixedValue;
+        return !!manualDetail[key];
+    });
+    const saveManual = () => {
+        if (!canSaveManual)
+            return;
+        const detail = applyAddressFields(manualDetail, addressFields);
+        onChange({ source: LocationInputMode.MANUAL, address: composeAddress(detail), addressDetail: detail });
+        setManualOpen(false);
+    };
+    const clearValue = () => {
+        onChange(null);
+        setGpsError(null);
+    };
+    const manualField = (key, label, requiredField = false) => {
+        const config = fieldConfig(addressFields, key);
+        if (config.mode === AddressFieldMode.OMIT)
+            return null;
+        const fixed = config.mode === AddressFieldMode.FIXED;
+        return (_jsx(ErkTextField, { label: fixed ? `${label} (fijo)` : label, value: manualFieldValue(key), readOnly: fixed, required: requiredField && !fixed, onChange: (text) => setManualDetail((detail) => ({ ...detail, [key]: text || undefined })) }));
+    };
+    // Vista de solo lectura: tarjeta con el resumen de la ubicación
+    if (readOnly) {
+        return (_jsx("div", { className: styles.readOnlyContainer, children: _jsxs("div", { className: styles.readOnlyCard, children: [_jsx("div", { className: styles.readOnlyIcon, children: _jsx(LocationIcon, { fill: "var(--eureka-primary)" }) }), _jsxs("div", { className: styles.readOnlyDetails, children: [value?.name && _jsx("span", { className: styles.readOnlyName, children: value.name }), _jsx("span", { className: styles.readOnlyAddress, children: value?.address ?? 'Ubicación no proporcionada' }), value?.latitude !== undefined && value?.longitude !== undefined && (_jsxs("span", { className: styles.readOnlyCoords, children: ["Coordenadas: ", value.latitude.toFixed(6), ", ", value.longitude.toFixed(6)] }))] })] }) }));
+    }
+    return (_jsxs("div", { className: styles.container, children: [_jsx("div", { className: styles.inputRow, children: value?.address ? (_jsxs(_Fragment, { children: [_jsx("div", { className: styles.grow, children: _jsx("input", { ref: inputRef, className: error ? `${styles.plainInput} ${styles.plainInputError}` : styles.plainInput, value: value.address, readOnly: true, "aria-label": "Ubicaci\u00F3n seleccionada" }) }), canManual && (_jsx(ErkIconButton, { title: "Editar direcci\u00F3n manualmente", onClick: openManual, children: _jsx(EditIcon, { fill: "currentColor" }) })), _jsx(ErkIconButton, { title: "Limpiar selecci\u00F3n", onClick: clearValue, children: _jsx(CloseIcon, { fill: "currentColor" }) })] })) : (_jsxs(_Fragment, { children: [_jsx("div", { className: styles.grow, children: canGoogle ? (_jsx(ErkAddressAutocomplete, { value: value, onChange: handleGoogle, regionCodes: regionCodes, error: error, required: required, inputRef: inputRef })) : canManual ? (_jsx("input", { ref: inputRef, className: error ? `${styles.plainInput} ${styles.plainInputError}` : styles.plainInput, placeholder: "Ingresa una ubicaci\u00F3n...", value: value?.address ?? '', required: required, onChange: (e) => onChange(e.target.value
+                                    ? { source: LocationInputMode.MANUAL, address: e.target.value }
+                                    : null) })) : (_jsx("input", { ref: inputRef, className: error ? `${styles.plainInput} ${styles.plainInputError}` : styles.plainInput, placeholder: "Usa el bot\u00F3n para obtener tu ubicaci\u00F3n", value: "", readOnly: true })) }), canGps && (_jsx(ErkIconButton, { title: "Obtener ubicaci\u00F3n por GPS", loading: gpsLoading, onClick: handleGps, children: _jsx(LocationIcon, { fill: "currentColor" }) })), canManual && (_jsx(ErkIconButton, { title: "Ingresar direcci\u00F3n manualmente", onClick: openManual, children: _jsx(EditIcon, { fill: "currentColor" }) }))] })) }), (gpsError ?? helperText) && (_jsx("div", { className: error || gpsError ? styles.errorText : styles.helperText, children: gpsError ?? helperText })), _jsxs(Dialog, { open: manualOpen, onClose: () => setManualOpen(false), maxWidth: "sm", fullWidth: true, slotProps: { paper: { className: styles.dialogPaper } }, children: [_jsx(DialogTitle, { className: styles.dialogTitle, children: "Ingresar Direcci\u00F3n" }), _jsx(DialogContent, { className: styles.dialogContent, children: _jsxs("div", { className: styles.manualGrid, children: [_jsx("div", { className: styles.manualRow, children: _jsx("div", { className: styles.col12, children: manualField('street', 'Calle / Carrera / Avenida (Línea 1)', true) }) }), _jsxs("div", { className: styles.manualRow, children: [_jsx("div", { className: styles.col6, children: manualField('streetNumber', 'Número / Portal') }), _jsx("div", { className: styles.col6, children: manualField('unit', 'Apto / Oficina / Interior') })] }), _jsxs("div", { className: styles.manualRow, children: [_jsx("div", { className: styles.col6, children: manualField('neighborhood', 'Barrio / Zona') }), _jsx("div", { className: styles.col6, children: manualField('city', 'Ciudad', true) })] }), _jsxs("div", { className: styles.manualRow, children: [_jsx("div", { className: styles.col4, children: manualField('state', 'Estado / Provincia / Dpto') }), _jsx("div", { className: styles.col4, children: manualField('postalCode', 'Código Postal') }), _jsx("div", { className: styles.col4, children: manualField('country', 'País', true) })] })] }) }), _jsxs(DialogActions, { style: { padding: '16px 0 0 0', gap: '12px' }, children: [_jsx(ErkButton, { text: "Cancelar", variant: "outlined", onClick: () => setManualOpen(false) }), _jsx(ErkButton, { text: "Guardar", variant: "contained", disabled: !canSaveManual, onClick: saveManual })] })] })] }));
+}
+export default ErkLocationField;

package/dist/Shared/ErkLocationField/ErkLocationField.module.css

@@ -0,0 +1,164 @@
+.container {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    box-sizing: border-box;
+}
+
+.inputRow {
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    width: 100%;
+}
+
+.grow {
+    flex: 1;
+    min-width: 0;
+}
+
+/* Mismo input del buscador de direcciones, para estados sin autocomplete */
+.plainInput {
+    width: 100%;
+    box-sizing: border-box;
+    height: 31px;
+    padding: 6px 12px;
+    font-size: 1rem;
+    font-family: inherit;
+    color: var(--eureka-text, #293241);
+    background-color: var(--eureka-bg, #fff);
+    border: 1px solid var(--eureka-outline, #b8b8b8);
+    border-radius: 10px;
+    outline: none;
+}
+
+.plainInput::placeholder {
+    color: var(--eureka-text, #293241);
+    opacity: 0.5;
+}
+
+.plainInput:hover:not(:disabled):not(:read-only) {
+    border-color: var(--eureka-primary, #3d5a7f);
+}
+
+.plainInput:focus:not(:read-only) {
+    border-color: var(--eureka-primary, #3d5a7f);
+    border-width: 2px;
+    padding: 5px 11px;
+}
+
+.plainInputError {
+    border-color: var(--eureka-error, #e53935);
+}
+
+.helperText {
+    font-size: 12px;
+    color: var(--eureka-text, #666);
+    opacity: 0.7;
+}
+
+.errorText {
+    font-size: 12px;
+    color: var(--eureka-error, #e53935);
+}
+
+/* Formulario manual (modal) */
+.manualGrid {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    width: 100%;
+}
+
+.manualRow {
+    display: flex;
+    gap: 12px;
+    width: 100%;
+}
+
+.col12 {
+    width: 100%;
+}
+.col6 {
+    width: 50%;
+}
+.col4 {
+    width: 33.333%;
+}
+
+@media (max-width: 600px) {
+    .manualRow {
+        flex-direction: column;
+        gap: 12px;
+    }
+    .col6,
+    .col4 {
+        width: 100%;
+    }
+}
+
+/* Vista de solo lectura */
+.readOnlyContainer {
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.readOnlyCard {
+    display: flex;
+    align-items: flex-start;
+    gap: 15px;
+    padding: 15px;
+    border: 1px solid var(--eureka-outline, #d9dee6);
+    border-radius: 10px;
+    background-color: var(--eureka-bg, #fff);
+}
+
+.readOnlyIcon {
+    flex-shrink: 0;
+    margin-top: 2px;
+    width: 24px;
+    height: 24px;
+}
+
+.readOnlyDetails {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    color: var(--eureka-text, #333);
+}
+
+.readOnlyName {
+    font-size: 1rem;
+    font-weight: 600;
+}
+
+.readOnlyAddress {
+    font-size: 0.9rem;
+}
+
+.readOnlyCoords {
+    font-size: 0.8rem;
+    opacity: 0.65;
+    font-family: monospace;
+}
+
+/* Modal de dirección manual (portal: usa fallbacks del theme del form) */
+.dialogPaper {
+    border-radius: 20px !important;
+    padding: 16px 24px;
+    background-color: var(--eureka-bg, #fff) !important;
+}
+
+.dialogTitle {
+    font-weight: 700 !important;
+    padding: 0 0 16px 0 !important;
+    color: var(--eureka-text, #333);
+    font-family: inherit !important;
+}
+
+.dialogContent {
+    padding: 16px 0 !important;
+    border-top: 1px solid var(--eureka-outline, #d9dee6);
+    border-bottom: 1px solid var(--eureka-outline, #d9dee6);
+}

package/dist/Shared/ErkLocationField/ErkLocationField.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/Shared/ErkLocationField/ErkLocationField.test.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import '@testing-library/jest-dom';
+import ErkLocationField from './ErkLocationField';
+import MaterialProviders from '../../Utils/MaterialProviders';
+import InternalFormStyle from '../../constants/InternalFormStyle';
+import { AddressFieldMode, LocationInputMode } from '../../@Types/LocationFormStep';
+const ALL_MODES = [LocationInputMode.GOOGLE_PLACES, LocationInputMode.GPS, LocationInputMode.MANUAL];
+function renderField(props = {}) {
+    const onChange = vi.fn();
+    render(_jsx(MaterialProviders, { formStyle: InternalFormStyle, children: _jsx(ErkLocationField, { value: null, onChange: onChange, allowedModes: ALL_MODES, ...props }) }));
+    return { onChange };
+}
+describe('ErkLocationField', () => {
+    it('renders the single-row search with GPS and manual action buttons', () => {
+        renderField();
+        expect(screen.getByPlaceholderText('Buscar dirección…')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Obtener ubicación por GPS' })).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Ingresar dirección manualmente' })).toBeInTheDocument();
+    });
+    it('saves a manual address from the dialog, composing the readable address', async () => {
+        const user = userEvent.setup();
+        const { onChange } = renderField();
+        await user.click(screen.getByRole('button', { name: 'Ingresar dirección manualmente' }));
+        expect(await screen.findByText('Ingresar Dirección')).toBeInTheDocument();
+        // Guardar bloqueado hasta llenar calle/ciudad/país
+        expect(screen.getByRole('button', { name: 'Guardar' })).toBeDisabled();
+        await user.type(screen.getByLabelText(/Calle \/ Carrera/), 'Calle 100');
+        await user.type(screen.getByLabelText(/^Ciudad/), 'Bogotá');
+        await user.type(screen.getByLabelText(/^País/), 'Colombia');
+        await user.click(screen.getByRole('button', { name: 'Guardar' }));
+        expect(onChange).toHaveBeenCalledWith({
+            source: LocationInputMode.MANUAL,
+            address: 'Calle 100, Bogotá, Colombia',
+            addressDetail: { street: 'Calle 100', city: 'Bogotá', country: 'Colombia' },
+        });
+    });
+    it('respects fixed and omitted fields in the manual dialog', async () => {
+        const user = userEvent.setup();
+        renderField({
+            addressFields: {
+                country: { mode: AddressFieldMode.FIXED, fixedValue: 'Colombia' },
+                postalCode: { mode: AddressFieldMode.OMIT },
+            },
+        });
+        await user.click(screen.getByRole('button', { name: 'Ingresar dirección manualmente' }));
+        await screen.findByText('Ingresar Dirección');
+        expect(screen.getByLabelText('País (fijo)')).toHaveValue('Colombia');
+        expect(screen.queryByLabelText('Código Postal')).not.toBeInTheDocument();
+    });
+    it('shows the selected address with edit and clear actions', async () => {
+        const user = userEvent.setup();
+        const value = {
+            source: LocationInputMode.GOOGLE_PLACES,
+            address: 'Carrera 7 # 71-21, Bogotá',
+            latitude: 4.65,
+            longitude: -74.05,
+        };
+        const { onChange } = renderField({ value });
+        expect(screen.getByDisplayValue('Carrera 7 # 71-21, Bogotá')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Editar dirección manualmente' })).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: 'Limpiar selección' }));
+        expect(onChange).toHaveBeenCalledWith(null);
+    });
+    it('renders the read-only summary card', () => {
+        renderField({
+            readOnly: true,
+            value: {
+                source: LocationInputMode.GPS,
+                name: 'Oficina',
+                address: 'Calle 93 # 12-34, Bogotá',
+                latitude: 4.678901,
+                longitude: -74.048123,
+            },
+        });
+        expect(screen.getByText('Oficina')).toBeInTheDocument();
+        expect(screen.getByText('Calle 93 # 12-34, Bogotá')).toBeInTheDocument();
+        expect(screen.getByText(/Coordenadas: 4.678901, -74.048123/)).toBeInTheDocument();
+    });
+});

package/dist/Shared/ErkLocationField/addressFields.d.ts

@@ -0,0 +1,12 @@
+import { AddressFieldConfig, AddressFieldKey, LocationAddressDetail, LocationStep } from '../../@Types/LocationFormStep';
+/** Campos de dirección en orden de render, con su etiqueta de UI. */
+export declare const ADDRESS_FIELDS: {
+    key: AddressFieldKey;
+    label: string;
+}[];
+export declare function fieldConfig(addressFields: LocationStep['addressFields'], key: AddressFieldKey): AddressFieldConfig;
+/**
+ * Aplica la config por campo a una dirección resuelta (Google/GPS):
+ * los `FIXED` se sobreescriben con el valor del diseñador y los `OMIT` se descartan.
+ */
+export declare function applyAddressFields(detail: LocationAddressDetail, addressFields: LocationStep['addressFields']): LocationAddressDetail;

package/dist/Shared/ErkLocationField/addressFields.js

@@ -0,0 +1,34 @@
+import { AddressFieldMode, } from '../../@Types/LocationFormStep';
+/** Campos de dirección en orden de render, con su etiqueta de UI. */
+export const ADDRESS_FIELDS = [
+    { key: 'street', label: 'Calle' },
+    { key: 'streetNumber', label: 'Número' },
+    { key: 'unit', label: 'Interior / Apto' },
+    { key: 'neighborhood', label: 'Barrio' },
+    { key: 'city', label: 'Ciudad' },
+    { key: 'state', label: 'Departamento / Región' },
+    { key: 'postalCode', label: 'Código postal' },
+    { key: 'country', label: 'País' },
+];
+export function fieldConfig(addressFields, key) {
+    return addressFields?.[key] ?? { mode: AddressFieldMode.ASK };
+}
+/**
+ * Aplica la config por campo a una dirección resuelta (Google/GPS):
+ * los `FIXED` se sobreescriben con el valor del diseñador y los `OMIT` se descartan.
+ */
+export function applyAddressFields(detail, addressFields) {
+    if (!addressFields)
+        return detail;
+    const result = { ...detail };
+    for (const { key } of ADDRESS_FIELDS) {
+        const config = addressFields[key];
+        if (!config)
+            continue;
+        if (config.mode === AddressFieldMode.OMIT)
+            delete result[key];
+        else if (config.mode === AddressFieldMode.FIXED)
+            result[key] = config.fixedValue;
+    }
+    return result;
+}

package/dist/Shared/ErkLocationField/locationRestrictions.d.ts

@@ -0,0 +1,6 @@
+import { LocationRestriction } from '../../@Types/LocationFormStep';
+/**
+ * Valida una coordenada contra todas las restricciones (lógica AND).
+ * Devuelve el mensaje de error de la primera restricción que falla, o `null` si es válida.
+ */
+export declare function validateRestrictions(lat: number, lng: number, restrictions: LocationRestriction[] | undefined): string | null;

package/dist/Shared/ErkLocationField/locationRestrictions.js

@@ -0,0 +1,51 @@
+import { LocationRestrictionBehavior, LocationRestrictionType, } from '../../@Types/LocationFormStep';
+const EARTH_RADIUS_M = 6371000;
+function toRad(deg) {
+    return (deg * Math.PI) / 180;
+}
+/** Distancia en metros entre dos coordenadas (haversine). */
+function haversineMeters(aLat, aLng, bLat, bLng) {
+    const dLat = toRad(bLat - aLat);
+    const dLng = toRad(bLng - aLng);
+    const lat1 = toRad(aLat);
+    const lat2 = toRad(bLat);
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+    return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+/** Punto dentro de polígono (ray casting). El polígono se cierra automáticamente. */
+function pointInPolygon(lat, lng, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const yi = polygon[i].latitude;
+        const xi = polygon[i].longitude;
+        const yj = polygon[j].latitude;
+        const xj = polygon[j].longitude;
+        const intersects = yi > lat !== yj > lat && lng < ((xj - xi) * (lat - yi)) / (yj - yi) + xi;
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function isInside(lat, lng, restriction) {
+    if (restriction.type === LocationRestrictionType.RADIUS) {
+        return (haversineMeters(lat, lng, restriction.center.latitude, restriction.center.longitude) <=
+            restriction.radiusMeters);
+    }
+    return pointInPolygon(lat, lng, restriction.polygon);
+}
+/**
+ * Valida una coordenada contra todas las restricciones (lógica AND).
+ * Devuelve el mensaje de error de la primera restricción que falla, o `null` si es válida.
+ */
+export function validateRestrictions(lat, lng, restrictions) {
+    for (const restriction of restrictions ?? []) {
+        const inside = isInside(lat, lng, restriction);
+        if (restriction.behavior === LocationRestrictionBehavior.ALLOW && !inside) {
+            return restriction.errorMessage ?? 'La ubicación está fuera de la zona permitida.';
+        }
+        if (restriction.behavior === LocationRestrictionBehavior.DENY && inside) {
+            return restriction.errorMessage ?? 'La ubicación está en una zona no permitida.';
+        }
+    }
+    return null;
+}

package/dist/Shared/ErkLocationInput/ErkLocationInput.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { LocationInputMode, LocationStepValue } from '../../@Types/LocationFormStep';
+export interface ErkLocationInputProps {
+    value?: LocationStepValue | null;
+    onChange?: (value: LocationStepValue | null) => void;
+    allowedModes: LocationInputMode[];
+    defaultMode?: LocationInputMode;
+    label: string;
+    helperText?: string | null;
+    required?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    inputRef?: React.Ref<any>;
+}
+export default function ErkLocationInput({ value, onChange, allowedModes, label, helperText, required, error, readOnly, inputRef, }: ErkLocationInputProps): JSX.Element;