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

package/src/utils/describeVersion.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { ModuleVersion } from '@nordicsemiconductor/nrf-device-lib-js';
+
+export default (version?: ModuleVersion) => {
+    if (version == null) {
+        return 'Unknown';
+    }
+
+    switch (version.versionFormat) {
+        case 'incremental':
+        case 'string':
+            return String(version.version);
+        case 'semantic':
+            return `${version.version.major}.${version.version.minor}.${version.version.patch}`;
+    }
+};

package/src/utils/environment.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+export const isDevelopment = process.env.NODE_ENV === 'development';

package/src/utils/logLibVersions.ts

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import {
+    getModuleVersions,
+    ModuleVersion,
+} from '@nordicsemiconductor/nrf-device-lib-js';
+import { spawn } from 'child_process';
+import os from 'os';
+
+import {
+    getDeviceLibContext,
+    getModuleVersion,
+} from '../Device/deviceLibWrapper';
+import logger from '../logging';
+import describeVersion from './describeVersion';
+
+const log = (description: string, moduleVersion?: ModuleVersion) => {
+    if (moduleVersion == null) {
+        logger.warn(`Unable to detect version of ${description}.`);
+    } else {
+        logger.info(
+            `Using ${description} version: ${describeVersion(moduleVersion)}`
+        );
+    }
+};
+
+const pathEnvVariable = () => {
+    if (process.platform !== 'darwin') return process.env;
+
+    return {
+        ...process.env,
+        PATH: `/bin:/usr/bin:/usr/local/bin:${process.env.PATH}`,
+    };
+};
+
+const spawnAsync = (cmd: string, params?: string[]) =>
+    new Promise<string>((resolve, reject) => {
+        const codeProcess = spawn(cmd, params, {
+            shell: true,
+            env: pathEnvVariable(),
+        });
+        let stdout = '';
+        let stderr = '';
+        codeProcess.stdout.on('data', data => {
+            stdout += data;
+        });
+        codeProcess.stderr.on('data', data => {
+            stderr += data;
+        });
+
+        codeProcess.on('close', (code, signal) => {
+            if (stderr) console.log(stderr);
+            if (code === 0 && signal === null) {
+                return resolve(stdout);
+            }
+            return reject();
+        });
+    });
+
+const checkJLinkArchitectureOnDarwin = async () => {
+    const stdout = await spawnAsync('file $(which JLinkExe)');
+    const universalMatch = 'Mach-O universal binary with 2 architectures';
+    const intelMatch = 'Mach-O 64-bit executable x86_64';
+    if (stdout.includes(universalMatch)) return 'universal';
+    if (stdout.includes(intelMatch)) return 'x86_64';
+    return 'arm';
+};
+
+export default async () => {
+    try {
+        const versions = await getModuleVersions(getDeviceLibContext());
+
+        log('nrf-device-lib-js', getModuleVersion('nrfdl-js', versions));
+        log('nrf-device-lib', getModuleVersion('nrfdl', versions));
+        log('nrfjprog DLL', getModuleVersion('jprog', versions));
+        log('JLink', getModuleVersion('JlinkARM', versions));
+        if (
+            process.platform === 'darwin' &&
+            os.cpus()[0].model.includes('Apple')
+        ) {
+            const JLinkArchOnDarwin = await checkJLinkArchitectureOnDarwin();
+
+            if (JLinkArchOnDarwin && JLinkArchOnDarwin !== 'universal') {
+                const JLinkInstallerVersion =
+                    JLinkArchOnDarwin === 'arm'
+                        ? '64-bit Apple M1 Installer'
+                        : '64-bit Intel Installer';
+                logger.warn(
+                    `It looks like you have installed JLink using ${JLinkInstallerVersion}, but currently we only support their Universal Installer for your system.`
+                );
+                logger.warn(
+                    `Please install JLink: https://www.segger.com/downloads/jlink/JLink_MacOSX_V780c_universal.pkg`
+                );
+            }
+        }
+    } catch (error) {
+        logger.logError('Failed to get the library versions', error);
+    }
+};

package/src/utils/open.ts

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import childProcess from 'child_process';
+import { shell } from 'electron';
+import fs from 'fs';
+import os from 'os';
+
+/**
+ * Open a file in the default text application, depending on the user's OS.
+ *
+ * @param {string} filePath path to the file to open.
+ * @returns {void}
+ */
+function openFile(filePath: string) {
+    const exists = fs.existsSync(filePath);
+    if (!exists) {
+        throw new Error(`Could not find file at path: ${filePath}`);
+    }
+
+    const escapedPath = filePath.replace(/ /g, '\\ ');
+
+    // Could not find a method that works on all three platforms:
+    // * shell.openItem works on Windows and Linux but not on OSX
+    // * childProcess.execSync works on OSX but not on Windows
+    if (os.type() === 'Darwin') {
+        childProcess.execSync(`open ${escapedPath}`);
+    } else {
+        shell.openPath(escapedPath);
+    }
+}
+
+/**
+ * Open a URL in the user's default web browser.
+ *
+ * @param {string} url The URL to open.
+ * @returns {void}
+ */
+function openUrl(url: string) {
+    shell.openExternal(url);
+}
+
+export { openFile, openUrl };

package/src/utils/packageJson.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { readFileSync } from 'fs';
+
+/* Explanation for that cascade of eslint-disable-next-line and @ts-ignore:
+   '../../../../package.json' will resolve correctly when `shared` is used in
+   a real app, so it is fine.
+
+   When checking `shared` '../../../../package.json' will not be there, so we
+   need to disable the errors that occur in that case. That is done by the
+   second and third statement:
+     // @ts-ignore This will be available when the app uses it.
+     // eslint-disable-next-line import/no-unresolved
+
+   Usually we would not use `@ts-ignore` but rather `@ts-expect-error`. But
+   the latter is not possible for a different reason: When we type-check an
+   app that uses shared, that line will now be type-checked too and now
+   '../../../../package.json' actually is there, so `ts-expect-error` would
+   lead to an error, telling us that contrary to our expectation there is no
+   error there.
+
+   Because of that we have to use `@ts-ignore`. But that is usually forbidden
+   by the linting rules, so additionally we have to add that first line
+     eslint-disable-next-line @typescript-eslint/ban-ts-comment
+
+   Phew!
+*/
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore This will be available when the app uses it.
+// eslint-disable-next-line import/no-unresolved
+import packageJsons from '../../../../package.json';
+import type { PackageJson } from '../../ipc/MetaFiles';
+
+let packageJson: PackageJson = packageJsons;
+
+export const loadPackageJson = (packageJsonPath: string) => {
+    try {
+        packageJson = JSON.parse(
+            readFileSync(packageJsonPath, 'utf8')
+        ) as PackageJson;
+    } catch (e) {
+        console.error(
+            'Failed to read "package.json" of the app. Please tell the app developer to package it correctly.'
+        );
+    }
+};
+
+export default () => {
+    if (packageJson == null) {
+        throw new Error(`package.json was not read. This can be caused by one of two things:
+- Either a programming error in the app that tries to use the content of package.json very early before it was loaded.
+- Or if the app was packaged without a package.json, but in that case the launcher should not even launch this app.`);
+    }
+
+    return packageJson;
+};

package/src/utils/persistentStore.ts

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import type { AutoDetectTypes } from '@serialport/bindings-cpp';
+import Store from 'electron-store';
+import { SerialPortOpenOptions } from 'serialport';
+import { v4 as uuid } from 'uuid';
+
+import logger from '../logging';
+import packageJson from './packageJson';
+
+export interface SerialSettings {
+    serialPortOptions: Omit<SerialPortOpenOptions<AutoDetectTypes>, 'path'>;
+    lastUpdated: number;
+    vComIndex: number;
+}
+
+export interface TerminalSettings {
+    lineMode: boolean;
+    echoOnShell: boolean;
+    lineEnding: string;
+    clearOnSend: boolean;
+}
+
+const sharedStore = new Store<{
+    verboseLogging: boolean;
+    isSendingUsageData: boolean | undefined;
+    clientId?: string;
+}>({
+    name: 'pc-nrfconnect-shared',
+});
+
+/* These nicknames are also read by the VS Code extension,
+  so changing e.g. the keys here would break the usage there. */
+export const persistNickname = (serialNumber: string, nickname: string) =>
+    sharedStore.set(`${serialNumber}.name`, nickname);
+export const getPersistedNickname = (serialNumber: string) =>
+    sharedStore.get(`${serialNumber}.name`, '') as string;
+
+export const persistIsFavorite = (serialNumber: string, value: boolean) =>
+    sharedStore.set(`${serialNumber}.fav`, value);
+export const getPersistedIsFavorite = (serialNumber: string) =>
+    sharedStore.get(`${serialNumber}.fav`, false) as boolean;
+
+export const persistSerialPortSettings = (
+    serialNumber: string,
+    serialPortSettings: Omit<SerialSettings, 'lastUpdated'>
+) =>
+    sharedStore.set(`${serialNumber}.${packageJson().name}`, {
+        ...serialPortSettings,
+        lastUpdated: Date.now(),
+    });
+export const getPersistedSerialPortSettings = (
+    serialNumber: string
+): SerialSettings | undefined => {
+    const appName = packageJson().name;
+    logger.info(
+        `Getting serialport options from persistent store ${serialNumber}.${appName}`
+    );
+    return sharedStore.get(`${serialNumber}.${appName}`);
+};
+export const persistTerminalSettings = (
+    serialNumber: string,
+    vComIndex: number,
+    terminalSettings: TerminalSettings
+) =>
+    sharedStore.set(
+        `${serialNumber}.vCom-${vComIndex}.TerminalSettings`,
+        terminalSettings
+    );
+export const getPersistedTerminalSettings = (
+    serialNumber: string,
+    vComIndex: number
+): TerminalSettings | undefined => {
+    logger.info(
+        `Get terminal settings from persistent store ${serialNumber}.vCom-${vComIndex}.TerminalSettings`
+    );
+    return sharedStore.get(
+        `${serialNumber}.vCom-${vComIndex}.TerminalSettings`
+    );
+};
+
+export const persistIsSendingUsageData = (value: boolean) =>
+    sharedStore.set('isSendingUsageData', value);
+export const getIsSendingUsageData = () =>
+    sharedStore.get('isSendingUsageData', undefined) as boolean | undefined;
+export const deleteIsSendingUsageData = () =>
+    sharedStore.delete('isSendingUsageData');
+
+const existingUsageDataClientId = () => sharedStore.get('clientId');
+const newUsageDataClientId = () => {
+    const clientId = uuid();
+    sharedStore.set('clientId', clientId);
+
+    return clientId;
+};
+export const getUsageDataClientId = () =>
+    existingUsageDataClientId() ?? newUsageDataClientId();
+
+export const persistIsLoggingVerbose = (value: boolean) =>
+    sharedStore.set('isLoggingVerbose', value);
+export const getIsLoggingVerbose = () =>
+    sharedStore.get('isLoggingVerbose', false);
+
+// This one must be initialised lazily, because the package.json is not read yet when this module is initialised.
+// This can probably be changed when we bundle shared with the apps.
+let appSpecificStore: Store | undefined;
+
+interface SharedAppSpecificStoreSchema {
+    currentPane?: number;
+}
+
+export const getAppSpecificStore = <
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    StoreSchema extends Record<string, any>
+>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    options?: Store.Options<any>
+) => {
+    if (appSpecificStore == null) {
+        appSpecificStore = new Store({
+            name: packageJson().name,
+            clearInvalidConfig: true,
+            // @ts-expect-error `electron-store` assumes the app is the version of the launcher, override this to be the same as the app version
+            projectVersion: packageJson().version,
+            ...options,
+        });
+    }
+
+    return appSpecificStore as Store<
+        StoreSchema & SharedAppSpecificStoreSchema
+    >;
+};
+
+export const persistCurrentPane = (currentPane: number) =>
+    getAppSpecificStore<SharedAppSpecificStoreSchema>().set(
+        `currentPane`,
+        currentPane
+    );
+export const getPersistedCurrentPane = () =>
+    getAppSpecificStore<SharedAppSpecificStoreSchema>().get(`currentPane`);

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 };