react-weekly-planning 1.0.38 → 1.0.40

package/dist/components/VirtualGroupRow.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useRef, useMemo } from "react";
+import { v4 as uuidv4 } from "uuid";
+import { useIntersectionObserver } from "../hooks/useIntersectionObserver";
+import GroupContainer from "./GroupContainer";
+import TaskVirtual from "./TaskContainer/TaskVirtual";
+import AddTask from "./AddTask";
+import { getHash, getSessionStorageRecordForDragAndDrop, getUnqueId, updateOffsetWithDateCalendar, } from "../lib/utils";
+import { groupTdStyle } from "../lib/slyles";
+const VirtualGroupRow = ({ group, i, props, getTasks, isValidTask, addTask, deleteTask, getTask, dailyHours, hashScope, tasks, sumHoursByGroupsCount }) => {
+    const ref = useRef(null);
+    const entry = useIntersectionObserver(ref, {
+        rootMargin: "600px",
+        threshold: 0,
+    });
+    const isVisible = !!(entry === null || entry === void 0 ? void 0 : entry.isIntersecting);
+    const offset = useMemo(() => updateOffsetWithDateCalendar(props.date), [props.date]);
+    const cellData = useMemo(() => {
+        if (!isVisible)
+            return [];
+        return dailyHours.map((_, positionDay) => {
+            const hash = getHash(offset, group.id, positionDay);
+            const cellTasks = getTasks(hash[hashScope]);
+            return {
+                hash: hash[hashScope],
+                tasks: cellTasks,
+                positionDay
+            };
+        });
+    }, [isVisible, offset, group.id, dailyHours, hashScope, getTasks, isValidTask, tasks]);
+    return (_jsx("div", { ref: ref, className: `planningCalendarRow ${props.rowsClassName}`, style: Object.assign(Object.assign({}, props.rowsStyle), { minHeight: isVisible ? "auto" : "60px" }), children: isVisible ? (_jsxs(_Fragment, { children: [_jsx("div", { className: `groupCol ${props.groupsColsClassName}`, style: Object.assign(Object.assign({}, groupTdStyle), props.groupsColsStyle), children: _jsx(GroupContainer, { style: props.groupContainerStyle, className: props.groupContainerClassName, groupRender: props.groupRender, currentGroup: group, handleClickGroup: props.handleClickGroup }) }, group.id), cellData.map((cell) => {
+                    return (_jsx("div", { onDragOver: (e) => e.preventDefault(), onDrop: (event) => {
+                            const dropInfo = getSessionStorageRecordForDragAndDrop(cell.tasks, cell.positionDay, group.id, getTask, cell.hash);
+                            if (!dropInfo)
+                                return;
+                            if (props.drop === "copy") {
+                                addTask(Object.assign(Object.assign({}, dropInfo.newTask), { id: uuidv4() }));
+                                return;
+                            }
+                            deleteTask(dropInfo.newTask.draghash, dropInfo.newTask.id);
+                            addTask(Object.assign(Object.assign({}, dropInfo.newTask), { id: getUnqueId() }));
+                        }, id: `col-${group.id}day-i`, className: `dayCol ${props.dayColsClassName}`, style: props.dayColsStyle, children: _jsxs("div", { style: {
+                                display: "flex",
+                                width: "100%",
+                                height: "100%",
+                                flexDirection: "column",
+                                padding: "5px",
+                            }, children: [cell.tasks.map((task) => {
+                                    if (task.dayIndex === cell.positionDay &&
+                                        task.groupId === group.id && isValidTask(task)) {
+                                        return (_jsx(TaskVirtual, { handleDragTask: props.handleDragTask, taskRender: props.taskRender, handleDragTaskEnd: props.handleDragTaskEnd, style: props.taskContainerStyle, className: `${props.taskContainerClassName}`, currentTask: task, handleClickTask: props.handleClickTask }, `${task.id} task`));
+                                    }
+                                    else
+                                        return null;
+                                }), _jsx(AddTask, { addTaskStyle: props.addTaskStyle, addTaskClassName: props.addTaskClassName, currentGroup: group, dayInfo: dailyHours[cell.positionDay], addTaskRender: props.addTaskRender, handleAddTask: props.handleAddTask })] }) }, `col-${group.id}day-i${cell.positionDay}`));
+                })] })) : (_jsx("div", { style: { height: "60px", width: "100%" } })) }));
+};
+export default memo(VirtualGroupRow, (prev, next) => {
+    return (prev.group.id === next.group.id &&
+        prev.i === next.i &&
+        prev.tasks === next.tasks &&
+        prev.props.date.getTime() === next.props.date.getTime() &&
+        prev.sumHoursByGroupsCount === next.sumHoursByGroupsCount);
+});

package/dist/components/VirtualGroupRowDay.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useRef, useMemo } from "react";
+import { useIntersectionObserver } from "../hooks/useIntersectionObserver";
+import GroupContainer from "./GroupContainer";
+import TaskVirtual from "./TaskContainer/TaskVirtual";
+import AddTask from "./AddTask";
+import { getHash, getSessionStorageRecordForDragAndDrop, getUnqueId, updateOffsetWithDateCalendar, } from "../lib/utils";
+const VirtualGroupRowDay = ({ group, i, props, getTasks, isValidTask, addTask, deleteTask, updateTask, getTask, dailyHours, dayOffset, hashScope, tasks, }) => {
+    const ref = useRef(null);
+    const entry = useIntersectionObserver(ref, {
+        rootMargin: "600px",
+        threshold: 0,
+    });
+    const isVisible = !!(entry === null || entry === void 0 ? void 0 : entry.isIntersecting);
+    const offset = useMemo(() => updateOffsetWithDateCalendar(props.date), [props.date]);
+    const currentDailyHours = dailyHours[dayOffset];
+    const hash = useMemo(() => getHash(offset, group.id, dayOffset), [offset, group.id, dayOffset]);
+    const cellTasks = useMemo(() => getTasks(hash[hashScope]), [getTasks, hash, hashScope, tasks]);
+    const handleDragOver = (event) => {
+        event.preventDefault();
+    };
+    return (_jsx("div", { ref: ref, style: Object.assign({ width: "100%", height: "auto", padding: "5px", borderBottom: "1.5px solid #0f52737e", borderRight: "0.74px solid rgba(198, 219, 225, 0.68)", borderLeft: "0.74px solid rgba(198, 219, 225, 0.68)", minHeight: isVisible ? "auto" : "60px" }, props.rowsStyle), className: `CalendarTableForDayRow ${props.rowsClassName}`, children: isVisible ? (_jsxs(_Fragment, { children: [_jsx("div", { style: Object.assign({ width: "auto", height: "auto" }, props.groupsColsStyle), className: props.groupsColsClassName, children: _jsx(GroupContainer, { style: props.groupContainerStyle, className: props.groupContainerClassName, groupRender: props.groupRender, currentGroup: group, handleClickGroup: props.handleClickGroup }) }), _jsxs("div", { className: "CalendarTableForDayGroupTasks", onDragOver: handleDragOver, onDrop: (event) => {
+                        if (!cellTasks)
+                            return;
+                        const dropInfo = getSessionStorageRecordForDragAndDrop(cellTasks, currentDailyHours.positionDay, group.id, getTask, hash[hashScope]);
+                        if (!dropInfo)
+                            return;
+                        if (props.drop === "copy") {
+                            addTask(Object.assign(Object.assign({}, dropInfo.newTask), { id: getUnqueId() }));
+                            return;
+                        }
+                        updateTask(hash[hashScope], dropInfo.newTask.id, dropInfo.newTask);
+                    }, children: [cellTasks.map((task) => {
+                            if (task.dayIndex === dayOffset &&
+                                task.groupId === group.id &&
+                                isValidTask(task)) {
+                                return (_jsx(TaskVirtual, { handleDragTask: props.handleDragTask, taskRender: props.taskRender, handleDragTaskEnd: props.handleDragTaskEnd, style: props.taskContainerStyle, className: `${props.taskContainerClassName}`, currentTask: task, handleClickTask: props.handleClickTask }, `${task.id} task`));
+                            }
+                            else
+                                return null;
+                        }), _jsx(AddTask, { addTaskStyle: props.addTaskStyle, addTaskClassName: props.addTaskClassName, currentGroup: group, dayInfo: currentDailyHours, addTaskRender: props.addTaskRender, handleAddTask: props.handleAddTask })] })] })) : (_jsx("div", { style: { height: "60px", width: "100%" } })) }));
+};
+export default memo(VirtualGroupRowDay, (prev, next) => {
+    return (prev.group.id === next.group.id &&
+        prev.i === next.i &&
+        prev.tasks === next.tasks &&
+        prev.props.date.getTime() === next.props.date.getTime() &&
+        prev.dayOffset === next.dayOffset);
+});

package/dist/components/index.js

@@ -1,7 +1,8 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import "./style.css";
 import CalendarForWeek from "./CalendarForWeek";
 import CalendarForDay from "./CalendarForday";
+import CalendarTaskContextProvider from "../contexts/CalendarTaskContext";
 /**
  * Calendar component to display tasks and groups in a weekly view.
  *
@@ -64,6 +65,6 @@ import CalendarForDay from "./CalendarForday";
  * @param {string} [props.hoursColsClassName] - Additional class names for the hours columns.
  */
 const Calendar = (props) => {
-    return (_jsx(_Fragment, { children: props.scope === "day" ? _jsx(CalendarForDay, Object.assign({}, props)) : _jsx(CalendarForWeek, Object.assign({}, props)) }));
+    return (_jsx(CalendarTaskContextProvider, { hashScope: "week", children: props.scope === "day" ? _jsx(CalendarForDay, Object.assign({}, props)) : _jsx(CalendarForWeek, Object.assign({}, props)) }));
 };
 export default Calendar;

package/dist/contexts/CalendarContext.js

@@ -1,12 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext } from "react";
-const CalendarContext = createContext({
-    groups: [],
-    weekOffset: 0,
-    date: new Date()
-});
-const CalendarContextProvider = ({ groups, weekOffset, children, date }) => {
-    return (_jsx(CalendarContext.Provider, { value: { groups, weekOffset, date }, children: children }));
+const CalendarContext = createContext({});
+const CalendarContextProvider = ({ children, }) => {
+    return (_jsx(CalendarContext.Provider, { value: {}, children: children }));
 };
 export const useCalendarContext = () => useContext(CalendarContext);
 export default CalendarContextProvider;

package/dist/contexts/CalendarTaskContext.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useCalendarTask } from "../hooks/useCalendarTask";
+const CalendarTaskContext = createContext({
+    tasks: { buckets: {}, dataLength: 0, taskCache: {} },
+    addTask: () => { },
+    getTasks: () => [],
+    updateTask: () => { },
+    deleteTask: () => { },
+    cleanExpiredTasks: () => { },
+    cleanExpiredTasksByHash: () => { },
+    isValidTask: () => false,
+    getTask: () => undefined,
+    hashScope: "week"
+});
+const CalendarTaskContextProvider = ({ children, hashScope }) => {
+    const { tasks, addTask, getTasks, updateTask, deleteTask, cleanExpiredTasks, cleanExpiredTasksByHash, isValidTask, getTask } = useCalendarTask(hashScope || "week");
+    return (_jsx(CalendarTaskContext.Provider, { value: {
+            tasks,
+            addTask,
+            getTasks,
+            updateTask,
+            deleteTask,
+            cleanExpiredTasks,
+            cleanExpiredTasksByHash,
+            isValidTask,
+            getTask,
+            hashScope
+        }, children: children }));
+};
+export const useCalendarTaskContext = () => useContext(CalendarTaskContext);
+export default CalendarTaskContextProvider;

package/dist/hooks/useCalendarDateState.js

@@ -1,11 +1,11 @@
 import { useEffect, useState } from "react";
-import { calculerEcartSemaine, getDateObjectInTimeZone, getDayHourly, getWeekDays, } from "../lib/utils";
+import { calculateWeekDifference, getDateObjectInTimeZone, getDayHourly, getWeekDays, } from "../lib/utils";
 function useCalendarDateState(date, weekOffset, timeZone) {
     const [calendarDateState, setCalendarDateState] = useState({ dailyHours: [], weekDays: [] });
     useEffect(() => {
         const weekOffsetByDate = timeZone
-            ? calculerEcartSemaine(getDateObjectInTimeZone(timeZone), timeZone)
-            : calculerEcartSemaine(date, timeZone);
+            ? calculateWeekDifference(getDateObjectInTimeZone(timeZone), timeZone)
+            : calculateWeekDifference(date, timeZone);
         const weekDays = getWeekDays(weekOffsetByDate || weekOffset || 0, timeZone);
         const dailyHours = getDayHourly(weekOffsetByDate || weekOffset || 0, timeZone);
         const calData = {

package/dist/hooks/useCalendarTask.js

@@ -0,0 +1,191 @@
+import { useEffect, useRef, useState, useMemo } from "react";
+import { getHash, updateOffsetWithDateCalendar } from "../lib/utils";
+const STORAGE_KEY = "calendar_tasks";
+export function useCalendarTask(hashScope, timeZone) {
+    const tasksRef = useRef({ buckets: {}, dataLength: 0, taskCache: {} });
+    const scheduleCleanRef = useRef(null);
+    const [render, forceRender] = useState(0);
+    const cleanExpiredTasks = () => {
+        const store = tasksRef.current;
+        let newDataLength = 0;
+        for (const hash in store.buckets) {
+            const bucket = store.buckets[hash];
+            const validTasks = bucket.list.filter(isValidTask);
+            newDataLength += validTasks.length;
+            if (validTasks.length === bucket.list.length)
+                continue;
+            const newIndexMap = {};
+            let sumOfTaskDuration = 0;
+            validTasks.forEach((task, index) => {
+                newIndexMap[task.id] = index;
+                sumOfTaskDuration += task.taskEnd - task.taskStart;
+            });
+            store.buckets[hash] = {
+                list: validTasks,
+                indexMap: newIndexMap,
+                sumOfTaskDuration,
+            };
+        }
+        store.dataLength = newDataLength;
+        saveToStorage();
+        forceRender((x) => x + 1);
+    };
+    const cleanExpiredTasksByHash = (hash) => {
+        const bucket = tasksRef.current.buckets[hash];
+        if (!bucket)
+            return;
+        const validTasks = bucket.list.filter(isValidTask);
+        if (validTasks.length === bucket.list.length)
+            return;
+        const removedCount = bucket.list.length - validTasks.length;
+        tasksRef.current.dataLength -= removedCount;
+        const newIndexMap = {};
+        let sumOfTaskDuration = 0;
+        validTasks.forEach((task, index) => {
+            newIndexMap[task.id] = index;
+            sumOfTaskDuration += task.taskEnd - task.taskStart;
+        });
+        tasksRef.current.buckets[hash] = {
+            list: validTasks,
+            indexMap: newIndexMap,
+            sumOfTaskDuration,
+        };
+        saveToStorage();
+        forceRender((x) => x + 1);
+    };
+    if (!scheduleCleanRef.current) {
+        scheduleCleanRef.current = (() => {
+            let timeout;
+            return () => {
+                clearTimeout(timeout);
+                timeout = setTimeout(() => {
+                    if ("requestIdleCallback" in window) {
+                        requestIdleCallback(() => {
+                            cleanExpiredTasks();
+                        });
+                    }
+                    else {
+                        setTimeout(() => cleanExpiredTasks(), 0);
+                    }
+                }, 2000);
+            };
+        })();
+    }
+    const scheduleClean = scheduleCleanRef.current;
+    const getNow = () => {
+        const now = new Date();
+        if (timeZone) {
+            return new Date(now.toLocaleString("en-US", { timeZone }));
+        }
+        return now;
+    };
+    const isValidTask = (task) => {
+        if (!task.taskExpiryDate)
+            return false;
+        return new Date(task.taskExpiryDate) > getNow();
+    };
+    // 💾 SAVE → O(1)
+    const saveToStorage = () => {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(tasksRef.current));
+    };
+    // 📦 LOAD (sans clean)
+    useEffect(() => {
+        const stored = localStorage.getItem(STORAGE_KEY);
+        if (!stored)
+            return;
+        tasksRef.current = JSON.parse(stored);
+        forceRender((x) => x + 1);
+    }, []);
+    // ➕ ADD → O(1)
+    const addTask = (task) => {
+        const offset = updateOffsetWithDateCalendar(task.taskDate);
+        const hash = getHash(offset, task.groupId, task.dayIndex)[hashScope];
+        if (!tasksRef.current.buckets[hash]) {
+            tasksRef.current.buckets[hash] = {
+                list: [],
+                indexMap: {},
+                sumOfTaskDuration: 0,
+            };
+        }
+        const bucket = tasksRef.current.buckets[hash];
+        const index = bucket.list.length;
+        bucket.list.push(Object.assign(Object.assign({}, task), { hash }));
+        bucket.indexMap[task.id] = index;
+        bucket.sumOfTaskDuration += task.taskEnd - task.taskStart;
+        tasksRef.current.dataLength++;
+        saveToStorage();
+        scheduleClean();
+        forceRender((x) => x + 1);
+    };
+    const getTasks = (hash) => {
+        const bucket = tasksRef.current.buckets[hash];
+        if (!bucket)
+            return [];
+        return bucket.list;
+    };
+    const getTask = (hash, taskId) => {
+        const bucket = tasksRef.current.buckets[hash];
+        if (!bucket)
+            return;
+        const index = bucket.indexMap[taskId];
+        if (index === undefined)
+            return;
+        return bucket.list[index];
+    };
+    // ✏️ UPDATE → O(1)
+    const updateTask = (hash, taskId, updatedTask) => {
+        const bucket = tasksRef.current.buckets[hash];
+        if (!bucket)
+            return;
+        const index = bucket.indexMap[taskId];
+        if (index === undefined)
+            return;
+        const oldTAskDuration = bucket.list[index].taskEnd - bucket.list[index].taskStart;
+        if (updatedTask.taskEnd && updatedTask.taskStart) {
+            const newTAskDuration = updatedTask.taskEnd - updatedTask.taskStart;
+            if (newTAskDuration !== oldTAskDuration) {
+                bucket.sumOfTaskDuration = bucket.sumOfTaskDuration - oldTAskDuration + newTAskDuration;
+            }
+        }
+        bucket.list[index] = Object.assign(Object.assign({}, bucket.list[index]), updatedTask);
+        saveToStorage();
+        scheduleClean();
+        forceRender((x) => x + 1);
+    };
+    // ❌ DELETE → O(1)
+    const deleteTask = (hash, taskId) => {
+        const bucket = tasksRef.current.buckets[hash];
+        if (!bucket)
+            return;
+        const index = bucket.indexMap[taskId];
+        if (index === undefined)
+            return;
+        const lastIndex = bucket.list.length - 1;
+        const lastTask = bucket.list[lastIndex];
+        const oldTAskDuration = bucket.list[index].taskEnd - bucket.list[index].taskStart;
+        [bucket.list[index], bucket.list[lastIndex]] = [
+            bucket.list[lastIndex],
+            bucket.list[index],
+        ];
+        bucket.indexMap[lastTask.id] = index;
+        bucket.list.pop();
+        delete bucket.indexMap[taskId];
+        bucket.sumOfTaskDuration -= oldTAskDuration;
+        tasksRef.current.dataLength--;
+        saveToStorage();
+        scheduleClean();
+        forceRender((x) => x + 1);
+    };
+    const tasks = useMemo(() => (Object.assign({}, tasksRef.current)), [render]);
+    return {
+        tasks,
+        addTask,
+        getTasks,
+        updateTask,
+        deleteTask,
+        cleanExpiredTasks,
+        cleanExpiredTasksByHash,
+        isValidTask,
+        getTask
+    };
+}

package/dist/hooks/useContainerScroll.js

@@ -0,0 +1,14 @@
+import { useState, useEffect } from "react";
+export function useContainerScroll(mainContaierRef, cardHeight, gridGap) {
+    const [sliceIndex, setSliceIndex] = useState(0);
+    useEffect(() => {
+        const mainContainer = mainContaierRef.current;
+        const handleScroll = () => {
+            const computeIndex = Math.floor(mainContainer.scrollTop / (cardHeight + gridGap));
+            setSliceIndex(computeIndex);
+        };
+        mainContainer.addEventListener("scroll", handleScroll);
+        return () => mainContainer.removeEventListener("scroll", handleScroll);
+    }, [cardHeight, gridGap]);
+    return { sliceIndex };
+}

package/dist/hooks/useData.js

@@ -0,0 +1,7 @@
+import { useMemo } from "react";
+export const useData = (sliceIndex, itemsByLine, windowLines, tasks, bottomBufferSize, topBufferSize) => {
+    console.log(sliceIndex, itemsByLine, windowLines, tasks, "virtual");
+    const visibleTasks = useMemo(() => tasks.slice(Math.max(sliceIndex - topBufferSize, 0) * itemsByLine, Math.min(tasks.length, (windowLines + bottomBufferSize) * itemsByLine +
+        sliceIndex * itemsByLine)), [sliceIndex, itemsByLine, windowLines, tasks]);
+    return { visibleTasks };
+};

package/dist/hooks/useGridContainer.js

@@ -0,0 +1,24 @@
+import { useEffect, useRef, useState } from "react";
+import { useWindowSize } from "./useWindowsSize";
+export const useGridContainer = (gridContaineRef) => {
+    const [cardCompH, setCardCompH] = useState(0);
+    const [itemsByLine, setItemsByLines] = useState(1);
+    const cardRef = useRef(undefined);
+    const { width } = useWindowSize();
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        //si le parent n'a aucun enfant on sort
+        if (gridContaineRef.current.hasChildNodes() === false)
+            return;
+        //la hauteur du premier enfant de la grid
+        const cardH = gridContaineRef.current.firstChild.clientHeight;
+        if (cardH !== cardCompH) {
+            const gridW = gridContaineRef.current.clientWidth;
+            const cardW = gridContaineRef.current.firstChild.clientWidth;
+            setCardCompH(cardH);
+            setItemsByLines(Math.floor(gridW / cardW));
+        }
+    }, [width]);
+    return { cardCompH, cardRef, itemsByLine };
+};

package/dist/hooks/useIntersectionObserver.js

@@ -0,0 +1,19 @@
+import { useEffect, useState } from "react";
+export function useIntersectionObserver(elementRef, { threshold = 0, root = null, rootMargin = "0%", freezeOnceVisible = false, } = {}) {
+    const [entry, setEntry] = useState();
+    const frozen = (entry === null || entry === void 0 ? void 0 : entry.isIntersecting) && freezeOnceVisible;
+    const updateEntry = ([entry]) => {
+        setEntry(entry);
+    };
+    useEffect(() => {
+        const node = elementRef === null || elementRef === void 0 ? void 0 : elementRef.current; // DOM node
+        const hasIOSupport = !!window.IntersectionObserver;
+        if (!hasIOSupport || frozen || !node)
+            return;
+        const observerParams = { threshold, root, rootMargin };
+        const observer = new IntersectionObserver(updateEntry, observerParams);
+        observer.observe(node);
+        return () => observer.disconnect();
+    }, [elementRef, JSON.stringify(threshold), root, rootMargin, frozen]);
+    return entry;
+}

package/dist/hooks/useMainContainerItemContent.js

@@ -0,0 +1,16 @@
+import { useEffect, useState } from "react";
+export function useMainContainerContent(mainContaierRef, cardCompH) {
+    const [windowLines, setWindowLine] = useState(0);
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        if (cardCompH === 0)
+            return;
+        const windowContent = Math.ceil(mainContaierRef.current.clientHeight / cardCompH);
+        if (windowContent !== windowLines)
+            setWindowLine(windowContent);
+    }, [cardCompH]);
+    //le nombre de lignes que peut contenir la fenetre
+    return { windowLines };
+}
+export default useMainContainerContent;

package/dist/hooks/useWindowsSize.js

@@ -0,0 +1,19 @@
+import { useState, useEffect } from 'react';
+export function useWindowSize() {
+    const [windowSize, setWindowSize] = useState({
+        width: window.innerWidth,
+        height: window.innerHeight,
+    });
+    useEffect(() => {
+        function handleResize() {
+            setWindowSize({
+                width: window.innerWidth,
+                height: window.innerHeight,
+            });
+        }
+        window.addEventListener('resize', handleResize);
+        return () => window.removeEventListener('resize', handleResize);
+    }, []);
+    return windowSize;
+}
+// Utilisation dans un composant

package/dist/index.js

@@ -4,4 +4,16 @@ export { default as Calendar } from './components/index';
 // 2. Tu exportes tout le contenu de ton fichier utils
 export * from './lib/utils';
 export * from './definitions/index';
-// OU exportes des éléments spécifiques : export { formatTime, generateSlots } from './utils';
+export * from './hooks/useCalendarTask';
+export * from './contexts/CalendarTaskContext';
+export * from './components/TaskContainer/';
+export * from './components/TaskContainer/TaskVirtual';
+export * from './components/AddTask';
+export * from './components/SumHoursContainer';
+export * from './components/SumHoursHead';
+export * from './components/GroupContainer';
+export * from './components/VirtualGroupRow';
+export * from './components/VirtualGroupRowDay';
+export * from './components/DayContainer';
+export * from './hooks/useCalendarDateState';
+export * from './contexts/CalendarTaskContext';