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

package/src/utils/systemReport.ts

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2105 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import nrfDeviceLib from '@nordicsemiconductor/nrf-device-lib-js';
+import fs from 'fs';
+import { EOL } from 'os';
+import path from 'path';
+import pretty from 'prettysize';
+import type Systeminformation from 'systeminformation';
+
+import {
+    deviceInfo as getDeviceInfo,
+    productPageUrl,
+} from '../Device/deviceInfo/deviceInfo';
+import {
+    getDeviceLibContext,
+    getModuleVersion,
+} from '../Device/deviceLibWrapper';
+import { Device } from '../Device/deviceSlice';
+import logger from '../logging';
+import { getAppDataDir } from './appDirs';
+import describeVersion from './describeVersion';
+import { openFile } from './open';
+
+const generalInfoReport = async () => {
+    // eslint-disable-next-line global-require
+    const si = require('systeminformation') as typeof Systeminformation;
+    const [
+        { manufacturer, model },
+        { vendor, version },
+        { platform, distro, release, arch },
+        { kernel, git, node, python, python3 },
+        {
+            manufacturer: cpuManufacturer,
+            brand,
+            speed,
+            cores,
+            physicalCores,
+            processors,
+        },
+        { total, free },
+        fsSize,
+    ] = await Promise.all([
+        si.system(),
+        si.bios(),
+        si.osInfo(),
+        si.versions(),
+        si.cpu(),
+        si.mem(),
+        si.fsSize(),
+    ]);
+
+    const versions = await nrfDeviceLib.getModuleVersions(
+        getDeviceLibContext()
+    );
+
+    return [
+        `- System:     ${manufacturer} ${model}`,
+        `- BIOS:       ${vendor} ${version}`,
+        `- CPU:        ${processors} x ${cpuManufacturer} ${brand} ${speed} GHz` +
+            ` ${cores} cores (${physicalCores} physical)`,
+        `- Memory:     ${pretty(free)} free of ${pretty(total)} total`,
+        `- Filesystem: ${fsSize[0].fs} (${fsSize[0].type})` +
+            ` ${pretty(Number(fsSize[0].size) || 0)}` +
+            ` ${fsSize[0].use.toFixed(1)}% used`,
+        '',
+        `- OS:         ${distro} (${release}) ${platform} ${arch}`,
+        '',
+        '- Versions',
+        `    - kernel: ${kernel}`,
+        `    - git: ${git}`,
+        `    - node: ${node}`,
+        `    - python: ${python}`,
+        `    - python3: ${python3}`,
+        `    - nrf-device-lib-js: ${describeVersion(
+            getModuleVersion('nrfdl-js', versions)
+        )}`,
+        `    - nrf-device-lib: ${describeVersion(
+            getModuleVersion('nrfdl', versions)
+        )}`,
+        `    - nrfjprog DLL: ${describeVersion(
+            getModuleVersion('jprog', versions)
+        )}`,
+        `    - JLink: ${describeVersion(
+            getModuleVersion('JlinkARM', versions)
+        )}`,
+        '',
+    ];
+};
+
+const allDevicesReport = (allDevices: Device[] = []) => [
+    '- Connected devices:',
+    ...allDevices.map(
+        d =>
+            `    - ${d.serialNumber} ${d.boardVersion || ''}: ${d.serialPorts
+                ?.map(s => s.comName)
+                .join(', ')}`
+    ),
+    '',
+];
+
+const currentDeviceReport = (device?: Device, currentSerialNumber?: string) => {
+    if (device == null) {
+        return [];
+    }
+
+    const deviceInfo = getDeviceInfo(device);
+
+    return [
+        '- Current device:',
+        `    - name:          ${deviceInfo.name}`,
+        `    - serialNumber:  ${currentSerialNumber}`,
+        `    - cores:         ${deviceInfo.cores ?? 'Unknown'}`,
+        `    - website:       ${productPageUrl(device) ?? 'Unknown'}`,
+        '',
+    ];
+};
+
+export const generateSystemReport = async (
+    timestamp: string,
+    allDevices?: Device[],
+    currentDevice?: Device,
+    currentSerialNumber?: string
+) =>
+    [
+        `# nRFConnect System Report - ${timestamp}`,
+        '',
+        ...(await generalInfoReport()),
+        ...allDevicesReport(allDevices),
+        ...currentDeviceReport(currentDevice, currentSerialNumber),
+    ].join(EOL);
+
+export default async (
+    allDevices: Device[],
+    currentSerialNumber: string,
+    currentDevice: Device | null
+) => {
+    logger.info('Generating system report...');
+    const timestamp = new Date().toISOString().replace(/:/g, '-');
+    const report = await generateSystemReport(
+        timestamp,
+        allDevices,
+        currentDevice ?? undefined,
+        currentSerialNumber
+    );
+
+    const fileName = `nrfconnect-system-report-${timestamp}.txt`;
+    const filePath = path.resolve(getAppDataDir(), fileName);
+
+    try {
+        fs.writeFileSync(filePath, report);
+        logger.info(`System report: ${filePath}`);
+        openFile(filePath);
+    } catch (error) {
+        logger.logError('Failed to generate system report', error);
+    }
+};

package/src/utils/truncateMiddle.test.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { truncateMiddle } from './truncateMiddle';
+
+test('truncate strings when necessary', () => {
+    expect(
+        truncateMiddle('some long string with more than 36 characters')
+    ).toBe('some long string wit...36 characters');
+
+    expect(truncateMiddle('short string')).toBe('short string');
+
+    expect(truncateMiddle('string with 20 chars')).toBe('string with 20 chars');
+
+    expect(truncateMiddle('abc123def', 3, 3)).toBe('abc123def');
+
+    expect(truncateMiddle('abc1234efg', 3, 3)).toBe('abc...efg');
+});

package/src/utils/truncateMiddle.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const truncateMiddle = (str: string, clipStart = 20, clipEnd = 13) => {
+    const clipStartWithEllipsis = clipStart + 3;
+    if (str.length <= clipStartWithEllipsis + clipEnd) {
+        return str;
+    }
+    const rightHandStartingPoint =
+        str.length - Math.min(clipEnd, str.length - clipStartWithEllipsis);
+    return `${str.substring(0, clipStart)}...${str.substring(
+        rightHandStartingPoint,
+        str.length
+    )}`;
+};
+
+export { truncateMiddle };

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 logger from '../logging';
+import type { PackageJson } from './AppTypes';
+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);
+    }
+};