@arquimedes.co/eureka-forms 3.0.62 → 3.0.64-entity-step-filter

package/dist/FormSteps/StepFunctions.test.js

@@ -1,3 +1,4 @@
+import * as Steps from '../@Types/FormStep';
 import AYFFormStepTypes from '../constants/AYFFormStepTypes';
 import CBRFormStepTypes from '../constants/CBRFormStepTypes';
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, OptionTypes, } from '../constants/FormStepTypes';
@@ -527,6 +528,13 @@ describe('StepFunctions', function () {
             const defaultValue = calcDefaultValue(step);
             expect(defaultValue).toBe(null);
         });
+        test('Location step type', async () => {
+            const step = {
+                type: FormStepTypes.LOCATION,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBe(null);
+        });
         test('Mapper, FileUpload, CBRFormStep types', async () => {
             const step1 = {
                 type: FormStepTypes.MAPPER,
@@ -558,6 +566,52 @@ describe('StepFunctions', function () {
             const defaultValue = calcDefaultValue(step);
             expect(defaultValue).toBeUndefined();
         });
+        test('Number step type without defaultValue', async () => {
+            const step1 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.INTEGER,
+            };
+            const step2 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.DECIMAL,
+            };
+            const step3 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.PERCENTAGE,
+            };
+            const step4 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.MONEY,
+            };
+            const step5 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.MEASURE,
+            };
+            const step6 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.UNIT_PRICE,
+            };
+            expect(calcDefaultValue(step1)).toBe('');
+            expect(calcDefaultValue(step2)).toBe('');
+            expect(calcDefaultValue(step3)).toBe('');
+            expect(calcDefaultValue(step4)).toBe(null);
+            expect(calcDefaultValue(step5)).toBe(null);
+            expect(calcDefaultValue(step6)).toBe(null);
+        });
+        test('Number step type with defaultValue', async () => {
+            const step1 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.INTEGER,
+                defaultValue: 42,
+            };
+            const step2 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.MONEY,
+                defaultValue: { value: 100, currency: 'USD' },
+            };
+            expect(calcDefaultValue(step1)).toBe(42);
+            expect(calcDefaultValue(step2)).toEqual({ value: 100, currency: 'USD' });
+        });
     });
     describe('iterateNestedSteps', function () {
         test('should iterate over nested steps', async () => {

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import { LocationStepValue } from '../../@Types/LocationFormStep';
+export interface ErkAddressAutocompleteProps {
+    value?: LocationStepValue | null;
+    onChange: (value: LocationStepValue) => void;
+    /** ISO-2 para acotar las sugerencias (ej. ['co']). */
+    regionCodes?: string[];
+    placeholder?: string;
+    error?: boolean;
+    required?: boolean;
+    readOnly?: boolean;
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+/**
+ * Buscador de direcciones con el `Autocomplete` de Base UI + Google Places.
+ * Emite un `LocationStepValue` (source GOOGLE_PLACES) con el desglose estructurado.
+ */
+declare function ErkAddressAutocomplete({ value, onChange, regionCodes, placeholder, error, required, readOnly, inputRef, }: ErkAddressAutocompleteProps): JSX.Element;
+export default ErkAddressAutocomplete;

package/dist/Shared/ErkAddressAutocomplete/ErkAddressAutocomplete.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Autocomplete } from '@base-ui/react/autocomplete';
+import { fetchAddressSuggestions, loadPlaces, newSessionToken, resolvePrediction, } from './googlePlaces';
+import styles from './ErkAddressAutocomplete.module.css';
+/**
+ * Buscador de direcciones con el `Autocomplete` de Base UI + Google Places.
+ * Emite un `LocationStepValue` (source GOOGLE_PLACES) con el desglose estructurado.
+ */
+function ErkAddressAutocomplete({ value, onChange, regionCodes = ['co'], placeholder = 'Buscar dirección…', error = false, required = false, readOnly = false, inputRef, }) {
+    const apiKey = import.meta.env.VITE_GOOGLE_MAPS_API_KEY ?? '';
+    const [ready, setReady] = useState(false);
+    const [inputValue, setInputValue] = useState(value?.address ?? value?.name ?? '');
+    const [options, setOptions] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [hasSearched, setHasSearched] = useState(false);
+    const debounceRef = useRef(undefined);
+    const sessionTokenRef = useRef(undefined);
+    useEffect(() => {
+        if (readOnly)
+            return;
+        let active = true;
+        void loadPlaces(apiKey)
+            .then(() => {
+            if (!active)
+                return;
+            sessionTokenRef.current = newSessionToken();
+            setReady(true);
+        })
+            .catch(() => {
+            if (active)
+                setReady(false);
+        });
+        return () => {
+            active = false;
+        };
+    }, [apiKey, readOnly]);
+    const handleInput = useCallback((text) => {
+        setInputValue(text);
+        if (debounceRef.current)
+            clearTimeout(debounceRef.current);
+        if (!ready || !text || text.length < 3) {
+            setOptions([]);
+            setHasSearched(false);
+            return;
+        }
+        setLoading(true);
+        debounceRef.current = setTimeout(() => {
+            void (async () => {
+                try {
+                    setOptions(await fetchAddressSuggestions(text, {
+                        sessionToken: sessionTokenRef.current,
+                        regionCodes,
+                    }));
+                }
+                catch {
+                    setOptions([]);
+                }
+                finally {
+                    setLoading(false);
+                    setHasSearched(true);
+                }
+            })();
+        }, 300);
+    }, [ready, regionCodes]);
+    const handleSelect = useCallback(async (prediction) => {
+        try {
+            const stepValue = await resolvePrediction(prediction);
+            setInputValue(stepValue.address ?? stepValue.name ?? prediction.label);
+            setOptions([]);
+            onChange(stepValue);
+        }
+        finally {
+            // Cada selección cierra la sesión de billing de Google.
+            sessionTokenRef.current = newSessionToken();
+        }
+    }, [onChange]);
+    return (_jsxs(Autocomplete.Root, { items: options, mode: "none", value: inputValue, onValueChange: handleInput, disabled: readOnly, children: [_jsx(Autocomplete.Input, { ref: inputRef, placeholder: placeholder, required: required, readOnly: readOnly, className: error ? `${styles.input} ${styles.inputError}` : styles.input }), _jsx(Autocomplete.Portal, { children: _jsx(Autocomplete.Positioner, { className: styles.positioner, sideOffset: 4, children: _jsxs(Autocomplete.Popup, { className: styles.popup, children: [loading && _jsx("div", { className: styles.status, children: "Buscando\u2026" }), _jsx(Autocomplete.Empty, { className: styles.status, children: hasSearched ? 'No se encontraron resultados' : 'Escribe para buscar…' }), _jsx(Autocomplete.List, { className: styles.list, children: (option) => (_jsxs(Autocomplete.Item, { value: option, className: styles.item, onClick: () => void handleSelect(option), children: [_jsx("span", { className: styles.optionLabel, children: option.label }), option.description && (_jsx("span", { className: styles.optionDescription, children: option.description }))] }, option.placeId)) })] }) }) })] }));
+}
+export default ErkAddressAutocomplete;

package/dist/Shared/ErkAddressAutocomplete/ErkAddressAutocomplete.module.css

@@ -0,0 +1,88 @@
+.input {
+    width: 100%;
+    box-sizing: border-box;
+    height: 31px;
+    padding: 6px 12px;
+    font-size: 1rem;
+    font-family: inherit;
+    color: var(--eureka-text, #293241);
+    background-color: var(--eureka-bg, #fff);
+    border: 1px solid var(--eureka-outline, #b8b8b8);
+    border-radius: 10px;
+    outline: none;
+}
+
+.input::placeholder {
+    color: var(--eureka-text, #293241);
+    opacity: 0.5;
+}
+
+.input:hover:not(:disabled):not(:read-only) {
+    border-color: var(--eureka-primary, #3d5a7f);
+}
+
+.input:focus:not(:read-only) {
+    border-color: var(--eureka-primary, #3d5a7f);
+    border-width: 2px;
+    padding: 5px 11px;
+}
+
+.input:disabled {
+    opacity: 0.5;
+}
+
+.inputError {
+    border-color: var(--eureka-error, #e53935);
+}
+
+.positioner {
+    z-index: 1400;
+    width: var(--anchor-width);
+}
+
+.popup {
+    box-sizing: border-box;
+    max-height: 320px;
+    overflow-y: auto;
+    padding: 4px;
+    background-color: var(--eureka-bg, #fff);
+    border: 1px solid var(--eureka-outline, #b8b8b8);
+    border-radius: 10px;
+    box-shadow: 0 4px 16px rgb(0 0 0 / 12%);
+}
+
+.list {
+    display: flex;
+    flex-direction: column;
+}
+
+.status {
+    padding: 10px 12px;
+    font-size: 0.875rem;
+    color: var(--eureka-text, #666);
+    opacity: 0.7;
+}
+
+.item {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    padding: 8px 12px;
+    border-radius: 8px;
+    cursor: pointer;
+}
+
+.item[data-highlighted],
+.item:hover {
+    background-color: var(--eureka-primary, #3d5a7f);
+    color: #fff;
+}
+
+.optionLabel {
+    font-size: 0.9375rem;
+}
+
+.optionDescription {
+    font-size: 0.8125rem;
+    opacity: 0.7;
+}

package/dist/Shared/ErkAddressAutocomplete/googlePlaces.d.ts

@@ -0,0 +1,29 @@
+import { LocationAddressDetail, LocationStepValue } from '../../@Types/LocationFormStep';
+/** Asegura el script cargado y las clases de Places listas. Idempotente. */
+export declare function loadPlaces(apiKey: string): Promise<void>;
+/** Token de sesión nuevo (mejora el billing/relevancia de Google). */
+export declare function newSessionToken(): any;
+/** Reverse-geocoding para el modo GPS: coordenadas → dirección estructurada. */
+export declare function reverseGeocode(apiKey: string, lat: number, lng: number): Promise<{
+    address?: string;
+    addressDetail: LocationAddressDetail;
+}>;
+export interface AddressPrediction {
+    placeId: string;
+    label: string;
+    description: string;
+    toPlace: () => any;
+}
+export interface FetchSuggestionsOptions {
+    sessionToken?: any;
+    /** ISO-2, ej. ['co'] */
+    regionCodes?: string[];
+}
+export declare function fetchAddressSuggestions(input: string, options?: FetchSuggestionsOptions): Promise<AddressPrediction[]>;
+/**
+ * Descompone los `addressComponents` de un Place en el shape estructurado del step.
+ * Acepta el formato nuevo (`longText`/`shortText`) y el legacy (`long_name`/`short_name`).
+ */
+export declare function parseAddressComponents(components: any[] | null | undefined): LocationAddressDetail;
+/** Resuelve una predicción a un `LocationStepValue` completo (fetchFields + parse). */
+export declare function resolvePrediction(prediction: AddressPrediction): Promise<LocationStepValue>;

package/dist/Shared/ErkAddressAutocomplete/googlePlaces.js

@@ -0,0 +1,139 @@
+import { LocationInputMode } from '../../@Types/LocationFormStep';
+/**
+ * Carga y consulta de Google Places (nueva API `AutocompleteSuggestion`).
+ * Encapsula el script loader + importLibrary que antes vivía inline en ErkLocationInput,
+ * para reutilizarlo desde el autocomplete de Base UI sin duplicar lógica.
+ */
+// Google's new Places classes (AutocompleteSuggestion/SessionToken) are untyped in the
+// installed @types/google.maps, so they're kept as `any` — same approach as ErkLocationInput.
+let loadPromise = null;
+let suggestionClass = null;
+let sessionTokenClass = null;
+let geocoderClass = null;
+function loadScript(apiKey) {
+    if (typeof window === 'undefined')
+        return Promise.resolve();
+    const win = window;
+    if (win.google?.maps?.importLibrary)
+        return Promise.resolve();
+    if (loadPromise)
+        return loadPromise;
+    loadPromise = new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        script.src = `https://maps.googleapis.com/maps/api/js?key=${apiKey}&loading=async`;
+        script.async = true;
+        script.defer = true;
+        script.onload = () => resolve();
+        script.onerror = () => {
+            loadPromise = null;
+            reject(new Error('Google Maps script failed to load.'));
+        };
+        document.head.appendChild(script);
+    });
+    return loadPromise;
+}
+/** Asegura el script cargado y las clases de Places listas. Idempotente. */
+export async function loadPlaces(apiKey) {
+    await loadScript(apiKey);
+    const win = window;
+    if (win.google?.maps?.importLibrary && !suggestionClass) {
+        const places = await win.google.maps.importLibrary('places');
+        suggestionClass = places.AutocompleteSuggestion;
+        sessionTokenClass = places.AutocompleteSessionToken;
+    }
+}
+/** Token de sesión nuevo (mejora el billing/relevancia de Google). */
+export function newSessionToken() {
+    return sessionTokenClass ? new sessionTokenClass() : undefined;
+}
+/** Reverse-geocoding para el modo GPS: coordenadas → dirección estructurada. */
+export async function reverseGeocode(apiKey, lat, lng) {
+    await loadScript(apiKey);
+    const win = window;
+    if (win.google?.maps?.importLibrary && !geocoderClass) {
+        const geocoding = await win.google.maps.importLibrary('geocoding');
+        geocoderClass = geocoding.Geocoder;
+    }
+    else if (!geocoderClass && win.google?.maps?.Geocoder) {
+        geocoderClass = win.google.maps.Geocoder;
+    }
+    if (!geocoderClass)
+        return { addressDetail: {} };
+    const geocoder = new geocoderClass();
+    return new Promise((resolve) => {
+        geocoder.geocode({ location: { lat, lng } }, (results, status) => {
+            if (status === 'OK' && results?.[0]) {
+                resolve({
+                    address: results[0].formatted_address,
+                    addressDetail: parseAddressComponents(results[0].address_components),
+                });
+            }
+            else {
+                resolve({ addressDetail: {} });
+            }
+        });
+    });
+}
+export async function fetchAddressSuggestions(input, options) {
+    if (!suggestionClass)
+        return [];
+    const request = { input };
+    if (options?.sessionToken)
+        request.sessionToken = options.sessionToken;
+    if (options?.regionCodes)
+        request.includedRegionCodes = options.regionCodes;
+    const { suggestions } = await suggestionClass.fetchAutocompleteSuggestions(request);
+    return suggestions
+        .filter((s) => s.placePrediction)
+        .map((s) => ({
+        placeId: s.placePrediction.placeId,
+        label: s.placePrediction.mainText?.text ?? s.placePrediction.text.text,
+        description: s.placePrediction.secondaryText?.text ?? s.placePrediction.text.text,
+        toPlace: () => s.placePrediction.toPlace(),
+    }));
+}
+/**
+ * Descompone los `addressComponents` de un Place en el shape estructurado del step.
+ * Acepta el formato nuevo (`longText`/`shortText`) y el legacy (`long_name`/`short_name`).
+ */
+export function parseAddressComponents(components) {
+    const detail = {};
+    for (const component of components ?? []) {
+        const types = component.types;
+        const longName = component.longText ?? component.long_name;
+        const shortName = component.shortText ?? component.short_name;
+        if (types.includes('route'))
+            detail.street = longName;
+        else if (types.includes('street_number'))
+            detail.streetNumber = longName;
+        else if (types.includes('subpremise'))
+            detail.unit = longName;
+        else if (types.includes('neighborhood') || types.includes('sublocality'))
+            detail.neighborhood = longName;
+        else if (types.includes('locality'))
+            detail.city = longName;
+        else if (types.includes('administrative_area_level_1'))
+            detail.state = longName;
+        else if (types.includes('country')) {
+            detail.country = longName;
+            detail.countryCode = shortName;
+        }
+        else if (types.includes('postal_code'))
+            detail.postalCode = longName;
+    }
+    return detail;
+}
+/** Resuelve una predicción a un `LocationStepValue` completo (fetchFields + parse). */
+export async function resolvePrediction(prediction) {
+    const place = prediction.toPlace();
+    await place.fetchFields({ fields: ['displayName', 'formattedAddress', 'location', 'addressComponents'] });
+    return {
+        source: LocationInputMode.GOOGLE_PLACES,
+        latitude: place.location?.lat(),
+        longitude: place.location?.lng(),
+        name: place.displayName ?? prediction.label,
+        address: place.formattedAddress ?? undefined,
+        placeId: prediction.placeId,
+        addressDetail: parseAddressComponents(place.addressComponents),
+    };
+}

package/dist/Shared/ErkAvailabilityPicker/ErkAvailabilityPicker.d.ts

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

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;