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

package/src/utils/usageData.ts

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2105 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+import type Systeminformation from 'systeminformation';
+
+import type { PackageJson } from '../../ipc/MetaFiles';
+import logger from '../logging';
+import { isDevelopment } from './environment';
+import {
+    deleteIsSendingUsageData,
+    getIsSendingUsageData,
+    getUsageDataClientId,
+    persistIsSendingUsageData,
+} from './persistentStore';
+
+const instrumentationKey = '4b8b1a39-37c7-479e-a684-d4763c7c647c';
+
+interface EventAction {
+    action: string;
+    label?: string;
+}
+
+let eventQueue: EventAction[] = [];
+let insights: ApplicationInsights | undefined;
+
+/**
+ * Initialize instance to send user data
+ * @param {*} packageJson the app's package json
+ *
+ * @returns {Promise<void>} void
+ */
+export const init = (packageJson: PackageJson) => {
+    const applicationName = isDevelopment
+        ? `${packageJson.name}-dev`
+        : packageJson.name;
+    const applicationVersion = packageJson.version;
+
+    if (!getIsSendingUsageData()) return;
+
+    const accountId = getUsageDataClientId();
+
+    insights = new ApplicationInsights({
+        config: {
+            instrumentationKey,
+            accountId,
+        },
+    });
+
+    insights.loadAppInsights();
+    insights.trackPageView({ name: applicationName });
+
+    // Add app name and version to every event
+    insights.addTelemetryInitializer(envelope => {
+        const trace = {
+            ...(envelope.ext?.trace ?? {}),
+            name: applicationName,
+        };
+        envelope.ext = { ...envelope.ext, trace };
+        envelope.data = {
+            ...envelope.data,
+            applicationName,
+            applicationVersion,
+        };
+    });
+
+    logger.debug(
+        `Application Insights for category ${applicationName} has initialized`
+    );
+
+    // Add 5 second delay to prevent inital rendering from beeing frozen.
+    setTimeout(async () => {
+        // eslint-disable-next-line global-require
+        const si = require('systeminformation') as typeof Systeminformation;
+        sendUsageData('architecture', (await si.osInfo()).arch);
+    }, 5_000);
+};
+
+/**
+ * Checks if usage report instance is initialized and ready to be sent
+ *
+ * @returns {Boolean} returns whether the setting is on, off or undefined
+ */
+export const isInitialized = () => {
+    logger.debug(
+        `Usage report instance is${
+            insights !== undefined ? '' : ' not'
+        } initialized`
+    );
+    return insights !== undefined;
+};
+
+/**
+ * Check the status of usage data
+ *
+ * @returns {Boolean | undefined} returns whether the setting is on, off or undefined
+ */
+export const isEnabled = () => {
+    const isSendingUsageData = getIsSendingUsageData();
+    logger.debug(`Usage data is ${isSendingUsageData}`);
+    return isSendingUsageData;
+};
+
+/**
+ * Enable sending usage data
+ *
+ * @returns {void}
+ */
+export const enable = () => {
+    persistIsSendingUsageData(true);
+    logger.debug('Usage data has been enabled');
+};
+
+/**
+ * Disable sending usage data
+ *
+ * @returns {void}
+ */
+export const disable = () => {
+    persistIsSendingUsageData(false);
+    logger.debug('Usage data has been disabled');
+};
+
+/**
+ * Reset settings so that launcher is able to
+ * ask the user to enable or disable sending usage data
+ *
+ * @returns {void}
+ */
+export const reset = () => {
+    deleteIsSendingUsageData();
+    logger.debug('Usage data setting has been reset');
+};
+
+/**
+ * Send event
+ * @param {EventAction} event the event to send
+ *
+ * @returns {void}
+ */
+const sendEvent = ({ action, label }: EventAction) => {
+    const isSendingUsageData = getIsSendingUsageData();
+
+    if (isSendingUsageData && insights !== undefined) {
+        logger.debug(`Sending usage data ${action} ${label}`);
+        insights.trackEvent({
+            name: action,
+            properties: label ? { label } : undefined,
+        });
+    }
+};
+
+/**
+ * Send usage data event to Application Insights
+ * @param {string} action The event action
+ * @param {string} label The event label
+ * @returns {void}
+ */
+export const sendUsageData = <T extends string>(action: T, label?: string) => {
+    eventQueue.push({ action, label });
+    if (!isInitialized()) {
+        return;
+    }
+    eventQueue.forEach(sendEvent);
+    eventQueue = [];
+};
+
+/**
+ * Send error usage data event to Application Insights and also show it in the logger view
+ * @param {string} error The event action
+ * @returns {void}
+ */
+export const sendErrorReport = (error: string) => {
+    logger.error(error);
+    insights?.trackException({
+        exception: new Error(error),
+    });
+    sendUsageData(
+        'Report error',
+        `${process.platform}; ${process.arch}; ${error}`
+    );
+};
+
+export default {
+    disable,
+    enable,
+    init,
+    isEnabled,
+    isInitialized,
+    reset,
+    sendErrorReport,
+    sendUsageData,
+};

package/src/utils/useFocusedOnVisible.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { useEffect, useRef } from 'react';
+
+/**
+ * Focus an element (usually an input) when a dialog becomes visible.
+ * Use the concrete elements type as a type parameter.
+ *
+ * @param {boolean} isVisible - Whether the dialog is visible
+ * @returns {React.RefObject<T>} A ref to pass to the element which should be focused
+ */
+export default <T extends HTMLElement>(isVisible: boolean) => {
+    const ref = useRef<T>(null);
+
+    useEffect(() => {
+        if (isVisible) {
+            ref.current?.focus();
+        }
+    }, [isVisible]);
+
+    return ref;
+};

package/src/utils/useHotKey.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { DependencyList, useEffect } from 'react';
+import { useDispatch } from 'react-redux';
+import Mousetrap from 'mousetrap';
+
+import { addShortcut, removeShortcut, Shortcut } from '../About/shortcutSlice';
+import { sendUsageData } from './usageData';
+
+const useNewHotKey = (shortcut: Shortcut, deps: DependencyList = []) => {
+    const dispatch = useDispatch();
+    useEffect(() => {
+        dispatch(addShortcut(shortcut));
+
+        Mousetrap.bind(shortcut.hotKey, (_e, combo) => {
+            shortcut.action();
+            sendUsageData('Pressed hotkey', combo);
+        });
+
+        return () => {
+            dispatch(removeShortcut(shortcut));
+
+            Mousetrap.unbind(shortcut.hotKey);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+};
+const useLegacyHotKey = (hotKey: string | string[], action: () => void) => {
+    console.warn(
+        `Defining a hot key for '${hotKey}' using a legacy API. ` +
+            'Please update the app (or tell the app author to update it to ' +
+            'the latest API).'
+    );
+
+    useNewHotKey({
+        hotKey,
+        title: 'Legacy shortcut',
+        isGlobal: false,
+        action,
+    });
+};
+
+const isUsingLegacyHotkey = (
+    args: unknown[]
+): args is Parameters<typeof useLegacyHotKey> =>
+    args.length === 2 && typeof args[1] === 'function';
+
+export default (
+    ...args:
+        | Parameters<typeof useNewHotKey>
+        | Parameters<typeof useLegacyHotKey>
+) => {
+    if (isUsingLegacyHotkey(args)) {
+        useLegacyHotKey(...args);
+    } else {
+        useNewHotKey(...args);
+    }
+};

package/src/utils/useStopwatch.test.tsx

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