@arquimedes.co/eureka-forms 3.0.68-test → 3.0.69

package/dist/Services/BookingService.d.ts

@@ -0,0 +1,79 @@
+import { BookingSlot } from '../@Types/BookingFormStep';
+/**
+ * Cómo llegar al paso BOOKING de un formulario publicado. Misma regla que el envío del formulario:
+ * un form embebido o interno nombra su organización y sale por el dominio de forms; uno servido por
+ * el subdominio de la organización habla con `/api` en el mismo origen.
+ */
+export interface BookingRoute {
+    apiKey: string;
+    idStep: string;
+    idOrganization?: string;
+    internal?: boolean;
+}
+/** Una persona agendable tal como la publica el backend: un handle opaco, nunca un id de agente. */
+export interface BookingOfferPerson {
+    token: string;
+    name: string;
+    role?: string;
+    avatarUrl?: string;
+    description?: string;
+}
+/** Lo que el picker necesita para dibujarse: en qué zona horaria leer las horas y qué días tienen cupo. */
+export interface BookingOffer {
+    timeZone: string;
+    durationMinutes: number;
+    bookingMode: string;
+    personSelection: 'NONE' | 'OPTIONAL' | 'REQUIRED';
+    persons?: BookingOfferPerson[];
+    /** Días con al menos un slot, `YYYY-MM-DD` en la zona horaria de la organización. */
+    days: string[];
+    from: string;
+    to: string;
+}
+/** Un slot tal como lo ofrece el backend: instantes ISO y el handle firmado que lo nombra. */
+export interface BookingOfferSlot {
+    start: string;
+    end: string;
+    token: string;
+}
+/** Un slot retirado de la oferta mientras se termina el formulario. */
+export interface BookingHold {
+    appointment: string;
+    hold: string;
+    lockedUntil: string;
+}
+export interface BookingContact {
+    name: string;
+    email?: string;
+    phone?: string;
+}
+/** La oferta del paso; con `person`, la oferta de esa persona (los días que ella tiene libres). */
+export declare function fetchBookingOffer(route: BookingRoute, person?: string): Promise<BookingOffer>;
+/** Los slots de un día, `date` en `YYYY-MM-DD` de la zona horaria de la organización. */
+export declare function fetchBookingSlots(route: BookingRoute, date: string, person?: string): Promise<BookingOfferSlot[]>;
+/**
+ * Bloquea un slot (o renueva un bloqueo propio si se envía su `hold`). El backend responde 409 cuando
+ * otra persona ya lo tomó, y 422 cuando el paso exige contacto y no llegó.
+ */
+export declare function holdBookingSlot(route: BookingRoute, body: {
+    slot: string;
+    hold?: string;
+    contact?: BookingContact;
+}): Promise<BookingHold>;
+/** Devuelve un slot antes de que venza su bloqueo, para que se ofrezca de nuevo de inmediato. */
+export declare function releaseBookingSlot(route: BookingRoute, body: {
+    appointment: string;
+    hold: string;
+}): Promise<void>;
+/**
+ * La hora `HH:mm` de un instante en la zona horaria de la organización. El picker muestra el reloj de
+ * quien recibe la cita, no el del navegador: un slot de las 09:00 en Bogotá es a las 09:00 aunque el
+ * que agenda esté en Madrid.
+ */
+export declare function clockIn(iso: string, timeZone: string): string;
+/** Un slot de la oferta como lo consume el picker: el handle es su id y las horas van en el reloj de la organización. */
+export declare function toPickerSlot(slot: BookingOfferSlot, timeZone: string): BookingSlot;
+/** Un texto opcional de un campo de contacto: vacío o solo espacios cuenta como no dado. */
+export declare function nonEmpty(text?: string): string | undefined;
+/** El motivo de un rechazo del backend, que llega como texto plano, o un mensaje genérico. */
+export declare function bookingErrorMessage(error: unknown): string;

package/dist/Services/BookingService.js

@@ -0,0 +1,66 @@
+import axiosInstance from '../Utils/AxiosAPI';
+import widgetInstance from '../Utils/AxiosWidget';
+function client(route) {
+    return route.idOrganization || route.internal ? widgetInstance : axiosInstance;
+}
+function url(route, suffix, params = {}) {
+    const search = new URLSearchParams();
+    if (route.idOrganization || route.internal)
+        search.set('idOrganization', route.idOrganization ?? '');
+    for (const [key, value] of Object.entries(params)) {
+        if (value)
+            search.set(key, value);
+    }
+    const query = search.toString();
+    return `/booking/${route.apiKey}/${route.idStep}${suffix}${query ? `?${query}` : ''}`;
+}
+/** La oferta del paso; con `person`, la oferta de esa persona (los días que ella tiene libres). */
+export async function fetchBookingOffer(route, person) {
+    const response = await client(route).get(url(route, '', { person }));
+    return response.data;
+}
+/** Los slots de un día, `date` en `YYYY-MM-DD` de la zona horaria de la organización. */
+export async function fetchBookingSlots(route, date, person) {
+    const response = await client(route).get(url(route, '/slots', { date, person }));
+    return response.data.slots;
+}
+/**
+ * Bloquea un slot (o renueva un bloqueo propio si se envía su `hold`). El backend responde 409 cuando
+ * otra persona ya lo tomó, y 422 cuando el paso exige contacto y no llegó.
+ */
+export async function holdBookingSlot(route, body) {
+    const response = await client(route).post(url(route, '/hold'), body);
+    return response.data;
+}
+/** Devuelve un slot antes de que venza su bloqueo, para que se ofrezca de nuevo de inmediato. */
+export async function releaseBookingSlot(route, body) {
+    await client(route).post(url(route, '/release'), body);
+}
+/**
+ * La hora `HH:mm` de un instante en la zona horaria de la organización. El picker muestra el reloj de
+ * quien recibe la cita, no el del navegador: un slot de las 09:00 en Bogotá es a las 09:00 aunque el
+ * que agenda esté en Madrid.
+ */
+export function clockIn(iso, timeZone) {
+    return new Intl.DateTimeFormat('en-GB', { hour: '2-digit', minute: '2-digit', hourCycle: 'h23', timeZone }).format(new Date(iso));
+}
+/** Un slot de la oferta como lo consume el picker: el handle es su id y las horas van en el reloj de la organización. */
+export function toPickerSlot(slot, timeZone) {
+    return {
+        id: slot.token,
+        startTime: clockIn(slot.start, timeZone),
+        endTime: clockIn(slot.end, timeZone),
+        available: true,
+    };
+}
+/** Un texto opcional de un campo de contacto: vacío o solo espacios cuenta como no dado. */
+export function nonEmpty(text) {
+    return text?.trim() ? text : undefined;
+}
+/** El motivo de un rechazo del backend, que llega como texto plano, o un mensaje genérico. */
+export function bookingErrorMessage(error) {
+    const data = error?.response?.data;
+    if (typeof data === 'string' && data.trim())
+        return data;
+    return 'No pudimos reservar ese horario. Intenta de nuevo.';
+}

package/dist/Services/BookingService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Services/BookingService.test.js

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/unbound-method, @typescript-eslint/require-await, @typescript-eslint/explicit-function-return-type -- test file: vi.mocked()/expect() reference mocked axios methods as values, and the mock factory uses terse async/return types */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import axiosInstance from '../Utils/AxiosAPI';
+import widgetInstance from '../Utils/AxiosWidget';
+import { bookingErrorMessage, clockIn, fetchBookingOffer, fetchBookingSlots, holdBookingSlot, releaseBookingSlot, toPickerSlot, } from './BookingService';
+vi.mock('../Utils/AxiosWidget', () => ({
+    default: { get: vi.fn(), post: vi.fn() },
+}));
+vi.mock('../Utils/AxiosAPI', () => ({
+    default: { get: vi.fn(), post: vi.fn() },
+    axiosBaseQuery: () => async () => ({ data: undefined }),
+}));
+const ROUTE = { apiKey: 'form-key', idStep: 'BOOKING-1' };
+describe('BookingService', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('reads a slot on the organization’s clock, not the browser’s', () => {
+        // 14:00Z is 09:00 in Bogotá and 16:00 in Madrid; the picker shows the calendar's own hours.
+        expect(clockIn('2026-09-22T14:00:00.000Z', 'America/Bogota')).toBe('09:00');
+        expect(clockIn('2026-09-22T14:00:00.000Z', 'Europe/Madrid')).toBe('16:00');
+        expect(clockIn('2026-09-22T05:00:00.000Z', 'America/Bogota')).toBe('00:00');
+        expect(toPickerSlot({ start: '2026-09-22T14:00:00.000Z', end: '2026-09-22T14:30:00.000Z', token: 'tok' }, 'America/Bogota')).toEqual({ id: 'tok', startTime: '09:00', endTime: '09:30', available: true });
+    });
+    it('talks to the same-origin API for a form served under the organization', async () => {
+        vi.mocked(axiosInstance.get).mockResolvedValue({ data: { days: ['2026-09-22'] } });
+        await fetchBookingOffer(ROUTE);
+        expect(axiosInstance.get).toHaveBeenCalledWith('/booking/form-key/BOOKING-1');
+        await fetchBookingSlots(ROUTE, '2026-09-22', 'person-token');
+        expect(axiosInstance.get).toHaveBeenLastCalledWith('/booking/form-key/BOOKING-1/slots?date=2026-09-22&person=person-token');
+        expect(widgetInstance.get).not.toHaveBeenCalled();
+    });
+    it('names the organization and goes through the forms domain for an embedded form', async () => {
+        vi.mocked(widgetInstance.get).mockResolvedValue({ data: { days: [] } });
+        vi.mocked(widgetInstance.post).mockResolvedValue({ data: { appointment: 'a1', hold: 'h1', lockedUntil: 'x' } });
+        const route = { ...ROUTE, idOrganization: 'acme' };
+        await fetchBookingOffer(route, 'p');
+        expect(widgetInstance.get).toHaveBeenCalledWith('/booking/form-key/BOOKING-1?idOrganization=acme&person=p');
+        const held = await holdBookingSlot(route, { slot: 'slot-token', contact: { name: 'Ana' } });
+        expect(widgetInstance.post).toHaveBeenCalledWith('/booking/form-key/BOOKING-1/hold?idOrganization=acme', {
+            slot: 'slot-token',
+            contact: { name: 'Ana' },
+        });
+        expect(held).toEqual({ appointment: 'a1', hold: 'h1', lockedUntil: 'x' });
+        await releaseBookingSlot(route, { appointment: 'a1', hold: 'h1' });
+        expect(widgetInstance.post).toHaveBeenLastCalledWith('/booking/form-key/BOOKING-1/release?idOrganization=acme', {
+            appointment: 'a1',
+            hold: 'h1',
+        });
+        expect(axiosInstance.get).not.toHaveBeenCalled();
+    });
+    it('surfaces the edge’s plain-text refusal, and a generic message otherwise', () => {
+        expect(bookingErrorMessage({ response: { data: 'That slot is no longer available' } })).toBe('That slot is no longer available');
+        expect(bookingErrorMessage({ response: { data: { message: 'Forbidden' } } })).toBe('No pudimos reservar ese horario. Intenta de nuevo.');
+        expect(bookingErrorMessage(new Error('network'))).toBe('No pudimos reservar ese horario. Intenta de nuevo.');
+    });
+});

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,88 @@
+.input {
+    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;
+}
+
+.input::placeholder {
+    color: var(--eureka-text, #293241);
+    opacity: 0.5;
+}
+
+.input:hover:not(:disabled):not(:read-only) {
+    border-color: var(--eureka-primary, #3d5a7f);
+}
+
+.input:focus:not(:read-only) {
+    border-color: var(--eureka-primary, #3d5a7f);
+    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, #b8b8b8);
+    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, #3d5a7f);
+    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/ErkAvailabilityPicker/ErkAvailabilityPicker.d.ts

@@ -0,0 +1,25 @@
+import { CalendarValue } from '../../@Types/CalendarFormStep';
+export interface ErkAvailabilityPickerProps {
+    value: CalendarValue | null;
+    onChange: (value: CalendarValue | null) => void;
+    label: string;
+    description?: string | null;
+    /** Hora mínima del grid (HH:mm). @default "07:00" */
+    minTime?: string;
+    /** Hora máxima del grid (HH:mm). @default "19:00" */
+    maxTime?: string;
+    /** Muestra sábado y domingo. @default true */
+    showWeekends?: boolean;
+    /** Zona horaria que se guarda junto a los eventos. */
+    timezone?: string;
+    readOnly?: boolean;
+    error?: string;
+}
+/**
+ * Picker compacto de disponibilidad para el paso CALENDAR/Availability del form:
+ * un grid semanal pequeño (día × hora) donde quien responde marca sus ventanas
+ * disponibles. Produce ventanas WORKING con recurrencia semanal (RRULE), las que
+ * un paso BOOKING puede usar como disponibilidad.
+ */
+declare function ErkAvailabilityPicker({ value, onChange, label, description, minTime, maxTime, showWeekends, timezone, readOnly, error, }: ErkAvailabilityPickerProps): JSX.Element;
+export default ErkAvailabilityPicker;