@arquimedes.co/eureka-forms 3.0.50-test → 3.0.52-new-steps

package/dist/@Types/PredefinedSelectorFormStep.d.ts

@@ -0,0 +1,51 @@
+/**
+ * DRAFT — PredefinedSelectorFormStep types
+ *
+ * Paso que reemplaza tener que configurar manualmente opciones de selectores
+ * para listas fijas y controladas por Capta (países, ciudades, monedas, etc.).
+ * Las opciones vienen de APIs internas — el formulario no necesita configurarlas.
+ *
+ * También resuelve la cascada Country → State → City via parentStepId.
+ */
+import { GSmartSelect } from './GenericFormSteps';
+export declare enum PredefinedOptionType {
+    /** ISO 3166-1 — lista de países */
+    COUNTRY = "COUNTRY",
+    /**
+     * Departamento / provincia / estado.
+     * Requiere parentStepId apuntando a un step COUNTRY.
+     */
+    STATE = "STATE",
+    /**
+     * Ciudad / municipio.
+     * Requiere parentStepId apuntando a un step STATE (o COUNTRY si no hay STATE).
+     */
+    CITY = "CITY",
+    /** ISO 4217 — monedas (USD, COP, EUR, etc.) */
+    CURRENCY = "CURRENCY",
+    /** BCP 47 — idiomas (es, en, pt, etc.) */
+    LANGUAGE = "LANGUAGE",
+    /** Tipos de canal de comunicación (WhatsApp, Email, Teléfono) */
+    COMMUNICATION_CHANNEL_TYPE = "COMMUNICATION_CHANNEL_TYPE",
+    /** Tipos de documento de identidad por país (CC, NIT, Pasaporte, etc.) */
+    DOCUMENT_TYPE = "DOCUMENT_TYPE",
+    /** Días de la semana */
+    DAY_OF_WEEK = "DAY_OF_WEEK",
+    /** Meses del año */
+    MONTH = "MONTH"
+}
+export interface PredefinedSelectorStep extends GSmartSelect {
+    type: 'PREDEFINED_SELECTOR';
+    predefinedType: PredefinedOptionType;
+    /**
+     * Solo para STATE y CITY: id del step padre que filtra las opciones.
+     *   - COUNTRY step → filtra estados del país seleccionado
+     *   - STATE step   → filtra ciudades del estado seleccionado
+     *
+     * Si no se especifica, se listan todas las opciones sin filtrar.
+     */
+    parentStepId?: string;
+    maxSize?: number;
+    defaultValue?: string;
+}
+export type PredefinedSelectorValue = string;

package/dist/@Types/PredefinedSelectorFormStep.js

@@ -0,0 +1,39 @@
+/**
+ * DRAFT — PredefinedSelectorFormStep types
+ *
+ * Paso que reemplaza tener que configurar manualmente opciones de selectores
+ * para listas fijas y controladas por Capta (países, ciudades, monedas, etc.).
+ * Las opciones vienen de APIs internas — el formulario no necesita configurarlas.
+ *
+ * También resuelve la cascada Country → State → City via parentStepId.
+ */
+// ===========================================================================
+// Tipos predefinidos disponibles
+// ===========================================================================
+export var PredefinedOptionType;
+(function (PredefinedOptionType) {
+    /** ISO 3166-1 — lista de países */
+    PredefinedOptionType["COUNTRY"] = "COUNTRY";
+    /**
+     * Departamento / provincia / estado.
+     * Requiere parentStepId apuntando a un step COUNTRY.
+     */
+    PredefinedOptionType["STATE"] = "STATE";
+    /**
+     * Ciudad / municipio.
+     * Requiere parentStepId apuntando a un step STATE (o COUNTRY si no hay STATE).
+     */
+    PredefinedOptionType["CITY"] = "CITY";
+    /** ISO 4217 — monedas (USD, COP, EUR, etc.) */
+    PredefinedOptionType["CURRENCY"] = "CURRENCY";
+    /** BCP 47 — idiomas (es, en, pt, etc.) */
+    PredefinedOptionType["LANGUAGE"] = "LANGUAGE";
+    /** Tipos de canal de comunicación (WhatsApp, Email, Teléfono) */
+    PredefinedOptionType["COMMUNICATION_CHANNEL_TYPE"] = "COMMUNICATION_CHANNEL_TYPE";
+    /** Tipos de documento de identidad por país (CC, NIT, Pasaporte, etc.) */
+    PredefinedOptionType["DOCUMENT_TYPE"] = "DOCUMENT_TYPE";
+    /** Días de la semana */
+    PredefinedOptionType["DAY_OF_WEEK"] = "DAY_OF_WEEK";
+    /** Meses del año */
+    PredefinedOptionType["MONTH"] = "MONTH";
+})(PredefinedOptionType || (PredefinedOptionType = {}));

package/dist/@Types/StepRef.d.ts

@@ -0,0 +1,135 @@
+/**
+ * DRAFT — Sistema de referencias dinámicas entre steps
+ *
+ * Permite que la configuración de un paso use el valor en tiempo de ejecución
+ * de otro step del mismo formulario, en lugar de un literal fijo.
+ *
+ * Patrón de uso:
+ *
+ *   // Valor fijo definido en la configuración del formulario
+ *   suffix: { type: 'FIXED', value: 'km' }
+ *
+ *   // Valor tomado del step 'step_unidad' cuando el usuario interactúa
+ *   suffix: { type: 'STEP_REF', idStep: 'step_unidad', fallback: 'm' }
+ *
+ * Se puede aplicar a cualquier campo de configuración cuyo valor deba
+ * responder a la selección previa del usuario: sufijos, unidades, monedas,
+ * títulos dinámicos, límites numéricos, etc.
+ */
+/**
+ * Representa un valor estático/literal configurado en tiempo de diseño.
+ * No cambia dinámicamente según las respuestas del usuario.
+ *
+ * @typeParam T - Tipo de dato del valor estático.
+ */
+export interface FixedRef<T> {
+    /**
+     * Indica que el valor es fijo.
+     */
+    type: 'FIXED';
+    /**
+     * El valor estático de tipo T.
+     * @example "km"
+     * @example 50
+     */
+    value: T;
+}
+/**
+ * Referencia dinámica al valor actual de otro step en el mismo formulario.
+ * El runtime del formulario sustituye esta referencia por el valor que el usuario
+ * haya ingresado en el step indicado.
+ *
+ * @typeParam TAllowed - Literal(es) de tipo de step permitidos como origen.
+ *   Por defecto es `string` (cualquier tipo de step). Pasar un literal union
+ *   permite al Form Builder filtrar la lista de steps disponibles en la UI.
+ *
+ * @example
+ * ```ts
+ * // Referencia a cualquier tipo de step
+ * const ref: StepRef = {
+ *   type: 'STEP_REF',
+ *   idStep: 'step_unidad_medida',
+ *   fallback: 'm'
+ * }
+ *
+ * // Referencia restringida únicamente a pasos de tipo LOCATION
+ * const refLocation: StepRef<'LOCATION'> = {
+ *   type: 'STEP_REF',
+ *   idStep: 'step_destino_cliente',
+ *   allowedStepTypes: ['LOCATION']
+ * }
+ * ```
+ */
+export interface StepRef<TAllowed extends string = string> {
+    /**
+     * Indica que el valor se toma dinámicamente de otro paso.
+     */
+    type: 'STEP_REF';
+    /**
+     * ID del paso origen en el formulario del cual se leerá el valor en tiempo de ejecución.
+     * @example "step_ubicacion_cliente"
+     */
+    idStep: string;
+    /**
+     * Valor de respaldo (fallback) en formato de texto a utilizar mientras el paso referenciado
+     * no contenga ningún valor (ej: porque el usuario aún no llega a ese paso).
+     * Si se omite, el campo referenciador se comportará como vacío o sin unidad.
+     *
+     * @example "m"
+     */
+    fallback?: string;
+    /**
+     * Lista de tipos de pasos permitidos para esta referencia.
+     * Ayuda al Form Builder a filtrar la interfaz de selección de campos y es
+     * validada por el backend al guardar la configuración del formulario.
+     * Si no se define, se permite referenciar cualquier tipo de paso.
+     *
+     * @example ["LOCATION"]
+     * @example ["PREDEFINED_SELECTOR", "CHECKBOX"]
+     */
+    allowedStepTypes?: TAllowed[];
+}
+/**
+ * Tipo genérico para campos que admiten tanto un valor estático como una referencia dinámica.
+ *
+ * @typeParam T - Tipo del valor cuando es FIXED (ej: `string`, `number`, `boolean`).
+ * @typeParam TAllowed - Tipos de paso de origen permitidos si es STEP_REF.
+ *
+ * @example
+ * ```ts
+ * // Un sufijo de texto dinámico:
+ * const sufijo: DynamicRef<string> = { type: 'FIXED', value: 'km' };
+ *
+ * // Una coordenada geográfica que debe venir de un paso de mapa:
+ * const origen: DynamicRef<LocationCoords, 'LOCATION'> = {
+ *   type: 'STEP_REF',
+ *   idStep: 'step_mapa_inicio',
+ *   allowedStepTypes: ['LOCATION']
+ * };
+ * ```
+ */
+export type DynamicRef<T, TAllowed extends string = string> = FixedRef<T> | StepRef<TAllowed>;
+/**
+ * Comprueba si la referencia dinámica recibida es de tipo FIXED.
+ * Funciona como Type Guard para TypeScript.
+ *
+ * @example
+ * ```ts
+ * if (isFixedRef(miRef)) {
+ *   console.log("El valor es:", miRef.value);
+ * }
+ * ```
+ */
+export declare function isFixedRef<T, TAllowed extends string = string>(ref: DynamicRef<T, TAllowed>): ref is FixedRef<T>;
+/**
+ * Comprueba si la referencia dinámica recibida es de tipo STEP_REF.
+ * Funciona como Type Guard para TypeScript.
+ *
+ * @example
+ * ```ts
+ * if (isStepRef(miRef)) {
+ *   console.log("Apunta al step:", miRef.idStep);
+ * }
+ * ```
+ */
+export declare function isStepRef<T, TAllowed extends string = string>(ref: DynamicRef<T, TAllowed>): ref is StepRef<TAllowed>;

package/dist/@Types/StepRef.js

@@ -0,0 +1,49 @@
+/**
+ * DRAFT — Sistema de referencias dinámicas entre steps
+ *
+ * Permite que la configuración de un paso use el valor en tiempo de ejecución
+ * de otro step del mismo formulario, en lugar de un literal fijo.
+ *
+ * Patrón de uso:
+ *
+ *   // Valor fijo definido en la configuración del formulario
+ *   suffix: { type: 'FIXED', value: 'km' }
+ *
+ *   // Valor tomado del step 'step_unidad' cuando el usuario interactúa
+ *   suffix: { type: 'STEP_REF', idStep: 'step_unidad', fallback: 'm' }
+ *
+ * Se puede aplicar a cualquier campo de configuración cuyo valor deba
+ * responder a la selección previa del usuario: sufijos, unidades, monedas,
+ * títulos dinámicos, límites numéricos, etc.
+ */
+// ---------------------------------------------------------------------------
+// Helpers de narrowing
+// ---------------------------------------------------------------------------
+/**
+ * Comprueba si la referencia dinámica recibida es de tipo FIXED.
+ * Funciona como Type Guard para TypeScript.
+ *
+ * @example
+ * ```ts
+ * if (isFixedRef(miRef)) {
+ *   console.log("El valor es:", miRef.value);
+ * }
+ * ```
+ */
+export function isFixedRef(ref) {
+    return ref.type === 'FIXED';
+}
+/**
+ * Comprueba si la referencia dinámica recibida es de tipo STEP_REF.
+ * Funciona como Type Guard para TypeScript.
+ *
+ * @example
+ * ```ts
+ * if (isStepRef(miRef)) {
+ *   console.log("Apunta al step:", miRef.idStep);
+ * }
+ * ```
+ */
+export function isStepRef(ref) {
+    return ref.type === 'STEP_REF';
+}

package/dist/App/App.stories.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { StoryObj } from '@storybook/react-vite';
+import App from './App';
+declare function FullHeight(Story: React.ComponentType): JSX.Element;
+declare const meta: {
+    title: string;
+    component: typeof App;
+    decorators: (typeof FullHeight)[];
+    parameters: {
+        layout: string;
+    };
+    args: {
+        isWidget: false;
+        idOrganization: string;
+        valuesData: {};
+        customSubmit: (values: Record<string, unknown>) => Promise<void>;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+/** Parsed form, as the widget receives it from the API. */
+export declare const Parseado: Story;
+/** TITLE with an INTEGRATION entity depending on a TEXTINPUT step. */
+export declare const IntegracionConStepDependencia: Story;
+/** Parsed form pre-filled with values. */
+export declare const ParseadoConValores: Story;
+/** Raw builder form: EUREKA entities resolved locally via mapDraftEntities. */
+export declare const PreParseado: Story;
+/** Final view (postview): what the user submitted, rendered read-only. */
+export declare const Postview: Story;

package/dist/App/App.stories.js

@@ -0,0 +1,298 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import App from './App';
+/**
+ * Stories to test full forms from a `{ form, values }` payload:
+ *
+ * - `Parseado`: a parsed form (what the widget receives, drafts are plain text).
+ * - `PreParseado`: a raw builder form (EUREKA/ENTITYVALUES entities still in the
+ *   drafts, `rootSteps` instead of section steps). Entities are resolved locally
+ *   with a stubbed `mapDraftEntities`, so no backend is needed.
+ *
+ * Paste any form JSON into `formData`/`valuesData` from the Controls panel.
+ */
+/** Raw builder form (pre-parsed): title draft still has EUREKA entities. */
+const preParsedForm = {
+    steps: {
+        'TITLE-NkSFXOcH-z': {
+            id: 'TITLE-NkSFXOcH-z',
+            type: 'TITLE',
+            title: {
+                blocks: [
+                    {
+                        key: '2ri0w',
+                        type: 'unstyled',
+                        text: 'Razón social (Proveedor) ',
+                        depth: 0,
+                        inlineStyleRanges: [{ offset: 0, length: 24, style: 'BOLD' }],
+                        entityRanges: [{ offset: 0, length: 24, key: 0 }],
+                        data: {},
+                    },
+                ],
+                entityMap: {
+                    '0': {
+                        type: 'EUREKA',
+                        mutability: 'IMMUTABLE',
+                        data: {
+                            type: 'ENTITYVALUES',
+                            idEntity: '6400adf810f16b8b68c24e72',
+                            renderType: 'INLINE',
+                            block: {
+                                key: '2522g',
+                                type: 'unstyled',
+                                text: 'Razón social (Proveedor)',
+                                depth: 0,
+                                inlineStyleRanges: [{ offset: 0, length: 24, style: 'BOLD' }],
+                                entityRanges: [{ offset: 0, length: 24, key: 0 }],
+                                data: {},
+                            },
+                            entityMap: {
+                                '0': {
+                                    type: 'EUREKA',
+                                    mutability: 'IMMUTABLE',
+                                    data: {
+                                        type: 'ENTITYVALUE_MAPPING',
+                                        idEntity: '6400adf810f16b8b68c24e72',
+                                        idProperty: 'NombreCompleto',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        'TEXTINPUT-lCmhOv5hYA': {
+            id: 'TEXTINPUT-lCmhOv5hYA',
+            type: 'TEXTINPUT',
+            label: 'name',
+            description: '',
+            required: false,
+            size: 2,
+            isSubject: false,
+        },
+    },
+    size: {
+        blockNum: 4,
+        blockSize: 210,
+        spacingSize: 20,
+    },
+    rootSteps: ['TITLE-NkSFXOcH-z', 'TEXTINPUT-lCmhOv5hYA'],
+    label: 'Enviar',
+    firstSection: 'FIRST',
+    sections: {
+        FIRST: {
+            id: 'FIRST',
+            steps: ['TITLE-NkSFXOcH-z', 'TEXTINPUT-lCmhOv5hYA'],
+            name: '',
+            nextSection: null,
+        },
+    },
+};
+/** The same form already parsed: drafts are plain text, no pending entities. */
+const parsedForm = {
+    ...preParsedForm,
+    steps: {
+        ...preParsedForm.steps,
+        'TITLE-NkSFXOcH-z': {
+            id: 'TITLE-NkSFXOcH-z',
+            type: 'TITLE',
+            title: {
+                blocks: [
+                    {
+                        key: '2ri0w',
+                        type: 'unstyled',
+                        text: 'Razón social (Proveedor)',
+                        depth: 0,
+                        inlineStyleRanges: [{ offset: 0, length: 24, style: 'BOLD' }],
+                        entityRanges: [],
+                        data: {},
+                    },
+                ],
+                entityMap: {},
+            },
+        },
+    },
+};
+const exampleValues = {
+    'TEXTINPUT-lCmhOv5hYA': 'Capta S.A.S.',
+};
+/**
+ * Local replacement for the backend `/draft/mapFormEntities` call: resolves a
+ * draft by dropping its EUREKA entities and keeping the literal text, so
+ * pre-parsed forms render in Storybook without a server.
+ */
+function makeStoryMapDraftEntities(form) {
+    return (property) => {
+        const path = property.split('.');
+        const stepProperty = path.pop();
+        const idStep = path[0];
+        const step = form.steps[idStep];
+        const draft = stepProperty ? step?.[stepProperty] : undefined;
+        if (!draft)
+            return Promise.reject(new Error(`Storybook mapDraftEntities: draft not found for "${property}"`));
+        return Promise.resolve({
+            blocks: draft.blocks.map((block) => ({ ...block, entityRanges: [] })),
+            entityMap: {},
+        });
+    };
+}
+function FullHeight(Story) {
+    return (_jsx("div", { style: { height: '100vh', display: 'flex', flexDirection: 'column' }, children: _jsx(Story, {}) }));
+}
+const meta = {
+    title: 'Form/FormRenderer',
+    component: App,
+    decorators: [FullHeight],
+    parameters: { layout: 'fullscreen' },
+    args: {
+        isWidget: false,
+        idOrganization: 'storybook',
+        valuesData: {},
+        customSubmit: (values) => {
+            // eslint-disable-next-line no-console
+            console.log('Storybook submit:', values);
+            return Promise.resolve();
+        },
+    },
+};
+export default meta;
+/** Parsed form, as the widget receives it from the API. */
+export const Parseado = {
+    args: {
+        formData: parsedForm,
+    },
+};
+/**
+ * Regression: TITLE whose title draft has an INTEGRATION entity parameterized by a
+ * TEXTINPUT step (`dependencies: [idStep]`). Mimics the backend contract of
+ * `/draft/mapFormEntities` (`keepNotMapped`): with the dependency unset the entity
+ * can't resolve and comes back untouched; with a value the text is resolved and the
+ * entity dropped. Production crashed with React #185 (max update depth) on render.
+ */
+const integrationTitleForm = {
+    steps: {
+        'TITLE-w4yCyiB1LM': {
+            id: 'TITLE-w4yCyiB1LM',
+            type: 'TITLE',
+            dependencies: ['TEXTINPUT-bwKwg_jKzD'],
+            description: {
+                blocks: [
+                    {
+                        depth: 0,
+                        data: {},
+                        inlineStyleRanges: [],
+                        text: '',
+                        type: 'unstyled',
+                        key: '3hfq7',
+                        entityRanges: [],
+                    },
+                ],
+                entityMap: {},
+            },
+            title: {
+                blocks: [
+                    {
+                        depth: 0,
+                        data: {},
+                        inlineStyleRanges: [{ offset: 7, length: 31, style: 'BOLD' }],
+                        text: 'Título Test Draft Integration Con Step ',
+                        type: 'unstyled',
+                        key: '0',
+                        entityRanges: [{ offset: 7, length: 31, key: 0 }],
+                    },
+                ],
+                entityMap: {
+                    '0': {
+                        type: 'EUREKA',
+                        mutability: 'IMMUTABLE',
+                        data: {
+                            type: 'INTEGRATION',
+                            idIntegration: '6960368e749b73499854bcac',
+                            values: { param: { type: 'STEP', idStep: 'TEXTINPUT-bwKwg_jKzD' } },
+                        },
+                    },
+                },
+            },
+        },
+        'TEXTINPUT-bwKwg_jKzD': {
+            id: 'TEXTINPUT-bwKwg_jKzD',
+            type: 'TEXTINPUT',
+            label: 'Campo',
+            description: '',
+            required: false,
+            size: 2,
+            isSubject: false,
+        },
+    },
+    size: { blockNum: 4, blockSize: 210, spacingSize: 20 },
+    rootSteps: ['TITLE-w4yCyiB1LM', 'TEXTINPUT-bwKwg_jKzD'],
+    label: 'Enviar',
+    firstSection: 'FIRST',
+    sections: {
+        FIRST: {
+            id: 'FIRST',
+            steps: ['TITLE-w4yCyiB1LM', 'TEXTINPUT-bwKwg_jKzD'],
+            name: '',
+            nextSection: null,
+        },
+    },
+};
+function makeIntegrationMapDraftEntities(form) {
+    return (property, dependencies) => {
+        const path = property.split('.');
+        const stepProperty = path.pop();
+        const idStep = path[0];
+        const step = form.steps[idStep];
+        const draft = stepProperty ? step?.[stepProperty] : undefined;
+        if (!draft)
+            return Promise.reject(new Error(`Storybook mapDraftEntities: draft not found for "${property}"`));
+        const depValue = dependencies['TEXTINPUT-bwKwg_jKzD'];
+        // Unresolvable integration (dependency null): keepNotMapped — return the draft as-is.
+        if (depValue == null || depValue === '')
+            return Promise.resolve(JSON.parse(JSON.stringify(draft)));
+        // Resolved: replace each entity range with the integration result, drop the entities.
+        return Promise.resolve({
+            blocks: draft.blocks.map((block) => {
+                let text = block.text;
+                for (const range of [...block.entityRanges].sort((a, b) => b.offset - a.offset)) {
+                    const chars = [...text];
+                    chars.splice(range.offset, range.length, ...`[${depValue}]`);
+                    text = chars.join('');
+                }
+                return { ...block, text, entityRanges: [], inlineStyleRanges: [] };
+            }),
+            entityMap: {},
+        });
+    };
+}
+/** TITLE with an INTEGRATION entity depending on a TEXTINPUT step. */
+export const IntegracionConStepDependencia = {
+    args: {
+        formData: integrationTitleForm,
+        mapDraftEntities: makeIntegrationMapDraftEntities(integrationTitleForm),
+    },
+};
+/** Parsed form pre-filled with values. */
+export const ParseadoConValores = {
+    args: {
+        formData: parsedForm,
+        valuesData: exampleValues,
+    },
+};
+/** Raw builder form: EUREKA entities resolved locally via mapDraftEntities. */
+export const PreParseado = {
+    args: {
+        formData: preParsedForm,
+        mapDraftEntities: makeStoryMapDraftEntities(preParsedForm),
+    },
+};
+/** Final view (postview): what the user submitted, rendered read-only. */
+export const Postview = {
+    args: {
+        formData: parsedForm,
+        valuesData: exampleValues,
+        postview: true,
+        internal: true,
+        editable: false,
+    },
+};

package/dist/App/App.stories.test.d.ts

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

package/dist/App/App.stories.test.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { composeStories } from '@storybook/react-vite';
+import { describe, expect, it } from 'vitest';
+import '@testing-library/jest-dom';
+import * as stories from './App.stories';
+const { Parseado, ParseadoConValores, PreParseado, Postview, IntegracionConStepDependencia } = composeStories(stories);
+describe('FormRenderer stories', () => {
+    it('renders the parsed form with its title and input', async () => {
+        const { container } = render(_jsx(Parseado, {}));
+        await waitFor(() => {
+            expect(container.textContent).toContain('Razón social');
+        });
+        expect(screen.getAllByText('name').length).toBeGreaterThan(0);
+    });
+    it('renders the parsed form pre-filled with values', async () => {
+        render(_jsx(ParseadoConValores, {}));
+        await waitFor(() => {
+            expect(screen.getByDisplayValue('Capta S.A.S.')).toBeInTheDocument();
+        });
+    });
+    it('renders the pre-parsed form resolving EUREKA entities locally', async () => {
+        const { container } = render(_jsx(PreParseado, {}));
+        await waitFor(() => {
+            expect(container.textContent).toContain('Razón social');
+        });
+        expect(screen.getAllByText('name').length).toBeGreaterThan(0);
+    });
+    it('renders the postview with the submitted value', async () => {
+        render(_jsx(Postview, {}));
+        await waitFor(() => {
+            expect(screen.getByDisplayValue('Capta S.A.S.')).toBeInTheDocument();
+        });
+    });
+    it('renders a title with an INTEGRATION entity depending on a step and reacts to typing', async () => {
+        const { container } = render(_jsx(IntegracionConStepDependencia, {}));
+        await waitFor(() => {
+            expect(container.textContent).toContain('Título');
+        });
+        const input = await screen.findByRole('textbox');
+        await userEvent.type(input, 'hola');
+        // The dependency dispatch is debounced (1s), so give the refetch room to land.
+        await waitFor(() => {
+            expect(container.textContent).toContain('[hola]');
+        }, { timeout: 5000 });
+        // Changing the dependency AFTER the first resolution must re-map the title:
+        // the stored value is a mapped copy with its entities stripped, so mapping
+        // has to keep keying off the original step draft.
+        await userEvent.clear(input);
+        await userEvent.type(input, 'chao');
+        await waitFor(() => {
+            expect(container.textContent).toContain('[chao]');
+        }, { timeout: 5000 });
+    });
+});

package/dist/FormSteps/BookingStep/BookingStep.d.ts

@@ -0,0 +1,17 @@
+import { BookingStep } from '../../@Types/BookingFormStep';
+import { BookingSlot } from '../../@Types/BookingFormStep';
+import { StepProps } from '../Step';
+export interface BookingStepProps extends StepProps {
+    step: BookingStep;
+    /**
+     * Callback to fetch available slots for a given person + date.
+     * The form host wires this to their availability API.
+     * If omitted, the component shows an empty slot list.
+     */
+    fetchSlots?: (params: {
+        personId?: string;
+        date: string;
+    }) => Promise<BookingSlot[]>;
+}
+declare function BookingStepComponent(props: BookingStepProps): JSX.Element;
+export default BookingStepComponent;