@arquimedes.co/eureka-forms 3.0.53-new-steps → 3.0.55-new-steps

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

@@ -43,6 +43,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.

package/dist/@Types/CalendarFormStep.js

@@ -46,3 +46,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/CalendarStep/MaterialCalendarStep/MaterialCalendarStep.d.ts

@@ -1,7 +1,8 @@
 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).
+ * Conector del paso CALENDAR/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 MaterialCalendarStep({ step, editable }: CalendarStepProps): JSX.Element;
 export default MaterialCalendarStep;

package/dist/FormSteps/CalendarStep/MaterialCalendarStep/MaterialCalendarStep.js

@@ -4,10 +4,11 @@ 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 CALENDAR/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 }) {
     const currentBreakPoint = useAppSelector(selectBreakPoint);
@@ -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;

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/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.53-new-steps",
+  "version":"3.0.55-new-steps",
   "scripts": {
     "watch": "tsgo --noEmit --watch --project tsconfig.app.json",
     "start": "vite",

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;

package/dist/Shared/ErkCalendar/CalendarFunctions.js

@@ -1,121 +0,0 @@
-import { differenceInCalendarDays, differenceInCalendarMonths, differenceInCalendarWeeks, format, isSameDay, startOfDay, } from 'date-fns';
-import { CalendarEventCategory, } from '../../@Types/CalendarFormStep';
-/** Color base por categoría (paleta del app; navy = primario, coral = acento). */
-export const CATEGORY_COLORS = {
-    [CalendarEventCategory.WORKING]: '#3d5a7f',
-    [CalendarEventCategory.PHYSICAL]: '#2e9367',
-    [CalendarEventCategory.VIRTUAL]: '#7b5ea7',
-    [CalendarEventCategory.SPECIFIC]: '#ee6c4d',
-    [CalendarEventCategory.MEETING]: '#d9822b',
-    [CalendarEventCategory.BUSY]: '#98a2b3',
-    [CalendarEventCategory.CUSTOM]: '#607d8b',
-};
-export const CATEGORY_LABELS = {
-    [CalendarEventCategory.WORKING]: 'Laboral',
-    [CalendarEventCategory.PHYSICAL]: 'Presencial',
-    [CalendarEventCategory.VIRTUAL]: 'Virtual',
-    [CalendarEventCategory.SPECIFIC]: 'Específico',
-    [CalendarEventCategory.MEETING]: 'Reunión',
-    [CalendarEventCategory.BUSY]: 'Ocupado',
-    [CalendarEventCategory.CUSTOM]: 'Personalizado',
-};
-/**
- * Categorías que definen ventanas de disponibilidad: se pintan como franja rayada
- * de fondo (se puede agendar encima), no como bloques sólidos.
- */
-const AVAILABILITY_CATEGORIES = new Set([
-    CalendarEventCategory.WORKING,
-    CalendarEventCategory.PHYSICAL,
-    CalendarEventCategory.VIRTUAL,
-    CalendarEventCategory.SPECIFIC,
-]);
-export function isAvailability(category) {
-    return AVAILABILITY_CATEGORIES.has(category);
-}
-export function parseTime(hhmm) {
-    const [h, m] = hhmm.split(':').map(Number);
-    return { h: h ?? 0, m: m ?? 0 };
-}
-export function toMinutes(hhmm) {
-    const { h, m } = parseTime(hhmm);
-    return h * 60 + m;
-}
-export function minutesToHHMM(mins) {
-    const h = Math.floor(mins / 60);
-    const m = mins % 60;
-    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
-}
-/** "2026-07-14T09:30:00" → "09:30" */
-export function isoToHHMM(iso) {
-    return iso.slice(11, 16);
-}
-/** Compone el ISO en hora local (sin corrimiento de zona horaria). */
-export function dateAndTimeToISO(date, hhmm) {
-    const { h, m } = parseTime(hhmm);
-    const d = new Date(date);
-    d.setHours(h, m, 0, 0);
-    return `${format(d, 'yyyy-MM-dd')}T${format(d, 'HH:mm:ss')}`;
-}
-/** Interpreta el ISO como hora local (sin corrimiento de zona horaria). */
-export function isoToDate(iso) {
-    const [datePart, timePart] = iso.slice(0, 19).split('T');
-    const [y, mo, d] = datePart.split('-').map(Number);
-    const { h, m } = parseTime(timePart ?? '00:00');
-    return new Date(y, (mo ?? 1) - 1, d ?? 1, h, m, 0, 0);
-}
-export function newEventId() {
-    return `evt-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-}
-/** Códigos de día RFC 5545 indexados por `Date.getDay()`. */
-const RRULE_DAY_CODES = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
-/**
- * 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 function occursOnDay(event, day) {
-    const start = isoToDate(event.start);
-    if (isSameDay(start, day))
-        return true;
-    if (!event.recurrence)
-        return false;
-    if (startOfDay(day) < startOfDay(start))
-        return false;
-    const rule = event.recurrence;
-    const interval = /INTERVAL=(\d+)/.exec(rule);
-    const every = interval ? parseInt(interval[1], 10) : 1;
-    if (rule.includes('FREQ=DAILY')) {
-        return differenceInCalendarDays(day, start) % every === 0;
-    }
-    if (rule.includes('FREQ=WEEKLY')) {
-        const byday = /BYDAY=([A-Z,]+)/.exec(rule);
-        if (byday) {
-            if (!byday[1].split(',').includes(RRULE_DAY_CODES[day.getDay()]))
-                return false;
-        }
-        else if (day.getDay() !== start.getDay()) {
-            return false;
-        }
-        return differenceInCalendarWeeks(day, start, { weekStartsOn: 1 }) % every === 0;
-    }
-    if (rule.includes('FREQ=MONTHLY')) {
-        if (day.getDate() !== start.getDate())
-            return false;
-        return differenceInCalendarMonths(day, start) % every === 0;
-    }
-    return false;
-}
-export function eventColor(event, templates) {
-    if (event.color)
-        return event.color;
-    const template = templates?.find((t) => t.id === event.eventTemplateId);
-    return template?.color ?? CATEGORY_COLORS[event.category];
-}
-export function eventLabel(event, templates) {
-    if (event.title)
-        return event.title;
-    const template = templates?.find((t) => t.id === event.eventTemplateId);
-    return template?.name ?? CATEGORY_LABELS[event.category];
-}

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

@@ -1,45 +0,0 @@
-import { CalendarEvent, CalendarEventCategory, CalendarEventTemplate } from '../../@Types/CalendarFormStep';
-export interface CalendarCreateState {
-    anchorEl: HTMLElement;
-    date: Date;
-    /** Hora de inicio sugerida en formato HH:mm (según dónde se hizo clic). */
-    startHHMM: string;
-    /** Hora de fin sugerida en formato HH:mm. */
-    endHHMM: string;
-}
-interface CalendarCreatePopoverProps {
-    state: CalendarCreateState;
-    /** Categorías de disponibilidad permitidas (laboral/presencial/virtual). */
-    availabilityCategories: CalendarEventCategory[];
-    /** Categorías de evento permitidas (reunión/ocupado/personalizado). */
-    eventCategories: CalendarEventCategory[];
-    /** Plantillas de la organización: las `bookable` son tipos de espacio agendable. */
-    eventTemplates?: CalendarEventTemplate[];
-    allowRecurring: boolean;
-    allowAllDay: boolean;
-    onClose: () => void;
-    onCreate: (event: CalendarEvent) => void;
-}
-/**
- * Popover anclado al slot clickeado, con dos modos:
- * - Disponibilidad: crea ventanas agendables — "estoy libre para que me agenden"
- *   (general/presencial/virtual, o un tipo de espacio de la organización).
- * - Evento: reuniones, bloqueos y eventos personalizados.
- */
-export declare function CalendarCreatePopover({ state, availabilityCategories, eventCategories, eventTemplates, allowRecurring, allowAllDay, onClose, onCreate, }: CalendarCreatePopoverProps): JSX.Element;
-export interface CalendarDetailState {
-    anchorEl: HTMLElement;
-    event: CalendarEvent;
-    /** Si el evento es del calendario propio (editable) o de una fuente compartida. */
-    own: boolean;
-}
-interface CalendarDetailPopoverProps {
-    state: CalendarDetailState;
-    eventTemplates?: CalendarEventTemplate[];
-    readOnly: boolean;
-    onClose: () => void;
-    onDelete: (id: string) => void;
-}
-/** Detalle de un evento: cuándo, categoría, notas y acciones. */
-export declare function CalendarDetailPopover({ state, eventTemplates, readOnly, onClose, onDelete, }: CalendarDetailPopoverProps): JSX.Element;
-export {};