@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1

package/src/utils/AppTypes.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+export interface SourceJson {
+    name: string;
+    apps: string[];
+}
+
+export type AppVersions = {
+    [version: string]: {
+        shasum?: string;
+        tarballUrl: string;
+    };
+};
+
+export interface AppInfo {
+    name: string;
+    displayName: string;
+    description: string;
+    homepage?: string;
+    iconUrl: string;
+    releaseNotesUrl: string;
+    latestVersion: string;
+    versions: AppVersions;
+    installed?: {
+        path: string;
+        shasum?: string;
+    };
+}
+
+interface ObjectContainingOptionalStrings {
+    [index: string]: string | undefined;
+}
+
+export interface PackageJson {
+    name: string;
+    version: string;
+
+    // Several optional properties
+    author?: string;
+    bin?: ObjectContainingOptionalStrings | string;
+    dependencies?: ObjectContainingOptionalStrings;
+    description?: string;
+    homepage?: string;
+    devDependencies?: ObjectContainingOptionalStrings;
+    displayName?: string;
+    engines?: ObjectContainingOptionalStrings;
+    files?: readonly string[];
+    license?: string;
+    main?: string;
+    peerDependencies?: ObjectContainingOptionalStrings;
+    repository?: {
+        type: string;
+        url: string;
+    };
+    scripts?: ObjectContainingOptionalStrings;
+}

package/src/utils/appDirs.ts

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { getGlobal } from '@electron/remote';
+import path from 'path';
+
+import { loadPackageJson } from './packageJson';
+
+const getUserDataDir = () => getGlobal('userDataDir');
+
+declare global {
+    interface Window {
+        appDir: string;
+        appDataDir: string;
+        appLogDir: string;
+    }
+}
+
+function setAppDirs(
+    newAppDir: string,
+    newAppDataDir: string,
+    newAppLogDir: string
+) {
+    window.appDir = newAppDir;
+    window.appDataDir = newAppDataDir;
+    window.appLogDir = newAppLogDir;
+
+    loadPackageJson(getAppFile('package.json'));
+}
+
+/**
+ * Get the filesystem path of the currently loaded app.
+ *
+ * @returns {string|undefined} Absolute path of current app.
+ */
+function getAppDir() {
+    return window.appDir;
+}
+
+/**
+ * Get the filesystem path of a file for the currently loaded app.
+ *
+ * @param {string} filename relative name of file in the app directory
+ * @returns {string|undefined} Absolute path of file.
+ */
+function getAppFile(filename: string) {
+    return path.resolve(getAppDir(), filename);
+}
+
+/**
+ * Get the filesystem path of the data directory of currently loaded app.
+ *
+ * @returns {string|undefined} Absolute path of data directory of the current app.
+ */
+function getAppDataDir() {
+    return window.appDataDir;
+}
+
+/**
+ * Get the filesystem path of the log directory of currently loaded app.
+ *
+ * @returns {string|undefined} Absolute path of data directory of the current app.
+ */
+function getAppLogDir() {
+    return window.appLogDir;
+}
+
+export {
+    setAppDirs,
+    getAppDir,
+    getAppFile,
+    getAppDataDir,
+    getAppLogDir,
+    getUserDataDir,
+};

package/src/utils/bleChannels.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const bleChannels = [
+    37, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 38, 11, 12, 13, 14, 15, 16, 17, 18,
+    19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 39,
+];
+
+export default Object.assign(bleChannels, {
+    min: Math.min(...bleChannels),
+    max: Math.max(...bleChannels),
+    isAdvertisement: (channel: number) => channel >= 37,
+});

package/src/utils/classNames.test.ts

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import classNames from './classNames';
+
+describe('classNames', () => {
+    it('combines multiple class names with a space', () => {
+        expect(classNames('button', 'important')).toBe('button important');
+    });
+
+    it('filters out non strings', () => {
+        expect(
+            classNames(
+                'button',
+                true,
+                false,
+                null,
+                undefined,
+                [],
+                {},
+                () => {},
+                'important'
+            )
+        ).toBe('button important');
+    });
+});

package/src/utils/classNames.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const isString = (o: unknown) => typeof o === 'string';
+
+/**
+ * Combine a list of class names into a space separated strings.
+ * Filters out all values that are not strings. The idea of this function is
+ * to use it with conditionals and potentially unset values like this:
+ *
+ *     classNames(
+ *          'fixed-class-name',
+ *          isVisible && 'visible',
+ *          isEnabled ? 'enabled' : 'disabled',
+ *          potentiallyUndefined,
+ *     )
+ *
+ * @param {...unknown} className - An arbitrary list of class names or other objects
+ * @returns {string} the combined class name
+ */
+export default (...className: unknown[]) =>
+    className.filter(isString).join(' ');

package/src/utils/colors.scss

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+@use "sass:color";
+@import "../variables";
+
+// Remember: When changing any entries here, they also must be
+// changed at the corresponding place in colors.ts
+:export {
+    nordicBlue: $nordic-blue;
+    blueSlate: $blue-slate;
+
+    white: $white;
+    black: $black;
+
+    primary: $primary;
+    primaryDarkened: $primary-darkened;
+    secondary: $secondary;
+    accent: $accent;
+    gray50: $gray-50;
+    gray100: $gray-100;
+    gray200: $gray-200;
+    gray300: $gray-300;
+    gray400: $gray-400;
+    gray500: $gray-500;
+    gray600: $gray-600;
+    gray700: $gray-700;
+    gray800: $gray-800;
+    gray900: $gray-900;
+
+    red: $red;
+    indigo: $indigo;
+    amber: $amber;
+    purple: $purple;
+    green: $green;
+    deepPurple: $deep-purple;
+    orange: $orange;
+    lime: $lime;
+    pink: $pink;
+
+    blueSlateLighter: color.scale($blue-slate, $lightness: 50%, $saturation: -50%);
+    greenLighter: color.scale($green, $lightness: 50%, $saturation: -50%);
+}

package/src/utils/colors.ts

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+// Keep this file in sync with colors.scss
+export const colors = {
+    nordicBlue: '#00a9ce',
+    blueSlate: '#0033a0',
+    white: 'white',
+    black: 'black',
+    primary: '#00a9ce',
+    primaryDarkened: '#0098b9',
+    secondary: 'white',
+    accent: '#0033a0',
+    gray50: '#eceff1',
+    gray100: '#cfd8dc',
+    gray200: '#b0bec5',
+    gray300: '#90a4ae',
+    gray400: '#78909c',
+    gray500: '#607d8b',
+    gray600: '#546e7a',
+    gray700: '#455a64',
+    gray800: '#37474f',
+    gray900: '#263238',
+    red: '#f44336',
+    indigo: '#3f51b5',
+    amber: '#ffc107',
+    purple: '#9c27b0',
+    green: '#4caf50',
+    deepPurple: '#673ab7',
+    orange: '#ff9800',
+    lime: '#cddc39',
+    pink: '#e91e63',
+    blueSlateLighter: '#7c98d3',
+    greenLighter: '#b1cbb3',
+};

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`);