@arkyn/components 3.0.1-beta.145 → 3.0.1-beta.147

package/dist/components/fullCalendar/_fullCalendarProvider.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from "react";
+import { type FullCalendarMatrix, type FullCalendarWeekMatrix } from "./_viewService";
+type FullCalendarEvent = {
+    initialDate: Date;
+    endDate?: Date;
+    title: string;
+    data?: any;
+    scheme?: "primary" | "success" | "warning" | "danger" | "info";
+    onClick?: (data: any) => void;
+};
+type BlockTimestamp = {
+    initialDate: Date;
+    endDate: Date;
+};
+type FullCalendarContextProps = {
+    events: FullCalendarEvent[];
+    blockedTimestamps: BlockTimestamp[];
+    viewDate: Date;
+    listHours: number[];
+    listWeek: string[];
+    listMonthlyMatrix: FullCalendarMatrix;
+    listWeeklyMatrix: FullCalendarWeekMatrix;
+    nextMonth: () => void;
+    nextWeek: () => void;
+    nextDay: () => void;
+    previousMonth: () => void;
+    previousWeek: () => void;
+    previousDay: () => void;
+    onClickDate?: (date: Date) => void;
+};
+type FullCalendarProviderProps = {
+    events: FullCalendarEvent[];
+    blockedTimestamps: BlockTimestamp[];
+    children: ReactNode;
+    language?: string;
+    defaultValue?: Date;
+    onChangeView?: (date: Date) => void;
+    onClickDate?: (date: Date) => void;
+};
+declare function useFullCalendar(): FullCalendarContextProps;
+declare function FullCalendarProvider(props: FullCalendarProviderProps): import("react/jsx-runtime").JSX.Element;
+export { FullCalendarProvider, useFullCalendar };
+//# sourceMappingURL=_fullCalendarProvider.d.ts.map

package/dist/components/fullCalendar/_fullCalendarProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_fullCalendarProvider.d.ts","sourceRoot":"","sources":["../../../src/components/fullCalendar/_fullCalendarProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC5E,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,gBAAgB,CAAC;AAExB,KAAK,iBAAiB,GAAG;IACvB,WAAW,EAAE,IAAI,CAAC;IAClB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;CAC/B,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,WAAW,EAAE,IAAI,CAAC;IAClB,OAAO,EAAE,IAAI,CAAC;CACf,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,iBAAiB,EAAE,cAAc,EAAE,CAAC;IACpC,QAAQ,EAAE,IAAI,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,gBAAgB,EAAE,sBAAsB,CAAC;IACzC,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,iBAAiB,EAAE,cAAc,EAAE,CAAC;IACpC,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACpC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;CACpC,CAAC;AAIF,iBAAS,eAAe,6BAEvB;AAED,iBAAS,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CAkC7D;AAED,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,CAAC"}

package/dist/components/fullCalendar/_fullCalendarProvider.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState } from "react";
+import { ViewService, } from "./_viewService";
+const FullCalendarContext = createContext({});
+function useFullCalendar() {
+    return useContext(FullCalendarContext);
+}
+function FullCalendarProvider(props) {
+    const language = props.language || "pt-BR";
+    const viewService = new ViewService();
+    const listHours = viewService.listHours([8, 18]);
+    const [viewDate, rawSetViewDate] = useState(props.defaultValue || new Date());
+    function setViewDate(date) {
+        if (props.onChangeView)
+            props.onChangeView(date);
+        rawSetViewDate(date);
+    }
+    return (_jsx(FullCalendarContext.Provider, { value: {
+            events: props.events,
+            blockedTimestamps: props.blockedTimestamps,
+            viewDate,
+            listHours,
+            listWeek: viewService.listWeek(viewDate, language),
+            listMonthlyMatrix: viewService.listMonthlyMatrix(viewDate),
+            listWeeklyMatrix: viewService.listWeeklyMatrix(viewDate, listHours),
+            nextMonth: () => viewService.nextMonth(viewDate, setViewDate),
+            nextWeek: () => viewService.nextWeek(viewDate, setViewDate),
+            nextDay: () => viewService.nextDay(viewDate, setViewDate),
+            previousMonth: () => viewService.previousMonth(viewDate, setViewDate),
+            previousWeek: () => viewService.previousWeek(viewDate, setViewDate),
+            previousDay: () => viewService.previousDay(viewDate, setViewDate),
+            onClickDate: props.onClickDate,
+        }, children: props.children }));
+}
+export { FullCalendarProvider, useFullCalendar };

package/dist/components/fullCalendar/_viewService.d.ts

@@ -0,0 +1,28 @@
+type FullCalendarCell = {
+    day: number;
+    month: number;
+    year: number;
+    dayOwner: "previous" | "current" | "next";
+};
+type FullCalendarMatrix = FullCalendarCell[][];
+type FullCalendarWeekCell = FullCalendarCell & {
+    timeInMinutes: number;
+};
+type FullCalendarWeekMatrix = FullCalendarWeekCell[][];
+declare class ViewService {
+    capitalize(text: string): string;
+    listHours(range: [number, number]): number[];
+    formatHourLabel(timeInMinutes: number): string;
+    getStartOfWeek(viewDate: Date): Date;
+    listWeek(viewDate: Date, language: string): string[];
+    listWeeklyMatrix(viewDate: Date, hours: number[]): FullCalendarWeekMatrix;
+    listMonthlyMatrix(viewDate: Date): FullCalendarMatrix;
+    nextMonth(viewDate: Date, setViewDate: (date: Date) => void): void;
+    nextWeek(viewDate: Date, setViewDate: (date: Date) => void): void;
+    nextDay(viewDate: Date, setViewDate: (date: Date) => void): void;
+    previousMonth(viewDate: Date, setViewDate: (date: Date) => void): void;
+    previousWeek(viewDate: Date, setViewDate: (date: Date) => void): void;
+    previousDay(viewDate: Date, setViewDate: (date: Date) => void): void;
+}
+export { ViewService, type FullCalendarMatrix, type FullCalendarWeekMatrix };
+//# sourceMappingURL=_viewService.d.ts.map

package/dist/components/fullCalendar/_viewService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_viewService.d.ts","sourceRoot":"","sources":["../../../src/components/fullCalendar/_viewService.ts"],"names":[],"mappings":"AAEA,KAAK,gBAAgB,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;CAC3C,CAAC;AAEF,KAAK,kBAAkB,GAAG,gBAAgB,EAAE,EAAE,CAAC;AAC/C,KAAK,oBAAoB,GAAG,gBAAgB,GAAG;IAC7C,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,KAAK,sBAAsB,GAAG,oBAAoB,EAAE,EAAE,CAAC;AAEvD,cAAM,WAAW;IACf,UAAU,CAAC,IAAI,EAAE,MAAM;IAIvB,SAAS,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IAejC,eAAe,CAAC,aAAa,EAAE,MAAM;IAOrC,cAAc,CAAC,QAAQ,EAAE,IAAI;IAQ7B,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM;IAgBzC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,sBAAsB;IAoCzE,iBAAiB,CAAC,QAAQ,EAAE,IAAI;IAwDhC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAM3D,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAM1D,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAMzD,aAAa,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAM/D,YAAY,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAM9D,WAAW,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;CAK9D;AAED,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,CAAC"}

package/dist/components/fullCalendar/_viewService.js

@@ -0,0 +1,144 @@
+import { formatToCapitalizeFirstWordLetter } from "@arkyn/shared";
+class ViewService {
+    capitalize(text) {
+        return formatToCapitalizeFirstWordLetter(text);
+    }
+    listHours(range) {
+        const [startHour, endHour] = range;
+        const hours = [];
+        for (let timeInMinutes = startHour * 60; timeInMinutes <= endHour * 60; timeInMinutes += 30) {
+            hours.push(timeInMinutes);
+        }
+        return hours;
+    }
+    formatHourLabel(timeInMinutes) {
+        const hour = Math.floor(timeInMinutes / 60);
+        const minutes = timeInMinutes % 60;
+        return `${String(hour).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+    }
+    getStartOfWeek(viewDate) {
+        const firstDayOfWeek = new Date(viewDate);
+        firstDayOfWeek.setHours(0, 0, 0, 0);
+        firstDayOfWeek.setDate(firstDayOfWeek.getDate() - firstDayOfWeek.getDay());
+        return firstDayOfWeek;
+    }
+    listWeek(viewDate, language) {
+        const weekDays = [];
+        const firstDayOfWeek = this.getStartOfWeek(viewDate);
+        for (let i = 0; i < 7; i++) {
+            const day = new Date(firstDayOfWeek);
+            day.setDate(firstDayOfWeek.getDate() + i);
+            const dayName = day.toLocaleDateString(language, {
+                weekday: "short",
+            });
+            weekDays.push(dayName);
+        }
+        return weekDays;
+    }
+    listWeeklyMatrix(viewDate, hours) {
+        const firstDayOfWeek = this.getStartOfWeek(viewDate);
+        const viewMonth = viewDate.getMonth();
+        return hours.map((hour) => {
+            return Array.from({ length: 7 }, (_, index) => {
+                const cellDate = new Date(firstDayOfWeek);
+                cellDate.setDate(firstDayOfWeek.getDate() + index);
+                let dayOwner = "current";
+                if (cellDate.getMonth() < viewMonth ||
+                    cellDate.getFullYear() < viewDate.getFullYear()) {
+                    dayOwner = "previous";
+                }
+                if (cellDate.getMonth() > viewMonth ||
+                    cellDate.getFullYear() > viewDate.getFullYear()) {
+                    dayOwner = "next";
+                }
+                return {
+                    day: cellDate.getDate(),
+                    month: cellDate.getMonth(),
+                    year: cellDate.getFullYear(),
+                    dayOwner,
+                    timeInMinutes: hour,
+                };
+            });
+        });
+    }
+    listMonthlyMatrix(viewDate) {
+        const year = viewDate.getFullYear();
+        const monthIndex = viewDate.getMonth();
+        const firstDayOfMonth = new Date(year, monthIndex, 1);
+        const firstWeekday = firstDayOfMonth.getDay();
+        const daysInCurrentMonth = new Date(year, monthIndex + 1, 0).getDate();
+        const daysInPreviousMonth = new Date(year, monthIndex, 0).getDate();
+        const totalCells = Math.ceil((firstWeekday + daysInCurrentMonth) / 7) * 7;
+        const weeks = [];
+        let currentMonthDay = 1;
+        let nextMonthDay = 1;
+        for (let i = 0; i < totalCells; i++) {
+            const weekIndex = Math.floor(i / 7);
+            if (!weeks[weekIndex])
+                weeks[weekIndex] = [];
+            if (i < firstWeekday) {
+                const day = daysInPreviousMonth - (firstWeekday - i - 1);
+                const month = monthIndex === 0 ? 11 : monthIndex - 1;
+                const cellYear = monthIndex === 0 ? year - 1 : year;
+                weeks[weekIndex].push({
+                    day,
+                    month,
+                    year: cellYear,
+                    dayOwner: "previous",
+                });
+            }
+            else if (currentMonthDay <= daysInCurrentMonth) {
+                weeks[weekIndex].push({
+                    day: currentMonthDay,
+                    month: monthIndex,
+                    year: year,
+                    dayOwner: "current",
+                });
+                currentMonthDay++;
+            }
+            else {
+                const month = monthIndex === 11 ? 0 : monthIndex + 1;
+                const cellYear = monthIndex === 11 ? year + 1 : year;
+                weeks[weekIndex].push({
+                    day: nextMonthDay,
+                    month,
+                    year: cellYear,
+                    dayOwner: "next",
+                });
+                nextMonthDay++;
+            }
+        }
+        return weeks;
+    }
+    nextMonth(viewDate, setViewDate) {
+        const nextViewDate = new Date(viewDate);
+        nextViewDate.setMonth(nextViewDate.getMonth() + 1);
+        setViewDate(nextViewDate);
+    }
+    nextWeek(viewDate, setViewDate) {
+        const nextViewDate = new Date(viewDate);
+        nextViewDate.setDate(nextViewDate.getDate() + 7);
+        setViewDate(nextViewDate);
+    }
+    nextDay(viewDate, setViewDate) {
+        const nextViewDate = new Date(viewDate);
+        nextViewDate.setDate(nextViewDate.getDate() + 1);
+        setViewDate(nextViewDate);
+    }
+    previousMonth(viewDate, setViewDate) {
+        const nextViewDate = new Date(viewDate);
+        nextViewDate.setMonth(nextViewDate.getMonth() - 1);
+        setViewDate(nextViewDate);
+    }
+    previousWeek(viewDate, setViewDate) {
+        const nextViewDate = new Date(viewDate);
+        nextViewDate.setDate(nextViewDate.getDate() - 7);
+        setViewDate(nextViewDate);
+    }
+    previousDay(viewDate, setViewDate) {
+        const nextViewDate = new Date(viewDate);
+        nextViewDate.setDate(nextViewDate.getDate() - 1);
+        setViewDate(nextViewDate);
+    }
+}
+export { ViewService };

package/dist/components/fullCalendar/dayCalendar/dayCalendarContainer/index.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+import "./styles.css";
+type DayCalendarContainerProps = {
+    children: ReactNode;
+};
+declare function DayCalendarContainer({ children }: DayCalendarContainerProps): import("react/jsx-runtime").JSX.Element;
+export { DayCalendarContainer };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/dayCalendar/dayCalendarContainer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/fullCalendar/dayCalendar/dayCalendarContainer/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,cAAc,CAAC;AAEtB,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,iBAAS,oBAAoB,CAAC,EAAE,QAAQ,EAAE,EAAE,yBAAyB,2CAEpE;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/components/fullCalendar/dayCalendar/dayCalendarContainer/index.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import "./styles.css";
+function DayCalendarContainer({ children }) {
+    return _jsx("div", { className: "arkynDayCalendarContainer", children: children });
+}
+export { DayCalendarContainer };

package/dist/components/fullCalendar/dayCalendar/dayCalendarEvent/index.d.ts

@@ -0,0 +1,7 @@
+import "./styles.css";
+type DayCalendarEventProps = {
+    timeInMinutes: number;
+};
+declare function DayCalendarEvent(props: DayCalendarEventProps): import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];
+export { DayCalendarEvent };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/dayCalendar/dayCalendarEvent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/fullCalendar/dayCalendar/dayCalendarEvent/index.tsx"],"names":[],"mappings":"AACA,OAAO,cAAc,CAAC;AAEtB,KAAK,qBAAqB,GAAG;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAKF,iBAAS,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,uFAoJrD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/components/fullCalendar/dayCalendar/dayCalendarEvent/index.js

@@ -0,0 +1,105 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFullCalendar } from "../../_fullCalendarProvider";
+import "./styles.css";
+const SLOT_DURATION_MINUTES = 30;
+const OVERLAP_OFFSET_PX = 205;
+function DayCalendarEvent(props) {
+    const { events, viewDate } = useFullCalendar();
+    const day = viewDate.getDate();
+    const month = viewDate.getMonth();
+    const year = viewDate.getFullYear();
+    const dayEvents = events
+        .map((event, sourceIndex) => ({ event, sourceIndex }))
+        .filter(({ event }) => {
+        return (event.initialDate.getDate() === day &&
+            event.initialDate.getMonth() === month &&
+            event.initialDate.getFullYear() === year);
+    })
+        .sort((a, b) => {
+        const startA = a.event.initialDate.getTime();
+        const startB = b.event.initialDate.getTime();
+        if (startA !== startB)
+            return startA - startB;
+        const endA = a.event.endDate?.getTime() ?? startA + SLOT_DURATION_MINUTES * 60_000;
+        const endB = b.event.endDate?.getTime() ?? startB + SLOT_DURATION_MINUTES * 60_000;
+        if (endA !== endB)
+            return endA - endB;
+        return a.sourceIndex - b.sourceIndex;
+    });
+    const dayEventOrderBySourceIndex = new Map(dayEvents.map((item, orderIndex) => [item.sourceIndex, orderIndex]));
+    const filteredEvents = dayEvents.filter(({ event }) => {
+        const dayHour = Math.floor(props.timeInMinutes / 60);
+        const dayMinute = props.timeInMinutes % 60;
+        function isEventInInterval() {
+            const eventHour = event.initialDate.getHours();
+            const eventMinute = event.initialDate.getMinutes();
+            if (eventHour !== dayHour)
+                return false;
+            if (dayMinute === 0)
+                return eventMinute < 30 && eventMinute >= 0;
+            if (dayMinute === 30)
+                return eventMinute >= 30 && eventMinute < 60;
+        }
+        return (isEventInInterval() &&
+            event.initialDate.getDate() === day &&
+            event.initialDate.getMonth() === month &&
+            event.initialDate.getFullYear() === year);
+    });
+    if (filteredEvents.length === 0)
+        return _jsx(_Fragment, {});
+    function makeEventKey(index, sourceIndex) {
+        return `${day}-${month}-${year}-${sourceIndex}-${index}`;
+    }
+    function makeHour(date) {
+        const hours = date.getHours();
+        const minutes = date.getMinutes();
+        if (minutes === 0)
+            return `${hours}h`;
+        return `${hours}h${minutes}`;
+    }
+    function getEventRangeInMinutes(event) {
+        const startMinutes = event.initialDate.getHours() * 60 + event.initialDate.getMinutes();
+        const endMinutes = event.endDate
+            ? event.endDate.getHours() * 60 + event.endDate.getMinutes()
+            : startMinutes + SLOT_DURATION_MINUTES;
+        return {
+            startMinutes,
+            endMinutes: Math.max(endMinutes, startMinutes + 1),
+        };
+    }
+    function countOverlappingPreviousEvents(currentEvent, sourceIndex) {
+        const current = getEventRangeInMinutes(currentEvent);
+        const currentOrderIndex = dayEventOrderBySourceIndex.get(sourceIndex);
+        if (currentOrderIndex == null)
+            return 0;
+        return dayEvents.reduce((count, item, orderIndex) => {
+            if (orderIndex >= currentOrderIndex)
+                return count;
+            const candidate = getEventRangeInMinutes(item.event);
+            const intersects = candidate.startMinutes < current.endMinutes &&
+                candidate.endMinutes > current.startMinutes;
+            if (!intersects)
+                return count;
+            return count + 1;
+        }, 0);
+    }
+    function getEventStyle(event, sourceIndex) {
+        const { startMinutes, endMinutes } = getEventRangeInMinutes(event);
+        const startOffsetInCell = startMinutes - props.timeInMinutes;
+        const durationInMinutes = Math.max(endMinutes - startMinutes, 1);
+        const top = (startOffsetInCell / SLOT_DURATION_MINUTES) * 100;
+        const height = (durationInMinutes / SLOT_DURATION_MINUTES) * 100;
+        const overlapOffset = countOverlappingPreviousEvents(event, sourceIndex) * OVERLAP_OFFSET_PX;
+        return {
+            top: `${top}%`,
+            height: `${height}%`,
+            left: `${overlapOffset}px`,
+        };
+    }
+    function handleEventClick(event, eventData) {
+        event.stopPropagation();
+        eventData.onClick?.(eventData.data);
+    }
+    return filteredEvents.map(({ event, sourceIndex }, index) => (_jsxs("div", { className: `arkynDayCalendarEvent ${event?.scheme || "primary"}`, style: getEventStyle(event, sourceIndex), onClick: (e) => handleEventClick(e, event), children: [_jsxs("strong", { children: [makeHour(event.initialDate), " ", event?.endDate && `- ${makeHour(event.endDate)}`] }), _jsx("p", { children: event.title })] }, makeEventKey(index, sourceIndex))));
+}
+export { DayCalendarEvent };

package/dist/components/fullCalendar/dayCalendar/dayCalendarRow/index.d.ts

@@ -0,0 +1,8 @@
+import "./styles.css";
+type DayCalendarRowProps = {
+    hour: number;
+    timeInMinutes: number;
+};
+declare function DayCalendarRow({ hour, timeInMinutes }: DayCalendarRowProps): import("react/jsx-runtime").JSX.Element;
+export { DayCalendarRow, type DayCalendarRowProps };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/dayCalendar/dayCalendarRow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/fullCalendar/dayCalendar/dayCalendarRow/index.tsx"],"names":[],"mappings":"AAGA,OAAO,cAAc,CAAC;AAEtB,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,iBAAS,cAAc,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,mBAAmB,2CAmCnE;AAED,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,CAAC"}

package/dist/components/fullCalendar/dayCalendar/dayCalendarRow/index.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFullCalendar } from "../../_fullCalendarProvider";
+import { ViewService } from "../../_viewService";
+import { DayCalendarEvent } from "../dayCalendarEvent";
+import "./styles.css";
+function DayCalendarRow({ hour, timeInMinutes }) {
+    const viewService = new ViewService();
+    const { blockedTimestamps, viewDate, onClickDate } = useFullCalendar();
+    function isBlocked() {
+        return blockedTimestamps.some((timestamp) => viewDate >= timestamp.initialDate && viewDate <= timestamp.endDate);
+    }
+    function handleClick(event) {
+        event.stopPropagation();
+        if (isBlocked())
+            return;
+        if (onClickDate) {
+            const date = new Date(viewDate);
+            date.setHours(0, timeInMinutes, 0, 0);
+            onClickDate(date);
+        }
+    }
+    return (_jsxs("div", { className: `arkynDayCalendarRow ${isBlocked() ? "blocked" : ""}`, "data-time": timeInMinutes, onClick: handleClick, children: [_jsx("p", { children: viewService.formatHourLabel(hour) }), _jsx("div", { className: "arkynDayCalendarRowContent", children: _jsx(DayCalendarEvent, { timeInMinutes: timeInMinutes }) })] }));
+}
+export { DayCalendarRow };

package/dist/components/fullCalendar/dayCalendar/index.d.ts

@@ -0,0 +1,3 @@
+declare function DayCalendar(): import("react/jsx-runtime").JSX.Element;
+export { DayCalendar };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/dayCalendar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/fullCalendar/dayCalendar/index.tsx"],"names":[],"mappings":"AAIA,iBAAS,WAAW,4CASnB;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/components/fullCalendar/dayCalendar/index.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFullCalendar } from "../_fullCalendarProvider";
+import { DayCalendarContainer } from "./dayCalendarContainer";
+import { DayCalendarRow } from "./dayCalendarRow";
+function DayCalendar() {
+    const { listHours } = useFullCalendar();
+    return (_jsx(DayCalendarContainer, { children: listHours.map((hour) => (_jsx(DayCalendarRow, { hour: hour, timeInMinutes: hour }))) }));
+}
+export { DayCalendar };

package/dist/components/fullCalendar/fullCalendarContainer/index.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+import "./styles.css";
+type FullCalendarContainerProps = {
+    children?: ReactNode;
+};
+declare function FullCalendarContainer({ children }: FullCalendarContainerProps): import("react/jsx-runtime").JSX.Element;
+export { FullCalendarContainer };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/fullCalendarContainer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/fullCalendar/fullCalendarContainer/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,cAAc,CAAC;AAEtB,KAAK,0BAA0B,GAAG;IAChC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,iBAAS,qBAAqB,CAAC,EAAE,QAAQ,EAAE,EAAE,0BAA0B,2CAEtE;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/components/fullCalendar/fullCalendarContainer/index.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import "./styles.css";
+function FullCalendarContainer({ children }) {
+    return _jsx("div", { className: "arkynFullCalendarContainer", children: children });
+}
+export { FullCalendarContainer };

package/dist/components/fullCalendar/fullCalendarHeader/index.d.ts

@@ -0,0 +1,8 @@
+import "./styles.css";
+type FullCalendarHeaderProps = {
+    viewType: "day" | "week" | "month";
+    setViewType: (viewType: "day" | "week" | "month") => void;
+};
+declare function FullCalendarHeader(props: FullCalendarHeaderProps): import("react/jsx-runtime").JSX.Element;
+export { FullCalendarHeader };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/fullCalendarHeader/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/fullCalendar/fullCalendarHeader/index.tsx"],"names":[],"mappings":"AAOA,OAAO,cAAc,CAAC;AAEtB,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IACnC,WAAW,EAAE,CAAC,QAAQ,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAC;CAC3D,CAAC;AAEF,iBAAS,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,2CA8DzD;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/components/fullCalendar/fullCalendarHeader/index.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { CardTabButton } from "../../cardTab/cardTabButton";
+import { CardTabContainer } from "../../cardTab/cardTabContainer";
+import { IconButton } from "../../iconButton";
+import { useFullCalendar } from "../_fullCalendarProvider";
+import "./styles.css";
+function FullCalendarHeader(props) {
+    const { setViewType, viewType } = props;
+    const fullCalendar = useFullCalendar();
+    function handlePrevious() {
+        switch (viewType) {
+            case "day":
+                return fullCalendar.previousDay();
+            case "week":
+                return fullCalendar.previousWeek();
+            case "month":
+                return fullCalendar.previousMonth();
+        }
+    }
+    function handleNext() {
+        switch (viewType) {
+            case "day":
+                return fullCalendar.nextDay();
+            case "week":
+                return fullCalendar.nextWeek();
+            case "month":
+                return fullCalendar.nextMonth();
+        }
+    }
+    return (_jsxs("div", { className: "arkynFullCalendarHeader", children: [_jsxs(CardTabContainer, { defaultValue: viewType, onChange: (value) => setViewType(value), children: [_jsx(CardTabButton, { value: "day", children: "Dia" }), _jsx(CardTabButton, { value: "week", children: "Semana" }), _jsx(CardTabButton, { value: "month", children: "M\u00EAs" })] }), _jsxs("div", { className: "arkynFullCalendarHeaderActions", children: [_jsx(IconButton, { variant: "outline", icon: ChevronLeft, "aria-label": "Handle previous", onClick: () => handlePrevious() }), _jsx("p", { children: fullCalendar.viewDate.toLocaleDateString("pt-BR", {
+                            day: "2-digit",
+                            month: "long",
+                            year: "numeric",
+                        }) }), _jsx(IconButton, { variant: "outline", icon: ChevronRight, "aria-label": "Handle next", onClick: () => handleNext() })] })] }));
+}
+export { FullCalendarHeader };

package/dist/components/fullCalendar/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Represents a single event rendered on the calendar.
+ */
+type FullCalendarEvent = {
+    /** Display label shown on the event block. */
+    title: string;
+    /** Start date and time of the event. */
+    initialDate: Date;
+    /** End date and time of the event. */
+    endDate?: Date;
+    /** Arbitrary payload forwarded to the `onClick` callback. */
+    data?: any;
+    /**
+     * Color scheme applied to the event block.
+     * - `primary`: default blue.
+     * - `success`: green.
+     * - `warning`: yellow.
+     * - `danger`: red.
+     * - `info`: light blue.
+     *
+     * @default "primary"
+     */
+    scheme?: "primary" | "success" | "warning" | "danger" | "info";
+    /** Callback fired when the user clicks the event. Receives `data` as argument. */
+    onClick?: (data: any) => void;
+};
+/**
+ * Represents a blocked (unavailable) time range on the calendar.
+ */
+type BlockTimestamp = {
+    /** Start of the blocked range. */
+    initialDate: Date;
+    /** End of the blocked range. */
+    endDate: Date;
+};
+/**
+ * Props for the FullCalendar component.
+ */
+type FullCalendarProps = {
+    /** Initial focused date when the calendar mounts. */
+    defaultValue?: Date;
+    /** List of events to display across day, week, and month views. */
+    events?: FullCalendarEvent[];
+    /** Time ranges that should be visually marked as unavailable. */
+    blockedTimestamps?: BlockTimestamp[];
+    /** Callback fired when the user navigates to a different period. */
+    onChangeView?: (date: Date) => void;
+    /** Callback fired when the user clicks a date cell. */
+    onClickDate?: (date: Date) => void;
+};
+/**
+ * Full-featured calendar component with day, week, and month views.
+ *
+ * Renders a switchable calendar that supports event display, blocked time
+ * ranges, and date navigation. Internal state and business logic are managed
+ * by `FullCalendarProvider`, keeping the public API minimal.
+ *
+ * @param props FullCalendar properties.
+ * @returns Calendar UI with a view switcher header and the active view grid.
+ *
+ * @example
+ * // Basic usage with events
+ * <FullCalendar
+ *   defaultValue={new Date()}
+ *   events={[
+ *     {
+ *       title: "Team standup",
+ *       initialDate: new Date(2026, 5, 22, 9, 0),
+ *       endDate: new Date(2026, 5, 22, 9, 30),
+ *       scheme: "primary",
+ *       onClick: (data) => console.log("Event clicked:", data),
+ *     },
+ *   ]}
+ *   onChangeView={(date) => console.log("Viewing:", date)}
+ *   onClickDate={(date) => console.log("Date clicked:", date)}
+ * />
+ *
+ * @example
+ * // With blocked timestamps
+ * <FullCalendar
+ *   defaultValue={new Date()}
+ *   blockedTimestamps={[
+ *     {
+ *       initialDate: new Date(2026, 5, 22, 12, 0),
+ *       endDate: new Date(2026, 5, 22, 13, 0),
+ *     },
+ *   ]}
+ * />
+ */
+declare function FullCalendar(props: FullCalendarProps): import("react/jsx-runtime").JSX.Element;
+export { FullCalendar };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/fullCalendar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/fullCalendar/index.tsx"],"names":[],"mappings":"AAQA;;GAEG;AACH,KAAK,iBAAiB,GAAG;IACvB,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,WAAW,EAAE,IAAI,CAAC;IAClB,sCAAsC;IACtC,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,6DAA6D;IAC7D,IAAI,CAAC,EAAE,GAAG,CAAC;IACX;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/D,kFAAkF;IAClF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;CAC/B,CAAC;AAEF;;GAEG;AACH,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,WAAW,EAAE,IAAI,CAAC;IAClB,gCAAgC;IAChC,OAAO,EAAE,IAAI,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,KAAK,iBAAiB,GAAG;IACvB,qDAAqD;IACrD,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,mEAAmE;IACnE,MAAM,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC7B,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,cAAc,EAAE,CAAC;IACrC,oEAAoE;IACpE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACpC,uDAAuD;IACvD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAmB7C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}