@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre2 → 78.0.0

package/src/utils/useStopwatch.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+export interface ITimer {
+    now: () => number;
+    setTimeout: (callback: () => void, ms: number) => () => void;
+}
+
+export type Stopwatch = {
+    autoStart: boolean;
+    resolution?: number;
+    timer?: ITimer;
+};
+
+const defaultTimer: ITimer = {
+    now: () => Date.now(),
+    setTimeout: (callback: () => void, ms: number) => {
+        const t = setTimeout(callback, ms);
+        return () => clearTimeout(t);
+    },
+};
+
+const splitMS = (ms: number) => {
+    const time = ms;
+    const days = Math.floor(ms / (24 * 60 * 60 * 1000));
+    ms -= days * 24 * 60 * 60 * 1000;
+
+    const hours = Math.floor(ms / (60 * 60 * 1000));
+    ms -= hours * 60 * 60 * 1000;
+
+    const minutes = Math.floor(ms / (60 * 1000));
+    ms -= minutes * 60 * 1000;
+
+    const seconds = Math.floor(ms / 1000);
+    const millisecond = ms - seconds * 60 * 1000;
+
+    return {
+        time,
+        days,
+        hours,
+        minutes,
+        seconds,
+        millisecond,
+    };
+};
+
+export default ({
+    autoStart = false,
+    timer = defaultTimer,
+    resolution = 1000,
+}: Stopwatch) => {
+    const previousTickTime = useRef(timer.now());
+    const expectedTickTime = useRef(-1);
+    const autoStarted = useRef(false);
+    const pauseTimeout = useRef<(() => void) | null>(null);
+    const [isRunning, setIsRunning] = useState(false);
+    const [time, setTime] = useState(0);
+
+    const nextTick = useCallback(
+        (elapsedTime: number) => {
+            expectedTickTime.current =
+                previousTickTime.current +
+                (resolution - (elapsedTime % resolution));
+
+            const nextInterval = expectedTickTime.current - timer.now();
+
+            const handler = (delta: number, shouldContinue = true) => {
+                setTime(elapsedTime + delta);
+                previousTickTime.current = timer.now();
+                if (shouldContinue)
+                    pauseTimeout.current = nextTick(elapsedTime + delta);
+            };
+
+            const release = timer.setTimeout(() => {
+                handler(timer.now() - previousTickTime.current);
+            }, nextInterval);
+
+            return () => {
+                handler(timer.now() - previousTickTime.current, false);
+                release();
+            };
+        },
+        [resolution, timer]
+    );
+
+    const start = useCallback(
+        (elapsedTime = time) => {
+            if (pauseTimeout.current === null) {
+                previousTickTime.current = timer.now();
+                expectedTickTime.current =
+                    timer.now() + (resolution - (elapsedTime % resolution));
+                setIsRunning(true);
+                pauseTimeout.current = nextTick(elapsedTime);
+            }
+        },
+        [nextTick, resolution, time, timer]
+    );
+
+    const pause = useCallback(() => {
+        setIsRunning(false);
+        if (pauseTimeout.current) {
+            pauseTimeout.current();
+            pauseTimeout.current = null;
+        }
+    }, []);
+
+    const reset = useCallback(() => {
+        pause();
+        setTime(0);
+        start(0);
+    }, [pause, start]);
+
+    useEffect(
+        () => () => {
+            if (pauseTimeout.current) {
+                pauseTimeout.current();
+                pauseTimeout.current = null;
+            }
+        },
+        []
+    );
+
+    if (autoStart && !autoStarted.current) {
+        autoStarted.current = true;
+        start(0);
+    }
+
+    return {
+        ...splitMS(time),
+        start,
+        pause,
+        reset,
+        isRunning,
+    };
+};