@arquimedes.co/eureka-forms 3.0.54-new-steps → 3.0.56-new-steps

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

@@ -3,7 +3,7 @@
  * Este archivo existe solo para compatibilidad retroactiva.
  * Usar `CalendarFormStep.ts` directamente.
  */
-export type { CalendarStep as AvailabilityStep } from './CalendarFormStep';
+export type { AvailabilityStep } from './CalendarFormStep';
 export type { CalendarValue as AvailabilityValue } from './CalendarFormStep';
 export { CalendarEventCategory as AvailabilityEventCategory } from './CalendarFormStep';
 export { CalendarDefaultView } from './CalendarFormStep';

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

@@ -117,7 +117,7 @@ export interface BookingStep extends GBaseStep {
      * se usa para filtrar los slots. Útil cuando el dueño del calendario también
      * llena el formulario y define su disponibilidad en el mismo flujo.
      */
-    calendarRef?: DynamicRef<CalendarValue, 'CALENDAR'>;
+    availabilityRef?: DynamicRef<CalendarValue, 'AVAILABILITY'>;
     size: 1 | 2 | 3 | 4;
 }
 /**

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

@@ -1,12 +1,9 @@
 /**
- * CalendarFormStep — paso de calendario completo (powered by MUI X Scheduler).
+ * Tipos del paso AVAILABILITY (pregunta de disponibilidad) y del valor de
+ * calendario compartido con el paso BOOKING.
  *
- * Permite al usuario (el dueño del formulario o quien lo responde) gestionar
- * su calendario: definir horarios de trabajo, crear eventos nombrados, marcar
- * bloques de disponibilidad por modalidad, bloquear horas y más.
- *
- * Renombrado desde `AvailabilityFormStep`. El archivo anterior re-exporta
- * desde aquí por compatibilidad retroactiva.
+ * El calendario completo (Google-like) vive en el admin; el form solo captura
+ * ventanas de disponibilidad con `ErkAvailabilityPicker` (grid semanal compacto).
  */
 import { GBaseStep } from './GenericFormSteps';
 import FormStepTypes from '../constants/FormStepTypes';
@@ -43,6 +40,26 @@ export declare enum CalendarDefaultView {
     MONTH = "month",
     AGENDA = "agenda"
 }
+/**
+ * Quién puede ver el detalle del evento.
+ */
+export declare enum CalendarEventVisibility {
+    /** Solo el dueño del calendario ve el detalle. */
+    PERSONAL = "PERSONAL",
+    /** Visible para toda la organización. */
+    ORGANIZATION = "ORGANIZATION"
+}
+/**
+ * Invitado / implicado en un evento (como los invitados de Google Calendar).
+ */
+export interface CalendarAttendee {
+    /** ID de la persona en el sistema (si es un agente interno). */
+    id?: string;
+    /** Nombre visible. */
+    name: string;
+    /** Correo (invitados externos o para notificar). */
+    email?: string;
+}
 /**
  * Plantilla de tipo de evento que el usuario puede seleccionar al crear un bloque.
  * Equivale a las "categorías de evento" visibles en la UI del scheduler.
@@ -74,11 +91,11 @@ export interface CalendarEventTemplate {
     maxConcurrentBookings?: number;
 }
 /**
- * Paso de tipo `CALENDAR`.
- * Renderiza un MUI X Scheduler completo donde el usuario gestiona su agenda.
+ * Paso de tipo `AVAILABILITY`: pregunta de disponibilidad compacta (grid
+ * semanal día × hora). Las ventanas capturadas pueden alimentar un paso BOOKING.
  */
-export interface CalendarStep extends GBaseStep {
-    type: FormStepTypes.CALENDAR;
+export interface AvailabilityStep extends GBaseStep {
+    type: FormStepTypes.AVAILABILITY;
     label: string;
     description: string | null;
     required: boolean;
@@ -188,5 +205,5 @@ export interface CalendarValue {
     /** Zona horaria en la que se capturaron los datos. */
     timezone?: string;
 }
-export type { CalendarStep as AvailabilityStep };
+export type { AvailabilityStep as CalendarStep };
 export type { CalendarValue as AvailabilityValue };

package/dist/@Types/CalendarFormStep.js

@@ -1,12 +1,9 @@
 /**
- * CalendarFormStep — paso de calendario completo (powered by MUI X Scheduler).
+ * Tipos del paso AVAILABILITY (pregunta de disponibilidad) y del valor de
+ * calendario compartido con el paso BOOKING.
  *
- * Permite al usuario (el dueño del formulario o quien lo responde) gestionar
- * su calendario: definir horarios de trabajo, crear eventos nombrados, marcar
- * bloques de disponibilidad por modalidad, bloquear horas y más.
- *
- * Renombrado desde `AvailabilityFormStep`. El archivo anterior re-exporta
- * desde aquí por compatibilidad retroactiva.
+ * El calendario completo (Google-like) vive en el admin; el form solo captura
+ * ventanas de disponibilidad con `ErkAvailabilityPicker` (grid semanal compacto).
  */
 // ===========================================================================
 // Enums
@@ -46,3 +43,13 @@ export var CalendarDefaultView;
     CalendarDefaultView["MONTH"] = "month";
     CalendarDefaultView["AGENDA"] = "agenda";
 })(CalendarDefaultView || (CalendarDefaultView = {}));
+/**
+ * Quién puede ver el detalle del evento.
+ */
+export var CalendarEventVisibility;
+(function (CalendarEventVisibility) {
+    /** Solo el dueño del calendario ve el detalle. */
+    CalendarEventVisibility["PERSONAL"] = "PERSONAL";
+    /** Visible para toda la organización. */
+    CalendarEventVisibility["ORGANIZATION"] = "ORGANIZATION";
+})(CalendarEventVisibility || (CalendarEventVisibility = {}));

package/dist/FormSteps/AvailabilityStep/AvailabilityStep.d.ts

@@ -0,0 +1,7 @@
+import { AvailabilityStep } from '../../@Types/CalendarFormStep';
+import { StepProps } from '../Step';
+export interface AvailabilityStepProps extends StepProps {
+    step: AvailabilityStep;
+}
+declare function AvailabilityStepComponent(props: AvailabilityStepProps): JSX.Element;
+export default AvailabilityStepComponent;

package/dist/FormSteps/{CalendarStep/CalendarStep.js → AvailabilityStep/AvailabilityStep.js}

@@ -1,14 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { FormStyleTypes } from '../../constants/FormStepTypes';
-import MaterialCalendarStep from './MaterialCalendarStep/MaterialCalendarStep';
+import MaterialAvailabilityStep from './MaterialAvailabilityStep/MaterialAvailabilityStep';
 import { useAppSelector } from '../../hooks';
-function CalendarStepComponent(props) {
+function AvailabilityStepComponent(props) {
     const { formStyle } = useAppSelector((state) => state.global);
     switch (formStyle.type) {
         case FormStyleTypes.MATERIAL:
         default: {
-            return _jsx(MaterialCalendarStep, { ...props });
+            return _jsx(MaterialAvailabilityStep, { ...props });
         }
     }
 }
-export default CalendarStepComponent;
+export default AvailabilityStepComponent;

package/dist/FormSteps/AvailabilityStep/MaterialAvailabilityStep/MaterialAvailabilityStep.d.ts

@@ -0,0 +1,8 @@
+import { AvailabilityStepProps } from '../AvailabilityStep';
+/**
+ * Conector del paso AVAILABILITY: pregunta de disponibilidad compacta
+ * (grid semanal día × hora). El calendario completo vive en el admin; el form
+ * solo captura ventanas disponibles que un paso BOOKING puede consumir.
+ */
+declare function MaterialAvailabilityStep({ step, editable }: AvailabilityStepProps): JSX.Element;
+export default MaterialAvailabilityStep;

package/dist/FormSteps/{CalendarStep/MaterialCalendarStep/MaterialCalendarStep.js → AvailabilityStep/MaterialAvailabilityStep/MaterialAvailabilityStep.js}

@@ -4,12 +4,13 @@ import { useFormStep } from '../../StepHooks';
 import FormContext from '../../../Contexts/FormContext';
 import { selectBreakPoint, useAppSelector } from '../../../hooks';
 import { calcStepWidth } from '../../StepFunctions';
-import ErkCalendar from '../../../Shared/ErkCalendar/ErkCalendar';
+import ErkAvailabilityPicker from '../../../Shared/ErkAvailabilityPicker/ErkAvailabilityPicker';
 /**
- * Conector del paso CALENDAR: enlaza el estado del formulario (`useFormStep`) y el
- * theming del form con el componente reutilizable `ErkCalendar` (en Shared).
+ * Conector del paso AVAILABILITY: pregunta de disponibilidad compacta
+ * (grid semanal día × hora). El calendario completo vive en el admin; el form
+ * solo captura ventanas disponibles que un paso BOOKING puede consumir.
  */
-function MaterialCalendarStep({ step, editable }) {
+function MaterialAvailabilityStep({ step, editable }) {
     const currentBreakPoint = useAppSelector(selectBreakPoint);
     const { postview, formStyle } = useAppSelector((state) => state.global);
     const formCtx = useContext(FormContext);
@@ -24,8 +25,8 @@ function MaterialCalendarStep({ step, editable }) {
     };
     const { ref, value, onChange, error } = useFormStep(step, {
         defaultValue: null,
-        rules: { required: step.required ? 'Este campo es obligatorio' : undefined },
+        rules: { required: step.required ? 'Marca tu disponibilidad' : undefined },
     });
-    return (_jsx("div", { ref: ref, style: cssVars, children: _jsx(ErkCalendar, { value: value, onChange: onChange, defaultView: step.defaultView, enabledViews: step.enabledViews, allowedCategories: step.allowedCategories, eventTemplates: step.eventTemplates, showWeekends: step.showWeekends, minTime: step.minTime, maxTime: step.maxTime, allowRecurring: step.allowRecurring, timezone: step.timezone, readOnly: isReadOnly, error: error?.message }) }));
+    return (_jsx("div", { ref: ref, style: cssVars, children: _jsx(ErkAvailabilityPicker, { value: value, onChange: onChange, label: step.label, description: step.description, minTime: step.minTime, maxTime: step.maxTime, showWeekends: step.showWeekends, timezone: step.timezone, readOnly: isReadOnly, error: error?.message }) }));
 }
-export default MaterialCalendarStep;
+export default MaterialAvailabilityStep;

package/dist/FormSteps/Step.js

@@ -27,7 +27,7 @@ import PhoneInputStep from './PhoneInputStep/PhoneInputStep';
 import LocationStepComponent from './LocationStep/LocationStep';
 import NumberStepComponent from './NumberStep/NumberStep';
 import BookingStepComponent from './BookingStep/BookingStep';
-import CalendarStepComponent from './CalendarStep/CalendarStep';
+import AvailabilityStepComponent from './AvailabilityStep/AvailabilityStep';
 function StepComponent({ step, ...props }) {
     const { postview, partial } = useAppSelector((state) => state.global);
     const { customSteps, customClientInfoStep } = useContext(CustomContext);
@@ -87,8 +87,8 @@ function StepComponent({ step, ...props }) {
         case FormStepTypes.BOOKING: {
             return _jsx(BookingStepComponent, { ...props, step: step, editable: editable });
         }
-        case FormStepTypes.CALENDAR: {
-            return _jsx(CalendarStepComponent, { ...props, step: step, editable: editable });
+        case FormStepTypes.AVAILABILITY: {
+            return _jsx(AvailabilityStepComponent, { ...props, step: step, editable: editable });
         }
         case FormStepTypes.DATEPICKER_RANGE: {
             return _jsx(DatePickerRangeStep, { ...props, step: step, editable: editable });

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;

package/dist/Shared/ErkAvailabilityPicker/ErkAvailabilityPicker.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { addDays, format, startOfWeek } from 'date-fns';
+import { CalendarEventCategory, } from '../../@Types/CalendarFormStep';
+import styles from './ErkAvailabilityPicker.module.css';
+const DOW_LABELS = ['L', 'M', 'M', 'J', 'V', 'S', 'D'];
+const DOW_NAMES = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo'];
+function parseHour(hhmm) {
+    return Number(hhmm.split(':')[0]) || 0;
+}
+/** Ancla del día `dayIdx` (0=Lun … 6=Dom) en la semana actual. */
+function anchorDate(dayIdx) {
+    return addDays(startOfWeek(new Date(), { weekStartsOn: 1 }), dayIdx);
+}
+function cellISO(dayIdx, hour) {
+    const day = anchorDate(dayIdx);
+    return `${format(day, 'yyyy-MM-dd')}T${String(hour).padStart(2, '0')}:00:00`;
+}
+/** `Date.getDay()` → índice de columna (0=Lun … 6=Dom). */
+function dayToIdx(day) {
+    return (day + 6) % 7;
+}
+const RRULE_DAY_CODES = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+/**
+ * Expande el value a celdas marcadas. Soporta las ventanas que el propio picker
+ * genera (semanales por día) y BYDAY (ej: L–V) por si el valor viene de otra fuente.
+ */
+function valueToCells(value) {
+    const cells = new Set();
+    for (const event of value?.events ?? []) {
+        const startHour = parseHour(event.start.slice(11, 16));
+        const endHour = parseHour(event.end.slice(11, 16)) || 24;
+        const byday = /BYDAY=([A-Z,]+)/.exec(event.recurrence ?? '');
+        const dayIdxs = byday
+            ? byday[1]
+                .split(',')
+                .map((code) => RRULE_DAY_CODES.indexOf(code))
+                .filter((d) => d >= 0)
+                .map(dayToIdx)
+            : [dayToIdx(new Date(`${event.start.slice(0, 10)}T00:00:00`).getDay())];
+        for (const dayIdx of dayIdxs) {
+            for (let h = startHour; h < endHour; h++)
+                cells.add(`${dayIdx}:${h}`);
+        }
+    }
+    return cells;
+}
+/** Convierte las celdas marcadas en ventanas semanales contiguas por día. */
+function cellsToEvents(cells, hours) {
+    const events = [];
+    for (let dayIdx = 0; dayIdx < 7; dayIdx++) {
+        let windowStart = null;
+        for (const h of hours) {
+            const marked = cells.has(`${dayIdx}:${h}`);
+            if (marked && windowStart === null)
+                windowStart = h;
+            if (!marked && windowStart !== null) {
+                events.push(windowEvent(dayIdx, windowStart, h));
+                windowStart = null;
+            }
+        }
+        if (windowStart !== null) {
+            events.push(windowEvent(dayIdx, windowStart, hours[hours.length - 1] + 1));
+        }
+    }
+    return events;
+}
+function windowEvent(dayIdx, startHour, endHour) {
+    return {
+        id: `avail-${dayIdx}-${startHour}-${endHour}`,
+        category: CalendarEventCategory.WORKING,
+        start: cellISO(dayIdx, startHour),
+        end: cellISO(dayIdx, endHour),
+        recurrence: 'FREQ=WEEKLY',
+    };
+}
+/**
+ * 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.
+ */
+function ErkAvailabilityPicker({ value, onChange, label, description, minTime = '07:00', maxTime = '19:00', showWeekends = true, timezone, readOnly = false, error, }) {
+    const minHour = parseHour(minTime);
+    const maxHour = parseHour(maxTime);
+    const hours = useMemo(() => Array.from({ length: Math.max(maxHour - minHour, 1) }, (_, i) => minHour + i), [minHour, maxHour]);
+    const dayIdxs = showWeekends ? [0, 1, 2, 3, 4, 5, 6] : [0, 1, 2, 3, 4];
+    const cells = useMemo(() => valueToCells(value), [value]);
+    const toggle = (dayIdx, hour) => {
+        if (readOnly)
+            return;
+        const next = new Set(cells);
+        const key = `${dayIdx}:${hour}`;
+        if (next.has(key))
+            next.delete(key);
+        else
+            next.add(key);
+        onChange({
+            type: 'CALENDAR_VALUE',
+            events: cellsToEvents(next, hours),
+            timezone: value?.timezone ?? timezone,
+        });
+    };
+    const markedCount = cells.size;
+    return (_jsxs("div", { className: styles.container, children: [_jsx("span", { className: styles.label, children: label }), description && _jsx("p", { className: styles.description, children: description }), _jsxs("div", { className: styles.card, children: [_jsxs("div", { className: styles.grid, style: { gridTemplateColumns: `44px repeat(${dayIdxs.length}, 1fr)` }, children: [_jsx("span", { className: styles.corner }), dayIdxs.map((d) => (_jsx("span", { className: styles.dow, children: DOW_LABELS[d] }, d))), hours.map((h) => (_jsxs("div", { className: styles.row, children: [_jsxs("span", { className: styles.hour, children: [h, ":00"] }), dayIdxs.map((d) => {
+                                        const on = cells.has(`${d}:${h}`);
+                                        return (_jsx("button", { type: "button", disabled: readOnly, "aria-pressed": on, "aria-label": `${DOW_NAMES[d]} ${h}:00`, className: on ? `${styles.cell} ${styles.cellOn}` : styles.cell, onClick: () => toggle(d, h) }, d));
+                                    })] }, h)))] }), _jsx("div", { className: styles.footer, children: markedCount > 0
+                            ? 'Disponible cada semana en las horas marcadas.'
+                            : 'Marca las horas en las que estás disponible cada semana.' })] }), error && _jsx("div", { className: styles.err, children: error })] }));
+}
+export default ErkAvailabilityPicker;

package/dist/Shared/ErkAvailabilityPicker/ErkAvailabilityPicker.module.css

@@ -0,0 +1,88 @@
+.container {
+    max-width: 100%;
+    box-sizing: border-box;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+}
+.label {
+    font-size: 14.5px;
+    font-weight: 700;
+    color: var(--eureka-text, #293241);
+}
+.description {
+    margin: 0 0 4px;
+    font-size: 12.5px;
+    color: #787878;
+}
+
+.card {
+    border: 1px solid var(--eureka-outline, #d9dee6);
+    border-radius: 12px;
+    overflow: hidden;
+    background: var(--eureka-bg, #fff);
+    max-width: 460px;
+}
+.grid {
+    display: grid;
+    padding: 10px 12px 4px;
+    gap: 2px;
+    font-variant-numeric: tabular-nums;
+}
+.corner {
+    grid-column: 1;
+}
+.dow {
+    text-align: center;
+    font-size: 10.5px;
+    font-weight: 700;
+    color: #787878;
+    text-transform: uppercase;
+    padding-bottom: 2px;
+}
+.row {
+    display: contents;
+}
+.hour {
+    font-size: 10.5px;
+    color: #787878;
+    text-align: right;
+    padding-right: 6px;
+    align-self: center;
+}
+.cell {
+    height: 26px;
+    border: 1px solid var(--eureka-outline, #eceff3);
+    border-radius: 6px;
+    background: #fbfcfd;
+    cursor: pointer;
+    padding: 0;
+}
+.cell:hover {
+    border-color: var(--eureka-primary, #3d5a7f);
+}
+.cell:disabled {
+    cursor: default;
+}
+.cellOn {
+    background: repeating-linear-gradient(
+        -45deg,
+        color-mix(in srgb, var(--eureka-primary, #3d5a7f) 30%, #fff),
+        color-mix(in srgb, var(--eureka-primary, #3d5a7f) 30%, #fff) 5px,
+        color-mix(in srgb, var(--eureka-primary, #3d5a7f) 18%, #fff) 5px,
+        color-mix(in srgb, var(--eureka-primary, #3d5a7f) 18%, #fff) 10px
+    );
+    border-color: var(--eureka-primary, #3d5a7f);
+}
+.footer {
+    padding: 8px 12px 10px;
+    font-size: 11.5px;
+    color: #787878;
+    border-top: 1px solid var(--eureka-outline, #eceff3);
+    background: color-mix(in srgb, var(--eureka-primary, #3d5a7f) 2%, #fff);
+}
+.err {
+    font-size: 12px;
+    color: #d0473f;
+    margin-top: 2px;
+}

package/dist/Shared/ErkAvailabilityPicker/ErkAvailabilityPicker.test.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import '@testing-library/jest-dom';
+import { addDays, format, startOfWeek } from 'date-fns';
+import ErkAvailabilityPicker from './ErkAvailabilityPicker';
+import MaterialProviders from '../../Utils/MaterialProviders';
+import InternalFormStyle from '../../constants/InternalFormStyle';
+import { CalendarEventCategory } from '../../@Types/CalendarFormStep';
+function iso(dayIdx, hhmm) {
+    const day = addDays(startOfWeek(new Date(), { weekStartsOn: 1 }), dayIdx);
+    return `${format(day, 'yyyy-MM-dd')}T${hhmm}:00`;
+}
+describe('ErkAvailabilityPicker', () => {
+    it('marks a cell and emits a weekly WORKING window', async () => {
+        const user = userEvent.setup();
+        const onChange = vi.fn();
+        render(_jsx(MaterialProviders, { formStyle: InternalFormStyle, children: _jsx(ErkAvailabilityPicker, { value: null, onChange: onChange, label: "Disponibilidad", minTime: "08:00", maxTime: "12:00" }) }));
+        await user.click(screen.getByRole('button', { name: 'Lunes 9:00' }));
+        expect(onChange).toHaveBeenCalledWith({
+            type: 'CALENDAR_VALUE',
+            events: [
+                expect.objectContaining({
+                    category: CalendarEventCategory.WORKING,
+                    start: iso(0, '09:00'),
+                    end: iso(0, '10:00'),
+                    recurrence: 'FREQ=WEEKLY',
+                }),
+            ],
+            timezone: undefined,
+        });
+    });
+    it('merges contiguous marked hours into a single window', async () => {
+        const user = userEvent.setup();
+        const onChange = vi.fn();
+        const value = {
+            type: 'CALENDAR_VALUE',
+            events: [
+                {
+                    id: 'avail-0-9-10',
+                    category: CalendarEventCategory.WORKING,
+                    start: iso(0, '09:00'),
+                    end: iso(0, '10:00'),
+                    recurrence: 'FREQ=WEEKLY',
+                },
+            ],
+        };
+        render(_jsx(MaterialProviders, { formStyle: InternalFormStyle, children: _jsx(ErkAvailabilityPicker, { value: value, onChange: onChange, label: "Disponibilidad", minTime: "08:00", maxTime: "12:00" }) }));
+        await user.click(screen.getByRole('button', { name: 'Lunes 10:00' }));
+        expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+            events: [
+                expect.objectContaining({ start: iso(0, '09:00'), end: iso(0, '11:00') }),
+            ],
+        }));
+    });
+    it('renders existing windows as pressed cells and blocks toggling when readOnly', () => {
+        const value = {
+            type: 'CALENDAR_VALUE',
+            events: [
+                {
+                    id: 'avail-2-14-16',
+                    category: CalendarEventCategory.WORKING,
+                    start: iso(2, '14:00'),
+                    end: iso(2, '16:00'),
+                    recurrence: 'FREQ=WEEKLY',
+                },
+            ],
+        };
+        render(_jsx(MaterialProviders, { formStyle: InternalFormStyle, children: _jsx(ErkAvailabilityPicker, { value: value, onChange: () => { }, label: "Disponibilidad", minTime: "13:00", maxTime: "17:00", readOnly: true }) }));
+        expect(screen.getByRole('button', { name: 'Miércoles 14:00', pressed: true })).toBeDisabled();
+        expect(screen.getByRole('button', { name: 'Miércoles 15:00', pressed: true })).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Miércoles 16:00', pressed: false })).toBeInTheDocument();
+    });
+});

package/dist/constants/FormStepTypes.d.ts

@@ -24,7 +24,7 @@ export declare enum FormStepTypes {
     API_SELECTOR = "API_SELECTOR",
     LOCATION = "LOCATION",
     NUMBER = "NUMBER",
-    CALENDAR = "CALENDAR",
+    AVAILABILITY = "AVAILABILITY",
     BOOKING = "BOOKING"
 }
 export declare enum OptionTypes {

package/dist/constants/FormStepTypes.js

@@ -27,7 +27,7 @@ export var FormStepTypes;
     FormStepTypes["API_SELECTOR"] = "API_SELECTOR";
     FormStepTypes["LOCATION"] = "LOCATION";
     FormStepTypes["NUMBER"] = "NUMBER";
-    FormStepTypes["CALENDAR"] = "CALENDAR";
+    FormStepTypes["AVAILABILITY"] = "AVAILABILITY";
     FormStepTypes["BOOKING"] = "BOOKING";
 })(FormStepTypes || (FormStepTypes = {}));
 export var OptionTypes;

package/dist/index.lib.d.ts

@@ -1,8 +1,8 @@
 import EurekaForm, { AppProps as EurekaFormProps } from './App/App';
 import { StepProps } from './FormSteps/Step';
 import * as StepFunctions from './FormSteps/StepFunctions';
-import ErkCalendar, { BusinessDaysConfig, ErkCalendarProps } from './Shared/ErkCalendar/ErkCalendar';
 import ErkBookingPicker, { ErkBookingPickerProps } from './Shared/ErkBookingPicker/ErkBookingPicker';
-export type { StepProps, EurekaFormProps, ErkCalendarProps, BusinessDaysConfig, ErkBookingPickerProps };
-export { EurekaForm, StepFunctions, ErkCalendar, ErkBookingPicker };
+import ErkAvailabilityPicker, { ErkAvailabilityPickerProps } from './Shared/ErkAvailabilityPicker/ErkAvailabilityPicker';
+export type { StepProps, EurekaFormProps, ErkBookingPickerProps, ErkAvailabilityPickerProps };
+export { EurekaForm, StepFunctions, ErkBookingPicker, ErkAvailabilityPicker };
 export default EurekaForm;

package/dist/index.lib.js

@@ -1,6 +1,6 @@
 import EurekaForm from './App/App';
 import * as StepFunctions from './FormSteps/StepFunctions';
-import ErkCalendar from './Shared/ErkCalendar/ErkCalendar';
 import ErkBookingPicker from './Shared/ErkBookingPicker/ErkBookingPicker';
-export { EurekaForm, StepFunctions, ErkCalendar, ErkBookingPicker };
+import ErkAvailabilityPicker from './Shared/ErkAvailabilityPicker/ErkAvailabilityPicker';
+export { EurekaForm, StepFunctions, ErkBookingPicker, ErkAvailabilityPicker };
 export default EurekaForm;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arquimedes.co/eureka-forms",
   "repository": "git://github.com/Arquimede5/Eureka-Forms.git",
-  "version":"3.0.54-new-steps",
+  "version":"3.0.56-new-steps",
   "scripts": {
     "watch": "tsgo --noEmit --watch --project tsconfig.app.json",
     "start": "vite",

package/dist/FormSteps/CalendarStep/CalendarStep.d.ts

@@ -1,7 +0,0 @@
-import { CalendarStep } from '../../@Types/CalendarFormStep';
-import { StepProps } from '../Step';
-export interface CalendarStepProps extends StepProps {
-    step: CalendarStep;
-}
-declare function CalendarStepComponent(props: CalendarStepProps): JSX.Element;
-export default CalendarStepComponent;

package/dist/FormSteps/CalendarStep/MaterialCalendarStep/MaterialCalendarStep.d.ts

@@ -1,7 +0,0 @@
-import { CalendarStepProps } from '../CalendarStep';
-/**
- * Conector del paso CALENDAR: enlaza el estado del formulario (`useFormStep`) y el
- * theming del form con el componente reutilizable `ErkCalendar` (en Shared).
- */
-declare function MaterialCalendarStep({ step, editable }: CalendarStepProps): JSX.Element;
-export default MaterialCalendarStep;

package/dist/Shared/ErkCalendar/CalendarFunctions.d.ts

@@ -1,28 +0,0 @@
-import { CalendarEvent, CalendarEventCategory, CalendarEventTemplate } from '../../@Types/CalendarFormStep';
-/** Color base por categoría (paleta del app; navy = primario, coral = acento). */
-export declare const CATEGORY_COLORS: Record<CalendarEventCategory, string>;
-export declare const CATEGORY_LABELS: Record<CalendarEventCategory, string>;
-export declare function isAvailability(category: CalendarEventCategory): boolean;
-export declare function parseTime(hhmm: string): {
-    h: number;
-    m: number;
-};
-export declare function toMinutes(hhmm: string): number;
-export declare function minutesToHHMM(mins: number): string;
-/** "2026-07-14T09:30:00" → "09:30" */
-export declare function isoToHHMM(iso: string): string;
-/** Compone el ISO en hora local (sin corrimiento de zona horaria). */
-export declare function dateAndTimeToISO(date: Date, hhmm: string): string;
-/** Interpreta el ISO como hora local (sin corrimiento de zona horaria). */
-export declare function isoToDate(iso: string): Date;
-export declare function newEventId(): string;
-/**
- * Si el evento ocurre en `day`, considerando su recurrencia RRULE (RFC 5545 —
- * el mismo estándar de Google/Outlook/iCal). Soporta:
- * - `FREQ=DAILY` (+ INTERVAL)
- * - `FREQ=WEEKLY` (+ INTERVAL, BYDAY — ej: `BYDAY=MO,TU,WE,TH,FR` = días hábiles)
- * - `FREQ=MONTHLY` (+ INTERVAL, mismo día del mes que el inicio)
- */
-export declare function occursOnDay(event: CalendarEvent, day: Date): boolean;
-export declare function eventColor(event: CalendarEvent, templates?: CalendarEventTemplate[]): string;
-export declare function eventLabel(event: CalendarEvent, templates?: CalendarEventTemplate[]): string;