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

package/src/utils/useStopwatch.test.tsx

@@ -1,311 +0,0 @@
-/*
- * Copyright (c) 2015 Nordic Semiconductor ASA
- *
- * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
- */
-
-import React from 'react';
-import { act, render } from '@testing-library/react';
-
-import useStopWatch, { ITimer, Stopwatch } from './useStopwatch';
-
-let appCallback = () => {};
-
-const setup = (stopwatch: Stopwatch) => {
-    const returnVal = {};
-    const TestComponent = () => {
-        Object.assign(returnVal, useStopWatch(stopwatch));
-        return null;
-    };
-    render(<TestComponent />);
-    return returnVal as ReturnType<typeof useStopWatch>;
-};
-
-describe('Stop Watch', () => {
-    const mockNow = jest.fn(() => 0);
-    const mockSetTimeout = jest.fn((callback: () => void) => {
-        appCallback = callback;
-        return () => {};
-    });
-
-    const timerMock: ITimer = {
-        now: mockNow,
-        setTimeout: mockSetTimeout,
-    };
-
-    const expectZeroElapsedTime = (
-        stopwatch: ReturnType<typeof useStopWatch>
-    ) => {
-        expect(stopwatch.time).toBe(0);
-        expect(stopwatch.seconds).toBe(0);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-    };
-
-    beforeEach(() => {
-        mockNow.mockReturnValue(0);
-        jest.clearAllMocks();
-    });
-
-    test('Auto Start will init timer', () => {
-        const { isRunning } = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(1);
-        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
-        expect(isRunning).toBeTruthy();
-    });
-
-    test('Pause will stop the stopwatch and report elapsed time', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(1);
-        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
-        expect(stopwatch.isRunning).toBeTruthy();
-
-        expectZeroElapsedTime(stopwatch);
-
-        mockNow.mockReturnValue(433);
-
-        act(() => {
-            stopwatch.pause();
-            stopwatch;
-        });
-
-        expect(stopwatch.time).toBe(433);
-        expect(stopwatch.seconds).toBe(0);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-        expect(stopwatch.isRunning).toBeFalsy();
-    });
-
-    test('Start a paused timer will continue timer', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(1);
-        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
-        expect(stopwatch.isRunning).toBeTruthy();
-
-        expectZeroElapsedTime(stopwatch);
-
-        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
-
-        mockNow.mockReturnValue(500);
-
-        act(() => {
-            stopwatch.pause();
-            stopwatch;
-        });
-
-        expect(stopwatch.time).toBe(500);
-        expect(stopwatch.seconds).toBe(0);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-        expect(stopwatch.isRunning).toBeFalsy();
-
-        mockNow.mockReturnValue(5000);
-
-        act(() => {
-            stopwatch.start();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(2);
-        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 500);
-    });
-
-    test('Timer will not automatically start', () => {
-        const { isRunning } = setup({
-            autoStart: false,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(0);
-        expect(isRunning).toBeFalsy();
-    });
-
-    test('Start call will start the timer', () => {
-        const stopwatch = setup({
-            autoStart: false,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(0);
-        expect(stopwatch.isRunning).toBeFalsy();
-
-        mockNow.mockReturnValue(5000);
-
-        act(() => {
-            stopwatch.start();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(1);
-        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
-        expect(stopwatch.isRunning).toBeTruthy();
-    });
-
-    test('Reset will reset all time the stopwatch and report elapsed time', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(1);
-        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
-        expect(stopwatch.isRunning).toBeTruthy();
-
-        expectZeroElapsedTime(stopwatch);
-
-        mockNow.mockReturnValue(1200);
-
-        act(() => {
-            appCallback();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 800);
-
-        expect(stopwatch.time).toBe(1200);
-        expect(stopwatch.seconds).toBe(1);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-        expect(stopwatch.isRunning).toBeTruthy();
-
-        mockNow.mockReturnValue(6800);
-        act(() => {
-            stopwatch.reset();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).nthCalledWith(3, expect.anything(), 1000);
-
-        expectZeroElapsedTime(stopwatch);
-        expect(stopwatch.isRunning).toBeTruthy();
-    });
-
-    test('Time will update output after precise interval elapsed trigger a new timeout', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expectZeroElapsedTime(stopwatch);
-
-        // trigger timeout with precise time elapsed
-        mockNow.mockReturnValue(1000);
-
-        act(() => {
-            appCallback();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(2);
-        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
-
-        expect(stopwatch.time).toBe(1000);
-        expect(stopwatch.seconds).toBe(1);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-    });
-
-    test('Time will update trigger a new timeout and add positive correction', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expectZeroElapsedTime(stopwatch);
-
-        // trigger timeout with error of -200ms
-        mockNow.mockReturnValue(800);
-
-        act(() => {
-            appCallback();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(2);
-        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
-        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 200);
-
-        expect(stopwatch.time).toBe(800);
-        expect(stopwatch.seconds).toBe(0);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-    });
-
-    test('Time will update trigger a new timeout and add negative correction', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expectZeroElapsedTime(stopwatch);
-
-        // trigger timeout with error of +200ms
-        mockNow.mockReturnValue(1200);
-
-        act(() => {
-            appCallback();
-            stopwatch;
-        });
-
-        expect(timerMock.setTimeout).toBeCalledTimes(2);
-        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
-        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 800);
-
-        expect(stopwatch.time).toBe(1200);
-        expect(stopwatch.seconds).toBe(1);
-        expect(stopwatch.minutes).toBe(0);
-        expect(stopwatch.hours).toBe(0);
-        expect(stopwatch.days).toBe(0);
-    });
-
-    test('Test time part splitting', () => {
-        const stopwatch = setup({
-            autoStart: true,
-            resolution: 1000,
-            timer: timerMock,
-        });
-
-        expectZeroElapsedTime(stopwatch);
-
-        // 2days 1hr 1 min 3 seconds 500ms
-        mockNow.mockReturnValue(176588500);
-
-        act(() => {
-            appCallback();
-            stopwatch;
-        });
-
-        expect(stopwatch.time).toBe(176588500);
-        expect(stopwatch.seconds).toBe(8);
-        expect(stopwatch.minutes).toBe(3);
-        expect(stopwatch.hours).toBe(1);
-        expect(stopwatch.days).toBe(2);
-    });
-});

package/src/utils/useStopwatch.ts

@@ -1,140 +0,0 @@
-/*
- * 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,
-    };
-};