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

package/dist/FormSteps/StepHooks.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'vitest';
+import FormStepTypes, { EntityValueDataTypes } from '../constants/FormStepTypes';
+import { calcDeepDependencies } from './StepHooks';
+const form = (steps) => ({
+    steps: Object.entries(steps).reduce((acc, [id, step]) => ({
+        ...acc,
+        [id]: { id, idSection: 'section', type: FormStepTypes.TEXTINPUT, ...step },
+    }), {}),
+});
+const picker = (step) => ({
+    type: FormStepTypes.ENTITYVALUEPICKER,
+    idEntity: 'entity',
+    path: [],
+    filters: [],
+    options: {},
+    ...step,
+});
+const stepFilter = (idStep, required) => ({
+    idProperty: 'prop-' + idStep,
+    type: EntityValueDataTypes.STEP,
+    idStep,
+    any: false,
+    required,
+});
+describe('calcDeepDependencies', () => {
+    test('walks a linear chain deepest first, listing each id once', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['c'] },
+            c: {},
+        }));
+        expect(deps).toEqual(['c', 'b']);
+    });
+    test('lists a dependency shared by two branches once', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b', 'c'] },
+            b: { dependencies: ['d'] },
+            c: { dependencies: ['d'] },
+            d: {},
+        }));
+        expect(deps).toEqual(['d', 'b', 'c']);
+    });
+    test('terminates on an A -> B -> A cycle without listing the step itself', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['a'] },
+        }));
+        expect(deps).toEqual(['b']);
+    });
+    test('terminates on a cycle reached deeper in the walk', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['c'] },
+            c: { dependencies: ['b'] },
+        }));
+        expect(deps).toEqual(['c', 'b']);
+    });
+    test('terminates on a step that depends on itself', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['b'] },
+        }));
+        expect(deps).toEqual(['b']);
+    });
+    /**
+     * A draft an entity picker points back at itself with a required STEP filter: the filter is not
+     * in the saved `dependencies` yet, so it only reaches the walk through
+     * `entityValuePickerBlockingSteps`.
+     */
+    test('terminates on a self reference through a required STEP filter of an entity picker', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['picker'] },
+            picker: picker({ filters: [stepFilter('picker', true)] }),
+        }));
+        expect(deps).toEqual(['picker']);
+    });
+    test('terminates on a cycle closed by a required STEP filter of an entity picker', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['picker'] },
+            picker: picker({ filters: [stepFilter('other', true)] }),
+            other: { dependencies: ['picker'] },
+        }));
+        expect(deps).toEqual(['other', 'picker']);
+    });
+    test('keeps a dependency whose step the draft has already deleted', () => {
+        const deps = calcDeepDependencies('a', form({ a: { dependencies: ['gone'] } }));
+        expect(deps).toEqual(['gone']);
+    });
+    test('answers nothing for a step the form does not hold', () => {
+        expect(calcDeepDependencies('missing', form({}))).toEqual([]);
+    });
+});

package/dist/FormSteps/isStepHiddenByCondition.test.d.ts

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

package/dist/FormSteps/isStepHiddenByCondition.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { isStepHiddenByCondition } from './StepHooks';
+// A Selector shown only while the Proyecto picker holds a specific value — the shape the editor saves.
+const PROYECTO = 'ENTITYVALUEPICKER-proyecto';
+const condition = {
+    type: 'EXPRESSION',
+    expression: 'AND',
+    conditions: [
+        { type: 'FORM_STEP', stepType: 'ENTITYVALUEPICKER', idStep: PROYECTO, operator: 'EXISTS' },
+        { type: 'FORM_STEP', stepType: 'ENTITYVALUEPICKER', idStep: PROYECTO, operator: 'EQUAL', values: ['kai'] },
+    ],
+};
+const form = {
+    steps: {
+        [PROYECTO]: { id: PROYECTO, type: 'ENTITYVALUEPICKER' },
+        'SELECTOR-piso': { id: 'SELECTOR-piso', type: 'SELECTOR', condition },
+        'SELECTOR-libre': { id: 'SELECTOR-libre', type: 'SELECTOR' },
+    },
+};
+const dependency = (value) => ({
+    idOriginal: PROYECTO,
+    dependents: [],
+    value,
+    type: 'ENTITYVALUEPICKER',
+});
+describe('isStepHiddenByCondition', () => {
+    test('a step without condition is never hidden', () => {
+        expect(isStepHiddenByCondition('SELECTOR-libre', form, {})).toBe(false);
+    });
+    test('a step whose condition evaluates false is hidden', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, { [PROYECTO]: dependency({ _id: 'otro' }) })).toBe(true);
+    });
+    test('a step whose condition evaluates true is shown', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, { [PROYECTO]: dependency({ _id: 'kai' }) })).toBe(false);
+    });
+    test('an undecidable condition (its step is not in the store) counts as shown', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, {})).toBe(false);
+    });
+    test('a step unknown to the form counts as shown', () => {
+        expect(isStepHiddenByCondition('MAPPER-x-espacio', form, {})).toBe(false);
+    });
+});

package/dist/Icons/AddIcon.d.ts

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

package/dist/Icons/AddIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function AddIcon(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: "M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" }) }));
+}
+export default AddIcon;

package/dist/Icons/EditIcon.d.ts

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

package/dist/Icons/EditIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function EditIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, version: "1.1", viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z" }) }));
+}
+export default EditIcon;

package/dist/Icons/RemoveIcon.d.ts

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

package/dist/Icons/RemoveIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function RemoveIcon(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: "M19 13H5v-2h14v2z" }) }));
+}
+export default RemoveIcon;

package/dist/Icons/ViewDayIcon.d.ts

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

package/dist/Icons/ViewDayIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function ViewDayIcon(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: "M2 21h19v-2H2v2zm0-4h19v-8H2v8zm0-10h19V5H2v2z" }) }));
+}
+export default ViewDayIcon;

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/BookingService.d.ts

@@ -0,0 +1,226 @@
+import { BookingSlot, BookingValue } 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;
+}
+/** An event template of the step as the offer publishes it: a signed handle, never the template's id. */
+export interface BookingOfferEventTemplate {
+    token: string;
+    name: string;
+    description?: string;
+    /** The template's own duration, or the step's when the template has none. */
+    durationMinutes: number;
+    bookingMode?: string;
+}
+/** The event template an appointment was booked with: what the summary and the manage page show. */
+export interface BookingEventTemplateSummary {
+    name: string;
+    durationMinutes: number;
+}
+/** 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;
+    /** The step's event templates with something on offer; empty when the step has none. */
+    eventTemplates?: BookingOfferEventTemplate[];
+    /** The requester picks an event template first: the step lets them and there are two or more. */
+    requesterPicksType?: boolean;
+}
+/** What narrows a read of the offer: one person's calendar, one event template's slots and duration. */
+export interface BookingOfferQuery {
+    person?: string;
+    eventTemplate?: 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. `start`/`end` son los instantes
+ * reales reservados y `person` es quien atenderá (el servidor la elige cuando hay varias libres).
+ */
+export interface BookingHold {
+    appointment: string;
+    /** Secreto del dueño de la reserva: viaja con el envío del formulario. */
+    hold: string;
+    lockedUntil: string;
+    /** Token para la próxima renovación; vive hasta `lockedUntil` y cada renovación devuelve uno nuevo. */
+    renew: string;
+    start: string;
+    end: string;
+    /** Falta solo si el agente dejó la organización. */
+    person?: BookingOfferPerson;
+    /** The event template the hold was made with, when the requester picked one. */
+    eventTemplate?: BookingEventTemplateSummary;
+}
+export interface BookingContact {
+    name: string;
+    email: string;
+    phone?: string;
+}
+/** Los códigos con los que el borde de agendamiento explica un rechazo. */
+export declare enum BookingErrorCodes {
+    INVALID_REQUEST = "INVALID_REQUEST",
+    NOT_FOUND = "NOT_FOUND",
+    FORBIDDEN = "FORBIDDEN",
+    /** Un token de persona o de cupo venció: hay que recargar la oferta (o las horas). */
+    STALE_OFFER = "STALE_OFFER",
+    CONTACT_REQUIRED = "CONTACT_REQUIRED",
+    SLOT_TAKEN = "SLOT_TAKEN",
+    /** La renovación llegó tarde: la reserva ya venció. */
+    HOLD_EXPIRED = "HOLD_EXPIRED",
+    /** El enlace de la cita venció, fue alterado o ya no nombra ninguna cita. */
+    INVALID_LINK = "INVALID_LINK",
+    /** La cita ya no se puede cancelar ni mover: está cancelada o su paso ya no existe. */
+    APPOINTMENT_CLOSED = "APPOINTMENT_CLOSED",
+    RATE_LIMITED = "RATE_LIMITED",
+    METHOD_NOT_ALLOWED = "METHOD_NOT_ALLOWED",
+    INTERNAL = "INTERNAL"
+}
+/** Un rechazo del borde ya leído: el mensaje es apto para mostrarse a quien agenda. */
+export declare class BookingEdgeError extends Error {
+    readonly code?: string;
+    readonly status?: number;
+    constructor(message: string, code?: string, status?: number);
+}
+/** El texto que muestra el picker cuando la renovación de la reserva falla para siempre. */
+export declare const HOLD_LAPSED_MESSAGE = "Tu reserva venci\u00F3; elige la hora de nuevo.";
+/**
+ * Una cita ya agendada, vista desde el enlace de sus correos: cuándo, con quién y cómo, y lo que quien
+ * la agendó todavía puede hacer con ella.
+ */
+export interface BookingAppointment {
+    /** El handle del enlace para esta cita; cambia cuando la cita se mueve, y el siguiente pedido usa este. */
+    token: string;
+    status: 'CONFIRMED' | 'CANCELLED';
+    start: string;
+    end: string;
+    /** La zona horaria de la organización, en la que se muestran `start` y `end`. */
+    timeZone: string;
+    person?: Omit<BookingOfferPerson, 'token'>;
+    bookingMode?: string;
+    eventTemplateName?: string;
+    eventTemplate?: BookingEventTemplateSummary;
+    joinUrl?: string;
+    /**
+     * Cómo ofrecer otra hora con la misma persona; falta cuando la cita ya no se puede mover desde aquí.
+     * `eventTemplate` is the handle of the appointment's template, so the new hour keeps its type.
+     */
+    reschedule?: {
+        apiKey: string;
+        idStep: string;
+        person: string;
+        durationMinutes: number;
+        eventTemplate?: string;
+    };
+}
+/** La cita que nombra el enlace. Un enlace vencido o alterado responde 404 `INVALID_LINK`. */
+export declare function fetchBookingAppointment(token: string, idOrganization?: string): Promise<BookingAppointment>;
+/** Cancela la cita; responde la cita ya cancelada. Una cita que ya no está vigente responde 409 `APPOINTMENT_CLOSED`. */
+export declare function cancelBookingAppointment(token: string, idOrganization?: string): Promise<BookingAppointment>;
+/**
+ * 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 declare function moveBookingAppointment(token: string, slot: string, idOrganization?: string): Promise<BookingAppointment>;
+/**
+ * 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 declare function fetchBookingOffer(route: BookingRoute, query?: BookingOfferQuery): 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, query?: BookingOfferQuery): Promise<BookingOfferSlot[]>;
+/**
+ * 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 declare function holdBookingSlot(route: BookingRoute, body: {
+    slot: string;
+    contact: BookingContact;
+    eventTemplate?: string;
+}): Promise<BookingHold>;
+/**
+ * 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 declare function renewBookingHold(route: BookingRoute, body: {
+    renew: string;
+    hold: string;
+}): 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;
+/** El día `YYYY-MM-DD` de un instante en una zona horaria. */
+export declare function dayIn(iso: string, timeZone: string): string;
+/** La zona horaria del navegador, o `undefined` si no se puede leer. */
+export declare function browserTimeZone(): string | undefined;
+/**
+ * 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 declare function zoneLabel(timeZone: string, at?: Date): 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;
+/**
+ * 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 declare function toPickerSlots(slots: BookingOfferSlot[], timeZone: string): BookingSlot[];
+/**
+ * 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 declare function holdToValue(held: BookingHold, timeZone: string): Pick<BookingValue, 'appointment' | 'hold' | 'lockedUntil' | 'date' | 'startTime' | 'endTime'> & Partial<Pick<BookingValue, 'personId' | 'personName' | 'eventTemplate'>>;
+/** 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;
+/** Si un texto es un correo con forma válida (lo mismo que exige el borde al reservar). */
+export declare function isValidEmail(text?: string): boolean;
+/** El código HTTP de un error del cliente HTTP, si lo hay. */
+export declare function statusOf(error: unknown): number | undefined;
+/**
+ * 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 declare function toBookingError(error: unknown, fallback?: string): BookingEdgeError;
+/** El motivo de un rechazo del borde, o un mensaje genérico. */
+export declare function bookingErrorMessage(error: unknown, fallback?: string): string;
+/**
+ * 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 declare function holdLapsed(error: BookingEdgeError, lockedUntil: string | undefined, now?: number): boolean;