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

package/src/utils/colors.ts

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+// Keep this file in sync with colors.scss
+export const colors = {
+    blueSlate: '#0033a0',
+    blueSlateLighter: '#7c98d3',
+    white: 'white',
+    black: 'black',
+    primary: '#00a9ce',
+    primaryDarkened: '#0098b9',
+    secondary: 'white',
+    accent: '#0033a0',
+
+    nordicBlue: '#00A9CE',
+    nordicBlue50: '#E0F5F9',
+    nordicBlue100: '#B3E5F0',
+    nordicBlue200: '#80D4E7',
+    nordicBlue300: '#4DC3DD',
+    nordicBlue400: '#26B6D5',
+    nordicBlue500: '#00A9CE',
+    nordicBlue600: '#00A2C9',
+    nordicBlue700: '#0098C2',
+    nordicBlue800: '#008FBC',
+    nordicBlue900: '#007EB0',
+
+    gray: '#607d8b',
+    gray50: '#eceff1',
+    gray100: '#cfd8dc',
+    gray200: '#b0bec5',
+    gray300: '#90a4ae',
+    gray400: '#78909c',
+    gray500: '#607d8b',
+    gray600: '#546e7a',
+    gray700: '#455a64',
+    gray800: '#37474f',
+    gray900: '#263238',
+
+    red: '#F44336',
+    red50: '#FFEBEE',
+    red100: '#FFCDD2',
+    red200: '#EF9A9A',
+    red300: '#E57373',
+    red400: '#EF5350',
+    red500: '#F44336',
+    red600: '#E53935',
+    red700: '#C62828',
+    red800: '#C62828',
+    red900: '#B71C1C',
+
+    indigo: '#3F51B5',
+    indigo50: '#E8EAF6',
+    indigo100: '#C5CAE9',
+    indigo200: '#9FA8DA',
+    indigo300: '#7986CB',
+    indigo400: '#5C6BC0',
+    indigo500: '#3F51B5',
+    indigo600: '#3949AB',
+    indigo700: '#303F9F',
+    indigo800: '#283593',
+    indigo900: '#1A237E',
+
+    amber: '#FFC107',
+    amber50: '#FFF8E1',
+    amber100: '#FFECB3',
+    amber200: '#FFE082',
+    amber300: '#FFD54F',
+    amber400: '#FFCA28',
+    amber500: '#FFC107',
+    amber600: '#FFB300',
+    amber700: '#FFA000',
+    amber800: '#FF8F00',
+    amber900: '#FF6F00',
+
+    purple: '#9C27B0',
+    purple50: '#F3E5F5',
+    purple100: '#E1BEE7',
+    purple200: '#CE93D8',
+    purple300: '#BA68C8',
+    purple400: '#AB47BC',
+    purple500: '#9C27B0',
+    purple600: '#8E24AA',
+    purple700: '#7B1FA2',
+    purple800: '#6A1B9A',
+    purple900: '#4A148C',
+
+    green: '#4CAF50',
+    green50: '#E8F5E9',
+    green100: '#C8E6C9',
+    green200: '#A5D6A7',
+    green300: '#81C784',
+    green400: '#66BB6A',
+    green500: '#4CAF50',
+    green600: '#43A047',
+    green700: '#388E3C',
+    green800: '#2E7D32',
+    green900: '#1B5E20',
+
+    deepPurple: '#673AB7',
+    deepPurple50: '#EDE7F6',
+    deepPurple100: '#D1C4E9',
+    deepPurple200: '#B39DDB',
+    deepPurple300: '#9575CD',
+    deepPurple400: '#7E57C2',
+    deepPurple500: '#673AB7',
+    deepPurple600: '#5E35B1',
+    deepPurple700: '#512DA8',
+    deepPurple800: '#4527A0',
+    deepPurple900: '#311B92',
+
+    orange: '#FF9800',
+    orange50: '#FFF3E0',
+    orange100: '#FFE0B2',
+    orange200: '#FFCC80',
+    orange300: '#FFB74D',
+    orange400: '#FFA726',
+    orange500: '#FF9800',
+    orange600: '#FB8C00',
+    orange700: '#F57C00',
+    orange800: '#EF6C00',
+    orange900: '#E65100',
+
+    lime: '#CDDC39',
+    lime50: '#F9FBE7',
+    lime100: '#F0F4C3',
+    lime200: '#E6EE9C',
+    lime300: '#DCE775',
+    lime400: '#D4E157',
+    lime500: '#CDDC39',
+    lime600: '#C0CA33',
+    lime700: '#AFB42B',
+    lime800: '#9E9D24',
+    lime900: '#827717',
+
+    pink: '#E91E63',
+    pink50: '#FCE4EC',
+    pink100: '#F8BBD0',
+    pink200: '#F48FB1',
+    pink300: '#F06292',
+    pink400: '#EC407A',
+    pink500: '#E91E63',
+    pink600: '#D81B60',
+    pink700: '#C2185B',
+    pink800: '#AD1457',
+    pink900: '#880E4F',
+
+    lightGreen: '#8BC34A',
+    lightGreen50: '#F1F8E9',
+    lightGreen100: '#DCEDC8',
+    lightGreen200: '#C5E1A5',
+    lightGreen300: '#AED581',
+    lightGreen400: '#9CCC65',
+    lightGreen500: '#8BC34A',
+    lightGreen600: '#7CB342',
+    lightGreen700: '#689F38',
+    lightGreen800: '#558B2F',
+    lightGreen900: '#33691E',
+
+    lightBlue: '#03A9F4',
+    lightBlue50: '#E1F5FE',
+    lightBlue100: '#B3E5FC',
+    lightBlue200: '#81D4FA',
+    lightBlue300: '#4FC3F7',
+    lightBlue400: '#29B6F6',
+    lightBlue500: '#03A9F4',
+    lightBlue600: '#039BE5',
+    lightBlue700: '#0288D1',
+    lightBlue800: '#0277BD',
+    lightBlue900: '#01579B',
+};

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 './AppTypes';
+
+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`);