react-weekly-planning 1.0.39 → 1.0.40

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

@@ -0,0 +1,19 @@
+// src/index.ts
+// 1. Tu exportes ton composant principal
+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';
+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';

package/dist/lib/slyles.js

@@ -0,0 +1,21 @@
+export const theadTrStyle = {
+    color: "#0f5173",
+    fontWeight: "300",
+    position: "sticky",
+    top: -1,
+};
+export const groupTdStyle = {
+    height: "auto",
+    width: "150px",
+};
+export const groupContainerStyle = {
+    width: "100%",
+    height: "100%",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: "0.75rem", // Correspond à gap-3
+    padding: "0.75rem", // Correspond à p-3
+    color: "#0f5173",
+    cursor: "pointer",
+};