@arquimedes.co/eureka-forms 3.0.48-test → 3.0.49-new-steps

package/dist/Icons/ViewWeekIcon.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './@ErkIcon';
+declare function ViewWeekIcon(props: IconProps): JSX.Element;
+export default ViewWeekIcon;

package/dist/Icons/ViewWeekIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function ViewWeekIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z" }) }));
+}
+export default ViewWeekIcon;

package/dist/Services/DraftService.js

@@ -21,10 +21,7 @@ export const DraftApi = RootApi.injectEndpoints({
                     });
                 }
                 else {
-                    response = await axiosInstance.post(`/form/draft/${apiKey}`, {
-                        property,
-                        dependencies,
-                    });
+                    response = await axiosInstance.post(`/form/draft/${apiKey}`, dependencies);
                 }
                 return { data: response.data };
             },

package/dist/Shared/ErkAddressAutocomplete/ErkAddressAutocomplete.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { LocationStepValue } from '../../@Types/LocationFormStep';
+export interface ErkAddressAutocompleteProps {
+    value?: LocationStepValue | null;
+    onChange: (value: LocationStepValue) => void;
+    /** ISO-2 para acotar las sugerencias (ej. ['co']). */
+    regionCodes?: string[];
+    placeholder?: string;
+    error?: boolean;
+    required?: boolean;
+    readOnly?: boolean;
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+/**
+ * Buscador de direcciones con el `Autocomplete` de Base UI + Google Places.
+ * Emite un `LocationStepValue` (source GOOGLE_PLACES) con el desglose estructurado.
+ */
+declare function ErkAddressAutocomplete({ value, onChange, regionCodes, placeholder, error, required, readOnly, inputRef, }: ErkAddressAutocompleteProps): JSX.Element;
+export default ErkAddressAutocomplete;

package/dist/Shared/ErkAddressAutocomplete/ErkAddressAutocomplete.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Autocomplete } from '@base-ui/react/autocomplete';
+import { fetchAddressSuggestions, loadPlaces, newSessionToken, resolvePrediction, } from './googlePlaces';
+import styles from './ErkAddressAutocomplete.module.css';
+/**
+ * Buscador de direcciones con el `Autocomplete` de Base UI + Google Places.
+ * Emite un `LocationStepValue` (source GOOGLE_PLACES) con el desglose estructurado.
+ */
+function ErkAddressAutocomplete({ value, onChange, regionCodes = ['co'], placeholder = 'Buscar dirección…', error = false, required = false, readOnly = false, inputRef, }) {
+    const apiKey = import.meta.env.VITE_GOOGLE_MAPS_API_KEY ?? '';
+    const [ready, setReady] = useState(false);
+    const [inputValue, setInputValue] = useState(value?.address ?? value?.name ?? '');
+    const [options, setOptions] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [hasSearched, setHasSearched] = useState(false);
+    const debounceRef = useRef(undefined);
+    const sessionTokenRef = useRef(undefined);
+    useEffect(() => {
+        if (readOnly)
+            return;
+        let active = true;
+        void loadPlaces(apiKey)
+            .then(() => {
+            if (!active)
+                return;
+            sessionTokenRef.current = newSessionToken();
+            setReady(true);
+        })
+            .catch(() => {
+            if (active)
+                setReady(false);
+        });
+        return () => {
+            active = false;
+        };
+    }, [apiKey, readOnly]);
+    const handleInput = useCallback((text) => {
+        setInputValue(text);
+        if (debounceRef.current)
+            clearTimeout(debounceRef.current);
+        if (!ready || !text || text.length < 3) {
+            setOptions([]);
+            setHasSearched(false);
+            return;
+        }
+        setLoading(true);
+        debounceRef.current = setTimeout(() => {
+            void (async () => {
+                try {
+                    setOptions(await fetchAddressSuggestions(text, {
+                        sessionToken: sessionTokenRef.current,
+                        regionCodes,
+                    }));
+                }
+                catch {
+                    setOptions([]);
+                }
+                finally {
+                    setLoading(false);
+                    setHasSearched(true);
+                }
+            })();
+        }, 300);
+    }, [ready, regionCodes]);
+    const handleSelect = useCallback(async (prediction) => {
+        try {
+            const stepValue = await resolvePrediction(prediction);
+            setInputValue(stepValue.address ?? stepValue.name ?? prediction.label);
+            setOptions([]);
+            onChange(stepValue);
+        }
+        finally {
+            // Cada selección cierra la sesión de billing de Google.
+            sessionTokenRef.current = newSessionToken();
+        }
+    }, [onChange]);
+    return (_jsxs(Autocomplete.Root, { items: options, mode: "none", value: inputValue, onValueChange: handleInput, disabled: readOnly, children: [_jsx(Autocomplete.Input, { ref: inputRef, placeholder: placeholder, required: required, readOnly: readOnly, className: error ? `${styles.input} ${styles.inputError}` : styles.input }), _jsx(Autocomplete.Portal, { children: _jsx(Autocomplete.Positioner, { className: styles.positioner, sideOffset: 4, children: _jsxs(Autocomplete.Popup, { className: styles.popup, children: [loading && _jsx("div", { className: styles.status, children: "Buscando\u2026" }), _jsx(Autocomplete.Empty, { className: styles.status, children: hasSearched ? 'No se encontraron resultados' : 'Escribe para buscar…' }), _jsx(Autocomplete.List, { className: styles.list, children: (option) => (_jsxs(Autocomplete.Item, { value: option, className: styles.item, onClick: () => void handleSelect(option), children: [_jsx("span", { className: styles.optionLabel, children: option.label }), option.description && (_jsx("span", { className: styles.optionDescription, children: option.description }))] }, option.placeId)) })] }) }) })] }));
+}
+export default ErkAddressAutocomplete;

package/dist/Shared/ErkAddressAutocomplete/ErkAddressAutocomplete.module.css

@@ -0,0 +1,82 @@
+.input {
+    width: 100%;
+    box-sizing: border-box;
+    height: 40px;
+    padding: 6px 12px;
+    font-size: 1rem;
+    color: var(--eureka-text, #333);
+    background-color: var(--eureka-bg, #fff);
+    border: 1px solid var(--eureka-outline, #ccc);
+    border-radius: 10px;
+    outline: none;
+}
+
+.input:hover:not(:disabled) {
+    border-color: var(--eureka-primary, #1976d2);
+}
+
+.input:focus {
+    border-color: var(--eureka-primary, #1976d2);
+    border-width: 2px;
+    padding: 5px 11px;
+}
+
+.input:disabled {
+    opacity: 0.5;
+}
+
+.inputError {
+    border-color: var(--eureka-error, #e53935);
+}
+
+.positioner {
+    z-index: 1400;
+    width: var(--anchor-width);
+}
+
+.popup {
+    box-sizing: border-box;
+    max-height: 320px;
+    overflow-y: auto;
+    padding: 4px;
+    background-color: var(--eureka-bg, #fff);
+    border: 1px solid var(--eureka-outline, #ccc);
+    border-radius: 10px;
+    box-shadow: 0 4px 16px rgb(0 0 0 / 12%);
+}
+
+.list {
+    display: flex;
+    flex-direction: column;
+}
+
+.status {
+    padding: 10px 12px;
+    font-size: 0.875rem;
+    color: var(--eureka-text, #666);
+    opacity: 0.7;
+}
+
+.item {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    padding: 8px 12px;
+    border-radius: 8px;
+    cursor: pointer;
+}
+
+.item[data-highlighted],
+.item:hover {
+    background-color: var(--eureka-primary, #1976d2);
+    color: #fff;
+}
+
+.optionLabel {
+    font-size: 0.9375rem;
+}
+
+.optionDescription {
+    font-size: 0.8125rem;
+    opacity: 0.7;
+}

package/dist/Shared/ErkAddressAutocomplete/googlePlaces.d.ts

@@ -0,0 +1,29 @@
+import { LocationAddressDetail, LocationStepValue } from '../../@Types/LocationFormStep';
+/** Asegura el script cargado y las clases de Places listas. Idempotente. */
+export declare function loadPlaces(apiKey: string): Promise<void>;
+/** Token de sesión nuevo (mejora el billing/relevancia de Google). */
+export declare function newSessionToken(): any;
+/** Reverse-geocoding para el modo GPS: coordenadas → dirección estructurada. */
+export declare function reverseGeocode(apiKey: string, lat: number, lng: number): Promise<{
+    address?: string;
+    addressDetail: LocationAddressDetail;
+}>;
+export interface AddressPrediction {
+    placeId: string;
+    label: string;
+    description: string;
+    toPlace: () => any;
+}
+export interface FetchSuggestionsOptions {
+    sessionToken?: any;
+    /** ISO-2, ej. ['co'] */
+    regionCodes?: string[];
+}
+export declare function fetchAddressSuggestions(input: string, options?: FetchSuggestionsOptions): Promise<AddressPrediction[]>;
+/**
+ * Descompone los `addressComponents` de un Place en el shape estructurado del step.
+ * Acepta el formato nuevo (`longText`/`shortText`) y el legacy (`long_name`/`short_name`).
+ */
+export declare function parseAddressComponents(components: any[] | null | undefined): LocationAddressDetail;
+/** Resuelve una predicción a un `LocationStepValue` completo (fetchFields + parse). */
+export declare function resolvePrediction(prediction: AddressPrediction): Promise<LocationStepValue>;

package/dist/Shared/ErkAddressAutocomplete/googlePlaces.js

@@ -0,0 +1,139 @@
+import { LocationInputMode } from '../../@Types/LocationFormStep';
+/**
+ * Carga y consulta de Google Places (nueva API `AutocompleteSuggestion`).
+ * Encapsula el script loader + importLibrary que antes vivía inline en ErkLocationInput,
+ * para reutilizarlo desde el autocomplete de Base UI sin duplicar lógica.
+ */
+// Google's new Places classes (AutocompleteSuggestion/SessionToken) are untyped in the
+// installed @types/google.maps, so they're kept as `any` — same approach as ErkLocationInput.
+let loadPromise = null;
+let suggestionClass = null;
+let sessionTokenClass = null;
+let geocoderClass = null;
+function loadScript(apiKey) {
+    if (typeof window === 'undefined')
+        return Promise.resolve();
+    const win = window;
+    if (win.google?.maps?.importLibrary)
+        return Promise.resolve();
+    if (loadPromise)
+        return loadPromise;
+    loadPromise = new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        script.src = `https://maps.googleapis.com/maps/api/js?key=${apiKey}&loading=async`;
+        script.async = true;
+        script.defer = true;
+        script.onload = () => resolve();
+        script.onerror = () => {
+            loadPromise = null;
+            reject(new Error('Google Maps script failed to load.'));
+        };
+        document.head.appendChild(script);
+    });
+    return loadPromise;
+}
+/** Asegura el script cargado y las clases de Places listas. Idempotente. */
+export async function loadPlaces(apiKey) {
+    await loadScript(apiKey);
+    const win = window;
+    if (win.google?.maps?.importLibrary && !suggestionClass) {
+        const places = await win.google.maps.importLibrary('places');
+        suggestionClass = places.AutocompleteSuggestion;
+        sessionTokenClass = places.AutocompleteSessionToken;
+    }
+}
+/** Token de sesión nuevo (mejora el billing/relevancia de Google). */
+export function newSessionToken() {
+    return sessionTokenClass ? new sessionTokenClass() : undefined;
+}
+/** Reverse-geocoding para el modo GPS: coordenadas → dirección estructurada. */
+export async function reverseGeocode(apiKey, lat, lng) {
+    await loadScript(apiKey);
+    const win = window;
+    if (win.google?.maps?.importLibrary && !geocoderClass) {
+        const geocoding = await win.google.maps.importLibrary('geocoding');
+        geocoderClass = geocoding.Geocoder;
+    }
+    else if (!geocoderClass && win.google?.maps?.Geocoder) {
+        geocoderClass = win.google.maps.Geocoder;
+    }
+    if (!geocoderClass)
+        return { addressDetail: {} };
+    const geocoder = new geocoderClass();
+    return new Promise((resolve) => {
+        geocoder.geocode({ location: { lat, lng } }, (results, status) => {
+            if (status === 'OK' && results?.[0]) {
+                resolve({
+                    address: results[0].formatted_address,
+                    addressDetail: parseAddressComponents(results[0].address_components),
+                });
+            }
+            else {
+                resolve({ addressDetail: {} });
+            }
+        });
+    });
+}
+export async function fetchAddressSuggestions(input, options) {
+    if (!suggestionClass)
+        return [];
+    const request = { input };
+    if (options?.sessionToken)
+        request.sessionToken = options.sessionToken;
+    if (options?.regionCodes)
+        request.includedRegionCodes = options.regionCodes;
+    const { suggestions } = await suggestionClass.fetchAutocompleteSuggestions(request);
+    return suggestions
+        .filter((s) => s.placePrediction)
+        .map((s) => ({
+        placeId: s.placePrediction.placeId,
+        label: s.placePrediction.mainText?.text ?? s.placePrediction.text.text,
+        description: s.placePrediction.secondaryText?.text ?? s.placePrediction.text.text,
+        toPlace: () => s.placePrediction.toPlace(),
+    }));
+}
+/**
+ * Descompone los `addressComponents` de un Place en el shape estructurado del step.
+ * Acepta el formato nuevo (`longText`/`shortText`) y el legacy (`long_name`/`short_name`).
+ */
+export function parseAddressComponents(components) {
+    const detail = {};
+    for (const component of components ?? []) {
+        const types = component.types;
+        const longName = component.longText ?? component.long_name;
+        const shortName = component.shortText ?? component.short_name;
+        if (types.includes('route'))
+            detail.street = longName;
+        else if (types.includes('street_number'))
+            detail.streetNumber = longName;
+        else if (types.includes('subpremise'))
+            detail.unit = longName;
+        else if (types.includes('neighborhood') || types.includes('sublocality'))
+            detail.neighborhood = longName;
+        else if (types.includes('locality'))
+            detail.city = longName;
+        else if (types.includes('administrative_area_level_1'))
+            detail.state = longName;
+        else if (types.includes('country')) {
+            detail.country = longName;
+            detail.countryCode = shortName;
+        }
+        else if (types.includes('postal_code'))
+            detail.postalCode = longName;
+    }
+    return detail;
+}
+/** Resuelve una predicción a un `LocationStepValue` completo (fetchFields + parse). */
+export async function resolvePrediction(prediction) {
+    const place = prediction.toPlace();
+    await place.fetchFields({ fields: ['displayName', 'formattedAddress', 'location', 'addressComponents'] });
+    return {
+        source: LocationInputMode.GOOGLE_PLACES,
+        latitude: place.location?.lat(),
+        longitude: place.location?.lng(),
+        name: place.displayName ?? prediction.label,
+        address: place.formattedAddress ?? undefined,
+        placeId: prediction.placeId,
+        addressDetail: parseAddressComponents(place.addressComponents),
+    };
+}

package/dist/Shared/ErkDatePicker/ErkDatePicker.js

@@ -2,11 +2,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useMemo } from 'react';
 import { format as dateFnsFormat, isValid } from 'date-fns';
 import { InputAdornment, styled, Dialog as MuiDialog } from '@mui/material';
-import { MobileDatePicker as MuiDatePicker, MobileDateTimePicker as MuiDateTimePicker, DatePickerToolbar as MuiDatePickerToolbar, DateTimePickerToolbar as MuiDateTimePickerToolbar, usePickerContext, } from '@mui/x-date-pickers';
-import { PickerDay as MuiPickerDay } from '@mui/x-date-pickers/PickerDay';
+import { MobileDatePicker as MuiDatePicker, MobileDateTimePicker as MuiDateTimePicker, DatePickerToolbar as MuiDatePickerToolbar, DateTimePickerToolbar as MuiDateTimePickerToolbar, usePickerContext, PickerDay as MuiPickerDay, renderTimeViewClock, } from '@mui/x-date-pickers';
 import { StyledTextField } from '../ErkTextField/ErkTextField';
 import CalendarIcon from '../../Icons/CalendarIcon';
-import { renderTimeViewClock } from '@mui/x-date-pickers/timeViewRenderers';
 const StyledDateTimePicker = styled(MuiDateTimePicker, {
     shouldForwardProp: (propName) => propName !== 'size',
 })(({ disabled, readOnly, size }) => ({

package/dist/Shared/ErkDateRangePicker/ErkDateRangePicker.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
-import { MobileDateRangePickerProps as MuiDateRangePickerProps } from '@mui/x-date-pickers-pro/MobileDateRangePicker';
-import { DateRange } from '@mui/x-date-pickers-pro';
-import { PickersShortcutsItem } from '@mui/x-date-pickers/PickersShortcuts';
+import { PickersShortcutsItem } from '@mui/x-date-pickers';
+import { MobileDateRangePickerProps as MuiDateRangePickerProps, DateRange } from '@mui/x-date-pickers-pro';
 import { ErkTextFieldProps } from '../ErkTextField/ErkTextField';
 interface ErkDateRangePickerProps extends Omit<MuiDateRangePickerProps, 'ref' | 'onChange' | 'value' | 'slotProps'>, Pick<ErkTextFieldProps, 'error' | 'required' | 'helperText' | 'size'> {
     onChange?: (dateRange: DateRange<Date>) => void;

package/dist/Shared/ErkDateRangePicker/ErkDateRangePicker.js

@@ -2,8 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useMemo } from 'react';
 import { InputAdornment, styled, Dialog as MuiDialog } from '@mui/material';
 import { DatePickerToolbar as MuiDatePickerToolbar, usePickerContext, } from '@mui/x-date-pickers';
-import { MobileDateRangePicker as MuiDateRangePicker, } from '@mui/x-date-pickers-pro/MobileDateRangePicker';
-import { DateRangePickerDay as MuiDateRangePickerDay } from '@mui/x-date-pickers-pro';
+import { MobileDateRangePicker as MuiDateRangePicker, DateRangePickerDay as MuiDateRangePickerDay, } from '@mui/x-date-pickers-pro';
 import { format, isValid } from 'date-fns';
 import { StyledTextField } from '../ErkTextField/ErkTextField';
 import CalendarIcon from '../../Icons/CalendarIcon';

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import { LocationInputMode, LocationStep, LocationStepValue } from '../../@Types/LocationFormStep';
+export interface ErkLocationFieldProps {
+    value?: LocationStepValue | null;
+    onChange: (value: LocationStepValue | null) => void;
+    allowedModes: LocationInputMode[];
+    defaultMode?: LocationInputMode;
+    addressFields?: LocationStep['addressFields'];
+    /** ISO-2 para acotar el buscador (ej. ['co']). */
+    regionCodes?: string[];
+    error?: boolean;
+    helperText?: string | null;
+    required?: boolean;
+    readOnly?: boolean;
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+/**
+ * Campo de ubicación (rehecho con Base UI). Ofrece los modos habilitados
+ * (buscador de Google Places, GPS, entrada manual) y aplica la config por campo
+ * (fijo / omitir) al valor resultante.
+ */
+declare function ErkLocationField({ value, onChange, allowedModes, defaultMode, addressFields, regionCodes, error, helperText, required, readOnly, inputRef, }: ErkLocationFieldProps): JSX.Element;
+export default ErkLocationField;

package/dist/Shared/ErkLocationField/ErkLocationField.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import { AddressFieldMode, LocationInputMode, } from '../../@Types/LocationFormStep';
+import ErkAddressAutocomplete from '../ErkAddressAutocomplete/ErkAddressAutocomplete';
+import { reverseGeocode } from '../ErkAddressAutocomplete/googlePlaces';
+import { ADDRESS_FIELDS, applyAddressFields, fieldConfig } from './addressFields';
+import ErkTextField from '../ErkTextField/ErkTextField';
+import ErkButton from '../ErkButton/ErkButton';
+import LocationIcon from '../../Icons/LocationIcon';
+import styles from './ErkLocationField.module.css';
+const MODE_LABELS = {
+    [LocationInputMode.GOOGLE_PLACES]: 'Buscar',
+    [LocationInputMode.GPS]: 'Mi ubicación',
+    [LocationInputMode.MANUAL]: 'Manual',
+};
+/**
+ * Campo de ubicación (rehecho con Base UI). Ofrece los modos habilitados
+ * (buscador de Google Places, GPS, entrada manual) y aplica la config por campo
+ * (fijo / omitir) al valor resultante.
+ */
+function ErkLocationField({ value, onChange, allowedModes, defaultMode, addressFields, regionCodes = ['co'], error = false, helperText, required = false, readOnly = false, inputRef, }) {
+    const apiKey = import.meta.env.VITE_GOOGLE_MAPS_API_KEY ?? '';
+    const initialMode = defaultMode && allowedModes.includes(defaultMode) ? defaultMode : allowedModes[0];
+    const [mode, setMode] = useState(initialMode);
+    const [gpsLoading, setGpsLoading] = useState(false);
+    const [gpsError, setGpsError] = useState(null);
+    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));
+        }, () => {
+            setGpsError('No se pudo obtener la ubicación.');
+            setGpsLoading(false);
+        }, { enableHighAccuracy: false, timeout: 15000, maximumAge: 300000 });
+    }, [apiKey, onChange, addressFields]);
+    const updateManualField = useCallback((key, text) => {
+        const base = value?.source === LocationInputMode.MANUAL ? (value.addressDetail ?? {}) : {};
+        const nextDetail = applyAddressFields({ ...base, [key]: text || undefined }, addressFields);
+        const address = ADDRESS_FIELDS.map(({ key: k }) => nextDetail[k])
+            .filter(Boolean)
+            .join(', ');
+        onChange({ source: LocationInputMode.MANUAL, address, addressDetail: nextDetail });
+    }, [value, onChange, addressFields]);
+    const manualDetail = value?.source === LocationInputMode.MANUAL ? (value.addressDetail ?? {}) : {};
+    return (_jsxs("div", { className: styles.container, children: [allowedModes.length > 1 && (_jsx("div", { className: styles.modeSwitch, children: allowedModes.map((m) => (_jsx(ErkButton, { color: m === mode ? 'primary' : 'secondary', disabled: readOnly, onClick: () => setMode(m), children: MODE_LABELS[m] }, m))) })), mode === LocationInputMode.GOOGLE_PLACES && (_jsx(ErkAddressAutocomplete, { value: value, onChange: handleGoogle, regionCodes: regionCodes, error: error, required: required, readOnly: readOnly, inputRef: inputRef })), mode === LocationInputMode.GPS && (_jsxs(ErkButton, { color: "primary", loading: gpsLoading, disabled: readOnly, onClick: handleGps, children: [_jsx(LocationIcon, { fill: "currentColor" }), " Usar mi ubicaci\u00F3n actual"] })), mode === LocationInputMode.MANUAL && (_jsx("div", { className: styles.manualGrid, children: ADDRESS_FIELDS.map(({ key, label }) => {
+                    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: fixed ? (config.fixedValue ?? '') : (manualDetail[key] ?? ''), readOnly: fixed || readOnly, onChange: (text) => updateManualField(key, text) }, key));
+                }) })), (gpsError ?? helperText) && (_jsx("div", { className: error || gpsError ? styles.errorText : styles.helperText, children: gpsError ?? helperText }))] }));
+}
+export default ErkLocationField;

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

@@ -0,0 +1,29 @@
+.container {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    width: 100%;
+}
+
+.modeSwitch {
+    display: flex;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.manualGrid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 10px;
+}
+
+.helperText {
+    font-size: 12px;
+    color: var(--eureka-text, #666);
+    opacity: 0.7;
+}
+
+.errorText {
+    font-size: 12px;
+    color: var(--eureka-error, #e53935);
+}

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;
+}