allaw-ui 2.5.2 → 2.5.4

package/dist/components/atoms/inputs/VerificationCodeInput.d.ts

@@ -8,6 +8,7 @@ export interface VerificationCodeInputProps {
     onComplete?: (value: string) => void;
     testError?: boolean;
     autoFocus?: boolean;
+    isDisabled?: boolean;
 }
 declare const VerificationCodeInput: React.FC<VerificationCodeInputProps>;
 export default VerificationCodeInput;

package/dist/components/atoms/inputs/VerificationCodeInput.js

@@ -11,9 +11,9 @@ import React, { useState, useEffect, useRef } from "react";
 import styles from "./VerificationCodeInput.module.css";
 import TinyInfo from "../typography/TinyInfo";
 var VerificationCodeInput = function (_a) {
-    var numInputs = _a.numInputs, _b = _a.allowedChars, allowedChars = _b === void 0 ? "numeric" : _b, _c = _a.size, size = _c === void 0 ? "large" : _c, onChange = _a.onChange, onError = _a.onError, onComplete = _a.onComplete, _d = _a.testError, testError = _d === void 0 ? false : _d, _e = _a.autoFocus, autoFocus = _e === void 0 ? false : _e;
-    var _f = useState(Array(numInputs).fill("")), values = _f[0], setValues = _f[1];
-    var _g = useState(""), error = _g[0], setError = _g[1];
+    var numInputs = _a.numInputs, _b = _a.allowedChars, allowedChars = _b === void 0 ? "numeric" : _b, _c = _a.size, size = _c === void 0 ? "large" : _c, onChange = _a.onChange, onError = _a.onError, onComplete = _a.onComplete, _d = _a.testError, testError = _d === void 0 ? false : _d, _e = _a.autoFocus, autoFocus = _e === void 0 ? false : _e, _f = _a.isDisabled, isDisabled = _f === void 0 ? false : _f;
+    var _g = useState(Array(numInputs).fill("")), values = _g[0], setValues = _g[1];
+    var _h = useState(""), error = _h[0], setError = _h[1];
     var inputRefs = useRef(Array(numInputs).fill(null));
     useEffect(function () {
         setValues(Array(numInputs).fill(""));
@@ -134,7 +134,7 @@ var VerificationCodeInput = function (_a) {
                     ? "[a-zA-Z]*"
                     : "[a-zA-Z0-9]*", ref: function (input) { return (inputRefs.current[index] = input); }, autoFocus: index === 0 && autoFocus, tabIndex: index === 0 ? 0 : undefined, "data-lpignore": "true" // Empêche Dashlane d'intervenir
             , "data-form-type": "other" // Indique que ce n'est pas un champ de mot de passe
-         })); });
+            , disabled: isDisabled })); });
     };
     return (React.createElement("div", { className: styles.container },
         React.createElement("div", { className: styles.inputsContainer }, renderInputs()),

package/dist/components/molecules/billingCount/BillingCount.d.ts

@@ -6,5 +6,5 @@ export type BillingCountProps = {
     resetTimer?: boolean;
     pauseTimer?: boolean;
 };
-declare const BillingCount: ({ onEnd, setIsStarted, pauseTimer, resetTimer, }: BillingCountProps) => React.JSX.Element;
+declare const BillingCount: ({ onEnd, setIsStarted, resetTimer, pauseTimer, }: BillingCountProps) => React.JSX.Element;
 export default BillingCount;

package/dist/components/molecules/billingCount/BillingCount.js

@@ -2,145 +2,145 @@ import React, { useEffect, useState, useRef } from "react";
 import "./BillingCount.css";
 var LOCAL_STORAGE_KEYS = {
     START_TIME: "startTimeBilling",
-    ELAPSED_TIME: "elapsedTime",
+    ACCUMULATED_TIME: "accumulatedTime",
     IS_RUNNING: "isRunning",
 };
 var BillingCount = function (_a) {
-    var onEnd = _a.onEnd, setIsStarted = _a.setIsStarted, pauseTimer = _a.pauseTimer, resetTimer = _a.resetTimer;
-    var _b = useState(0), time = _b[0], setTime = _b[1];
-    var _c = useState(false), isPaused = _c[0], setIsPaused = _c[1];
-    var _d = useState(false), isRunning = _d[0], setIsRunning = _d[1];
-    var _e = useState(false), isInitialized = _e[0], setIsInitialized = _e[1];
+    var onEnd = _a.onEnd, setIsStarted = _a.setIsStarted, resetTimer = _a.resetTimer, pauseTimer = _a.pauseTimer;
+    var _b = useState(0), elapsedSeconds = _b[0], setElapsedSeconds = _b[1];
+    var _c = useState(false), isRunning = _c[0], setIsRunning = _c[1];
     var intervalRef = useRef(null);
+    // --- Au premier render, on relit le localStorage
     useEffect(function () {
-        setIsInitialized(true);
-    }, []);
-    useEffect(function () {
-        setTime(getSavedElapsedTime());
-    }, []);
-    useEffect(function () {
-        if (!isInitialized)
-            return;
-        if (resetTimer)
-            setTime(0);
-        setIsPaused(false);
-        setIsRunning(false);
-        clearTimerData();
-        if (intervalRef.current) {
-            clearInterval(intervalRef.current);
+        var savedAccumulated = getAccumulatedTime(); // secondes
+        var savedIsRunning = localStorage.getItem(LOCAL_STORAGE_KEYS.IS_RUNNING) === "true";
+        var savedStartTime = getStartTime(); // en ms ou 0
+        if (savedAccumulated) {
+            setElapsedSeconds(savedAccumulated);
         }
-        else if (pauseTimer) {
-            pauseTimerHandler();
+        if (savedIsRunning && savedStartTime > 0) {
+            setIsRunning(true);
+            setIsStarted && setIsStarted(true);
         }
-        else if (!pauseTimer && !isRunning && isPaused) {
-            startTimerHandler();
+        else {
+            setIsRunning(false);
+            setIsStarted && setIsStarted(false);
         }
-    }, [resetTimer]);
+    }, [setIsStarted]);
+    // --- Gère l'interval pour mettre à jour l'affichage
     useEffect(function () {
-        if (isRunning && !isPaused) {
-            intervalRef.current = setInterval(function () {
-                setTime(function (prevTime) {
-                    var newElapsedTime = prevTime + 1;
-                    updateElapsedTime(newElapsedTime);
-                    return newElapsedTime;
-                });
+        if (isRunning) {
+            // Créé un interval toutes les 1000ms
+            intervalRef.current = window.setInterval(function () {
+                var newElapsed = computeElapsedTime(); // on recalcule via Date.now()
+                setElapsedSeconds(newElapsed);
             }, 1000);
         }
         else if (intervalRef.current) {
+            // On stoppe l'interval
             clearInterval(intervalRef.current);
             intervalRef.current = null;
         }
+        // Cleanup si le composant se démonte
         return function () {
             if (intervalRef.current)
                 clearInterval(intervalRef.current);
         };
-    }, [isRunning, isPaused]);
+    }, [isRunning]);
+    // --- Sur changement de resetTimer/pauseTimer
+    //     on applique la logique de reset, de pause ou de start
     useEffect(function () {
-        if (!isInitialized)
-            return;
         if (resetTimer) {
-            pauseTimerHandler();
-        }
-        else if (!pauseTimer && !resetTimer) {
-            startTimerHandler();
+            resetTimerHandler();
         }
         else if (pauseTimer) {
             pauseTimerHandler();
         }
-    }, [pauseTimer, resetTimer]);
-    // Gestion de reprise de chrono en cas de refresh de page
-    useEffect(function () {
-        var savedElapsedTime = getSavedElapsedTime();
-        var savedIsRunning = localStorage.getItem(LOCAL_STORAGE_KEYS.IS_RUNNING) === "true";
-        setTime(savedElapsedTime);
-        if (savedIsRunning && savedElapsedTime > 0) {
-            setIsRunning(true);
-            setIsStarted && setIsStarted(true);
-        }
-        else {
-            setIsRunning(false);
-            setIsStarted && setIsStarted(false);
-        }
-    }, [setIsStarted]);
-    // Mise a jour du temps de session
-    var updateElapsedTime = function (elapsedTime) {
-        localStorage.setItem(LOCAL_STORAGE_KEYS.ELAPSED_TIME, elapsedTime.toString());
-    };
-    // Cleanup du localStorage après un reset de session de travail
-    var clearTimerData = function () {
-        localStorage.removeItem(LOCAL_STORAGE_KEYS.START_TIME);
-        localStorage.removeItem(LOCAL_STORAGE_KEYS.ELAPSED_TIME);
-        localStorage.removeItem(LOCAL_STORAGE_KEYS.IS_RUNNING);
-    };
-    var getSavedElapsedTime = function () {
-        return parseInt(localStorage.getItem(LOCAL_STORAGE_KEYS.ELAPSED_TIME) || "0", 10);
-    };
-    var getCurrentElapsedTime = function () {
-        var savedStartTime = localStorage.getItem(LOCAL_STORAGE_KEYS.START_TIME);
-        if (savedStartTime) {
-            return getSavedElapsedTime();
+        else if (!pauseTimer && !resetTimer) {
+            startTimerHandler();
         }
-        return getSavedElapsedTime();
+    }, [resetTimer, pauseTimer]);
+    // --- Fonctions utilitaires ---
+    // Calcule la différence en s'appuyant sur:
+    //   accumulatedTime (secondes) + (Date.now() - startTime) / 1000
+    var computeElapsedTime = function () {
+        var savedStartTime = getStartTime();
+        var savedAccumulated = getAccumulatedTime();
+        if (!savedStartTime)
+            return savedAccumulated;
+        var now = Date.now();
+        var diffSeconds = Math.floor((now - savedStartTime) / 1000);
+        return savedAccumulated + diffSeconds;
     };
+    // On lance ou relance le chrono
     var startTimerHandler = function () {
-        if (!isRunning) {
-            localStorage.setItem(LOCAL_STORAGE_KEYS.START_TIME, new Date().toISOString());
+        var isRunningFlag = localStorage.getItem(LOCAL_STORAGE_KEYS.IS_RUNNING) === "true";
+        if (!isRunningFlag) {
+            // On enregistre le moment précis du démarrage (ms)
+            localStorage.setItem(LOCAL_STORAGE_KEYS.START_TIME, Date.now().toString());
             localStorage.setItem(LOCAL_STORAGE_KEYS.IS_RUNNING, "true");
-            setTime(getSavedElapsedTime());
             setIsRunning(true);
             setIsStarted && setIsStarted(true);
         }
     };
+    // On met le chrono en pause
     var pauseTimerHandler = function () {
-        if (isRunning) {
-            var elapsed = getCurrentElapsedTime();
-            updateElapsedTime(elapsed);
+        var currentlyRunning = localStorage.getItem(LOCAL_STORAGE_KEYS.IS_RUNNING) === "true";
+        if (currentlyRunning) {
+            // On calcule le temps total vraiment écoulé
+            var newElapsed = computeElapsedTime();
+            // On met à jour l'accumulatedTime en localStorage
+            localStorage.setItem(LOCAL_STORAGE_KEYS.ACCUMULATED_TIME, newElapsed.toString());
+            // On arrête
             localStorage.setItem(LOCAL_STORAGE_KEYS.IS_RUNNING, "false");
-            setTime(elapsed);
+            localStorage.removeItem(LOCAL_STORAGE_KEYS.START_TIME);
+            setElapsedSeconds(newElapsed);
             setIsRunning(false);
             setIsStarted && setIsStarted(false);
+            onEnd(newElapsed); // si on veut déclencher l'événement "onEnd"
         }
     };
+    // On remet tout à zéro
+    var resetTimerHandler = function () {
+        clearTimerData();
+        setElapsedSeconds(0);
+        setIsRunning(false);
+        setIsStarted && setIsStarted(false);
+    };
     var handleButtonClick = function () {
-        if (!isRunning) {
-            startTimerHandler();
+        if (isRunning) {
+            pauseTimerHandler();
         }
         else {
-            pauseTimerHandler();
-            onEnd(getCurrentElapsedTime());
+            startTimerHandler();
         }
     };
-    var formatTime = function (seconds) {
-        var hrs = Math.floor(seconds / 3600);
-        var mins = Math.floor((seconds % 3600) / 60);
-        var secs = seconds % 60;
+    // --- Lecture / écriture localStorage ---
+    var getStartTime = function () {
+        var val = localStorage.getItem(LOCAL_STORAGE_KEYS.START_TIME);
+        return val ? parseInt(val, 10) : 0;
+    };
+    var getAccumulatedTime = function () {
+        var val = localStorage.getItem(LOCAL_STORAGE_KEYS.ACCUMULATED_TIME);
+        return val ? parseInt(val, 10) : 0;
+    };
+    var clearTimerData = function () {
+        localStorage.removeItem(LOCAL_STORAGE_KEYS.START_TIME);
+        localStorage.removeItem(LOCAL_STORAGE_KEYS.ACCUMULATED_TIME);
+        localStorage.removeItem(LOCAL_STORAGE_KEYS.IS_RUNNING);
+    };
+    // --- Format d'affichage
+    var formatTime = function (totalSeconds) {
+        var hrs = Math.floor(totalSeconds / 3600);
+        var mins = Math.floor((totalSeconds % 3600) / 60);
+        var secs = totalSeconds % 60;
         return "".concat(hrs.toString().padStart(2, "0"), ":").concat(mins
             .toString()
             .padStart(2, "0"), ":").concat(secs.toString().padStart(2, "0"));
     };
     return (React.createElement("button", { onClick: handleButtonClick, className: "billing-button-wrapper ".concat(isRunning ? "isRunning" : "") },
         React.createElement("i", { className: "allaw-icon-clock" }),
-        React.createElement("span", { className: "billing-time" }, formatTime(time)),
+        React.createElement("span", { className: "billing-time" }, formatTime(elapsedSeconds)),
         React.createElement("i", { className: isRunning ? "allaw-icon-pause" : "allaw-icon-play", style: { fontSize: "12px", color: "#25BEEB", fontWeight: 800 } })));
 };
 export default BillingCount;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allaw-ui",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "Composants UI pour l'application Allaw",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",