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

package/dist/Services/BookingService.js

@@ -0,0 +1,264 @@
+import axiosInstance from '../Utils/AxiosAPI';
+import widgetInstance from '../Utils/AxiosWidget';
+/** Los códigos con los que el borde de agendamiento explica un rechazo. */
+export var BookingErrorCodes;
+(function (BookingErrorCodes) {
+    BookingErrorCodes["INVALID_REQUEST"] = "INVALID_REQUEST";
+    BookingErrorCodes["NOT_FOUND"] = "NOT_FOUND";
+    BookingErrorCodes["FORBIDDEN"] = "FORBIDDEN";
+    /** Un token de persona o de cupo venció: hay que recargar la oferta (o las horas). */
+    BookingErrorCodes["STALE_OFFER"] = "STALE_OFFER";
+    BookingErrorCodes["CONTACT_REQUIRED"] = "CONTACT_REQUIRED";
+    BookingErrorCodes["SLOT_TAKEN"] = "SLOT_TAKEN";
+    /** La renovación llegó tarde: la reserva ya venció. */
+    BookingErrorCodes["HOLD_EXPIRED"] = "HOLD_EXPIRED";
+    /** El enlace de la cita venció, fue alterado o ya no nombra ninguna cita. */
+    BookingErrorCodes["INVALID_LINK"] = "INVALID_LINK";
+    /** La cita ya no se puede cancelar ni mover: está cancelada o su paso ya no existe. */
+    BookingErrorCodes["APPOINTMENT_CLOSED"] = "APPOINTMENT_CLOSED";
+    BookingErrorCodes["RATE_LIMITED"] = "RATE_LIMITED";
+    BookingErrorCodes["METHOD_NOT_ALLOWED"] = "METHOD_NOT_ALLOWED";
+    BookingErrorCodes["INTERNAL"] = "INTERNAL";
+})(BookingErrorCodes || (BookingErrorCodes = {}));
+/** Un rechazo del borde ya leído: el mensaje es apto para mostrarse a quien agenda. */
+export class BookingEdgeError extends Error {
+    constructor(message, code, status) {
+        super(message);
+        Object.defineProperty(this, "code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'BookingEdgeError';
+        this.code = code;
+        this.status = status;
+    }
+}
+/** El texto que muestra el picker cuando la renovación de la reserva falla para siempre. */
+export const HOLD_LAPSED_MESSAGE = 'Tu reserva venció; elige la hora de nuevo.';
+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}` : ''}`;
+}
+function appointmentUrl(token, idOrganization, suffix = '') {
+    const query = idOrganization ? `?${new URLSearchParams({ idOrganization }).toString()}` : '';
+    return `/booking/appointment/${encodeURIComponent(token)}${suffix}${query}`;
+}
+function appointmentClient(idOrganization) {
+    return idOrganization ? widgetInstance : axiosInstance;
+}
+/** La cita que nombra el enlace. Un enlace vencido o alterado responde 404 `INVALID_LINK`. */
+export async function fetchBookingAppointment(token, idOrganization) {
+    const response = await appointmentClient(idOrganization).get(appointmentUrl(token, idOrganization));
+    return response.data;
+}
+/** Cancela la cita; responde la cita ya cancelada. Una cita que ya no está vigente responde 409 `APPOINTMENT_CLOSED`. */
+export async function cancelBookingAppointment(token, idOrganization) {
+    const response = await appointmentClient(idOrganization).post(appointmentUrl(token, idOrganization, '/cancel'));
+    return response.data;
+}
+/**
+ * Mueve la cita al cupo `slot` (un handle de la oferta del mismo paso y la misma persona). Responde la
+ * cita movida con su handle nuevo; 409 `SLOT_TAKEN` si alguien tomó la hora primero.
+ */
+export async function moveBookingAppointment(token, slot, idOrganization) {
+    const response = await appointmentClient(idOrganization).post(appointmentUrl(token, idOrganization, '/move'), { slot });
+    return response.data;
+}
+/**
+ * La oferta del paso; con `person`, la oferta de esa persona (los días que ella tiene libres), y con
+ * `eventTemplate`, los días de ese tipo de atención con su duración.
+ */
+export async function fetchBookingOffer(route, query = {}) {
+    const response = await client(route).get(url(route, '', { person: query.person, eventTemplate: query.eventTemplate }));
+    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, query = {}) {
+    const response = await client(route).get(url(route, '/slots', { date, person: query.person, eventTemplate: query.eventTemplate }));
+    return response.data.slots;
+}
+/**
+ * Bloquea un slot a nombre de quien agenda. El borde responde 409 `SLOT_TAKEN` cuando nadie quedó
+ * libre a esa hora y 422 `CONTACT_REQUIRED` sin nombre o sin correo válido. `eventTemplate` is the
+ * handle of the type the requester picked; the appointment takes that type's duration.
+ */
+export async function holdBookingSlot(route, body) {
+    const response = await client(route).post(url(route, '/hold'), body);
+    return response.data;
+}
+/**
+ * Extiende una reserva propia con el `renew` de la última respuesta. No depende del token del cupo,
+ * así que una reserva renovada a tiempo vive lo que tarde el formulario. Una reserva ya vencida
+ * responde 409 `HOLD_EXPIRED`.
+ */
+export async function renewBookingHold(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));
+}
+/** El día `YYYY-MM-DD` de un instante en una zona horaria. */
+export function dayIn(iso, timeZone) {
+    return new Intl.DateTimeFormat('en-CA', { year: 'numeric', month: '2-digit', day: '2-digit', timeZone }).format(new Date(iso));
+}
+/** La zona horaria del navegador, o `undefined` si no se puede leer. */
+export function browserTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Ciudades de zonas IANA cuyo nombre en español lleva tilde o cambia. */
+const CITY_NAMES = {
+    Bogota: 'Bogotá',
+    Mexico_City: 'Ciudad de México',
+    Panama: 'Panamá',
+    Asuncion: 'Asunción',
+    Sao_Paulo: 'São Paulo',
+    New_York: 'Nueva York',
+    Los_Angeles: 'Los Ángeles',
+    Merida: 'Mérida',
+    Cancun: 'Cancún',
+};
+/**
+ * Cómo se nombra la zona de la organización junto a las horas: "hora de Bogotá (GMT-5)". El desfase
+ * se calcula en `at`, porque en las zonas con horario de verano cambia según el día.
+ */
+export function zoneLabel(timeZone, at = new Date()) {
+    const id = timeZone.split('/').pop() ?? timeZone;
+    const city = CITY_NAMES[id] ?? id.replace(/_/g, ' ');
+    let offset;
+    try {
+        offset = new Intl.DateTimeFormat('en-US', { timeZone, timeZoneName: 'shortOffset' })
+            .formatToParts(at)
+            .find((part) => part.type === 'timeZoneName')?.value;
+    }
+    catch {
+        offset = undefined;
+    }
+    return offset ? `hora de ${city} (${offset})` : `hora de ${city}`;
+}
+/** 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,
+        start: slot.start,
+    };
+}
+/**
+ * Las horas de un día como las muestra el picker: una por instante y en orden. El borde ya agrupa por
+ * instante; si llegara un instante repetido, gana el primero y el servidor elige a la persona al reservar.
+ */
+export function toPickerSlots(slots, timeZone) {
+    const seen = new Set();
+    return [...slots]
+        .sort((a, b) => a.start.localeCompare(b.start))
+        .filter((slot) => {
+        if (seen.has(slot.start))
+            return false;
+        seen.add(slot.start);
+        return true;
+    })
+        .map((slot) => toPickerSlot(slot, timeZone));
+}
+/**
+ * Lo que la reserva aporta al valor del paso: día y horas reales en el reloj de la organización, la
+ * persona asignada y el tipo de atención elegido.
+ */
+export function holdToValue(held, timeZone) {
+    return {
+        appointment: held.appointment,
+        hold: held.hold,
+        lockedUntil: held.lockedUntil,
+        date: dayIn(held.start, timeZone),
+        startTime: clockIn(held.start, timeZone),
+        endTime: clockIn(held.end, timeZone),
+        ...(held.person ? { personId: held.person.token, personName: held.person.name } : {}),
+        ...(held.eventTemplate
+            ? { eventTemplate: { name: held.eventTemplate.name, durationMinutes: held.eventTemplate.durationMinutes } }
+            : {}),
+    };
+}
+/** 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.trim() : undefined;
+}
+/** Si un texto es un correo con forma válida (lo mismo que exige el borde al reservar). */
+export function isValidEmail(text) {
+    return !!text && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(text.trim());
+}
+/** El código HTTP de un error del cliente HTTP, si lo hay. */
+export function statusOf(error) {
+    return error?.response?.status;
+}
+/**
+ * Lee un rechazo del borde. El borde responde `{ code, message }` con el mensaje en español; los
+ * errores que el gateway responde antes de la lambda siguen llegando como texto plano.
+ */
+export function toBookingError(error, fallback = 'No pudimos reservar ese horario. Intenta de nuevo.') {
+    if (error instanceof BookingEdgeError)
+        return error;
+    const status = statusOf(error);
+    const data = error?.response?.data;
+    if (data && typeof data === 'object') {
+        const { code, message } = data;
+        if (typeof message === 'string' && message.trim()) {
+            return new BookingEdgeError(message, typeof code === 'string' ? code : undefined, status);
+        }
+    }
+    if (typeof data === 'string' && data.trim())
+        return new BookingEdgeError(data, undefined, status);
+    if (status === 429) {
+        return new BookingEdgeError('Hay muchas consultas en este momento. Intenta de nuevo en unos segundos.', BookingErrorCodes.RATE_LIMITED, status);
+    }
+    return new BookingEdgeError(fallback, undefined, status);
+}
+/** El motivo de un rechazo del borde, o un mensaje genérico. */
+export function bookingErrorMessage(error, fallback) {
+    return toBookingError(error, fallback).message;
+}
+/**
+ * Si una renovación fallida significa que la reserva ya no existe: el borde lo dice (`HOLD_EXPIRED`,
+ * o el token venció), o el plazo pasó sin una renovación que llegara. Un corte de red o un 429 antes
+ * del plazo se reintenta en la siguiente vuelta.
+ */
+export function holdLapsed(error, lockedUntil, now = Date.now()) {
+    if (error.code === BookingErrorCodes.HOLD_EXPIRED || error.code === BookingErrorCodes.STALE_OFFER)
+        return true;
+    if (error.code === BookingErrorCodes.NOT_FOUND || error.code === BookingErrorCodes.INVALID_REQUEST)
+        return true;
+    return !!lockedUntil && new Date(lockedUntil).getTime() <= now;
+}

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

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

package/dist/Services/BookingService.test.js

@@ -0,0 +1,178 @@
+/* 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 { BookingEdgeError, BookingErrorCodes, bookingErrorMessage, cancelBookingAppointment, clockIn, dayIn, fetchBookingAppointment, fetchBookingOffer, fetchBookingSlots, holdBookingSlot, holdLapsed, holdToValue, isValidEmail, moveBookingAppointment, releaseBookingSlot, renewBookingHold, toBookingError, toPickerSlot, toPickerSlots, zoneLabel, } 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,
+            start: '2026-09-22T14:00:00.000Z',
+        });
+    });
+    it('shows one hour per instant, in order', () => {
+        const slots = toPickerSlots([
+            { start: '2026-09-22T14:15:00.000Z', end: '2026-09-22T14:45:00.000Z', token: 'b' },
+            { start: '2026-09-22T14:00:00.000Z', end: '2026-09-22T14:30:00.000Z', token: 'a' },
+            { start: '2026-09-22T14:00:00.000Z', end: '2026-09-22T14:30:00.000Z', token: 'a2' },
+        ], 'America/Bogota');
+        expect(slots.map((slot) => [slot.id, slot.startTime])).toEqual([
+            ['a', '09:00'],
+            ['b', '09:15'],
+        ]);
+    });
+    it('names the organization clock with its offset on the given day', () => {
+        expect(zoneLabel('America/Bogota', new Date('2026-10-14T12:00:00Z'))).toBe('hora de Bogotá (GMT-5)');
+        expect(zoneLabel('Europe/Madrid', new Date('2026-07-01T12:00:00Z'))).toBe('hora de Madrid (GMT+2)');
+        expect(zoneLabel('Europe/Madrid', new Date('2026-12-01T12:00:00Z'))).toBe('hora de Madrid (GMT+1)');
+    });
+    it('takes the day, hours and assigned person of a hold from the hold itself', () => {
+        // 04:30Z is still the previous day in Bogotá.
+        expect(dayIn('2026-10-15T04:30:00.000Z', 'America/Bogota')).toBe('2026-10-14');
+        expect(holdToValue({
+            appointment: 'a1',
+            hold: 'h1',
+            lockedUntil: '2026-10-14T15:30:00.000Z',
+            renew: 'r1',
+            start: '2026-10-15T14:00:00.000Z',
+            end: '2026-10-15T14:30:00.000Z',
+            person: { token: 'pt', name: 'Bruno Pérez', role: 'Asesor' },
+        }, 'America/Bogota')).toEqual({
+            appointment: 'a1',
+            hold: 'h1',
+            lockedUntil: '2026-10-14T15:30:00.000Z',
+            date: '2026-10-15',
+            startTime: '09:00',
+            endTime: '09:30',
+            personId: 'pt',
+            personName: 'Bruno Pérez',
+        });
+    });
+    it('keeps the event template the hold was made with', () => {
+        expect(holdToValue({
+            appointment: 'a1',
+            hold: 'h1',
+            lockedUntil: '2026-10-14T15:30:00.000Z',
+            renew: 'r1',
+            start: '2026-10-15T14:00:00.000Z',
+            end: '2026-10-15T14:45:00.000Z',
+            eventTemplate: { name: 'Asesoría de crédito', durationMinutes: 45 },
+        }, 'America/Bogota').eventTemplate).toEqual({ name: 'Asesoría de crédito', durationMinutes: 45 });
+    });
+    it('narrows the offer, the slots and the hold to the picked event template', async () => {
+        vi.mocked(axiosInstance.get).mockResolvedValue({ data: { days: [], slots: [] } });
+        vi.mocked(axiosInstance.post).mockResolvedValue({ data: {} });
+        await fetchBookingOffer(ROUTE, { eventTemplate: 'tt-1' });
+        expect(axiosInstance.get).toHaveBeenLastCalledWith('/booking/form-key/BOOKING-1?eventTemplate=tt-1');
+        await fetchBookingSlots(ROUTE, '2026-09-22', { person: 'p', eventTemplate: 'tt-1' });
+        expect(axiosInstance.get).toHaveBeenLastCalledWith('/booking/form-key/BOOKING-1/slots?date=2026-09-22&person=p&eventTemplate=tt-1');
+        await holdBookingSlot(ROUTE, {
+            slot: 's',
+            contact: { name: 'Ana', email: 'ana@correo.com' },
+            eventTemplate: 'tt-1',
+        });
+        expect(axiosInstance.post).toHaveBeenLastCalledWith('/booking/form-key/BOOKING-1/hold', {
+            slot: 's',
+            contact: { name: 'Ana', email: 'ana@correo.com' },
+            eventTemplate: 'tt-1',
+        });
+    });
+    it('accepts only well-formed emails', () => {
+        expect(isValidEmail('juan@correo.com')).toBe(true);
+        expect(isValidEmail(' juan@correo.com ')).toBe(true);
+        expect(isValidEmail('juan@')).toBe(false);
+        expect(isValidEmail('juan correo.com')).toBe(false);
+        expect(isValidEmail(undefined)).toBe(false);
+    });
+    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: '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, { person: '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', email: 'ana@correo.com' },
+        });
+        expect(widgetInstance.post).toHaveBeenCalledWith('/booking/form-key/BOOKING-1/hold?idOrganization=acme', {
+            slot: 'slot-token',
+            contact: { name: 'Ana', email: 'ana@correo.com' },
+        });
+        expect(held).toEqual({ appointment: 'a1', hold: 'h1', lockedUntil: 'x' });
+        // A renewal carries only the renewal token and the hold secret: no slot, no contact.
+        await renewBookingHold(route, { renew: 'r1', hold: 'h1' });
+        expect(widgetInstance.post).toHaveBeenLastCalledWith('/booking/form-key/BOOKING-1/hold?idOrganization=acme', {
+            renew: 'r1',
+            hold: 'h1',
+        });
+        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('talks about an appointment by its link, on the same origin or naming the organization', async () => {
+        vi.mocked(axiosInstance.get).mockResolvedValue({ data: { token: 't1' } });
+        vi.mocked(widgetInstance.post).mockResolvedValue({ data: { token: 't2' } });
+        await expect(fetchBookingAppointment('a.b')).resolves.toEqual({ token: 't1' });
+        expect(axiosInstance.get).toHaveBeenCalledWith('/booking/appointment/a.b');
+        await expect(cancelBookingAppointment('a.b', 'acme')).resolves.toEqual({ token: 't2' });
+        expect(widgetInstance.post).toHaveBeenCalledWith('/booking/appointment/a.b/cancel?idOrganization=acme');
+        await moveBookingAppointment('a.b', 'slot-1', 'acme');
+        expect(widgetInstance.post).toHaveBeenLastCalledWith('/booking/appointment/a.b/move?idOrganization=acme', {
+            slot: 'slot-1',
+        });
+    });
+    it('reads the edge’s { code, message } refusal, plain text, and a generic message otherwise', () => {
+        const stale = toBookingError({
+            response: { status: 403, data: { code: 'STALE_OFFER', message: 'Esa persona ya no está disponible' } },
+        });
+        expect(stale).toBeInstanceOf(BookingEdgeError);
+        expect(stale.code).toBe(BookingErrorCodes.STALE_OFFER);
+        expect(stale.status).toBe(403);
+        expect(stale.message).toBe('Esa persona ya no está disponible');
+        expect(bookingErrorMessage({ response: { status: 404, data: 'Organization not found' } })).toBe('Organization not found');
+        expect(toBookingError({ response: { status: 429, data: '' } }).code).toBe(BookingErrorCodes.RATE_LIMITED);
+        expect(bookingErrorMessage(new Error('network'))).toBe('No pudimos reservar ese horario. Intenta de nuevo.');
+        expect(bookingErrorMessage(new Error('network'), 'No pudimos cargar los horarios.')).toBe('No pudimos cargar los horarios.');
+    });
+    it('gives a hold up only when the edge says so or its time ran out', () => {
+        const now = new Date('2026-10-14T15:00:00.000Z').getTime();
+        const later = '2026-10-14T15:10:00.000Z';
+        const earlier = '2026-10-14T14:59:00.000Z';
+        const refusal = (code) => new BookingEdgeError('x', code);
+        expect(holdLapsed(refusal(BookingErrorCodes.HOLD_EXPIRED), later, now)).toBe(true);
+        expect(holdLapsed(refusal(BookingErrorCodes.STALE_OFFER), later, now)).toBe(true);
+        // A network failure or a rate limit is retried on the next round, while the lock still runs.
+        expect(holdLapsed(refusal(), later, now)).toBe(false);
+        expect(holdLapsed(refusal(BookingErrorCodes.RATE_LIMITED), later, now)).toBe(false);
+        expect(holdLapsed(refusal(), earlier, now)).toBe(true);
+    });
+});

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