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

package/src/logging/index.ts

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { TransformableInfo } from 'logform';
+import path from 'path';
+import { SPLAT } from 'triple-beam';
+import { createLogger, format, LogEntry, Logger, transports } from 'winston';
+import Transport from 'winston-transport';
+
+import { getAppLogDir } from '../utils/appDirs';
+import { openFile } from '../utils/open';
+import AppTransport from './appTransport';
+import describeError from './describeError';
+import createLogBuffer from './logBuffer';
+
+const isDevelopment = process.env.NODE_ENV === 'development';
+
+const isConsoleAvailable = (() => {
+    try {
+        process.stdout.write('');
+    } catch (error) {
+        return false;
+    }
+    return true;
+})();
+
+const filePrefix = new Date().toISOString().replace(/:/gi, '_');
+const logFilePath = () => path.join(getAppLogDir(), `${filePrefix}-log.txt`);
+
+const logBuffer = createLogBuffer();
+
+const logTransports: Transport[] = [
+    new AppTransport({
+        level: 'info',
+        onLogEntry: logBuffer.addEntry,
+    }),
+];
+
+if (isDevelopment && isConsoleAvailable) {
+    logTransports.push(new transports.Console({ level: 'silly' }));
+}
+
+interface SharedLogger extends Logger {
+    initialise: () => void;
+    getAndClearEntries: () => LogEntry[];
+    openLogFile: () => void;
+    logError: (message: string, error: unknown) => void;
+}
+
+/* This function is only needed, because our version of TypeScript still seems
+   unable to accept (unique) symbols as index types. As soon as we have
+   upgraded to a version that is capable of that, the invocations of this
+   function can be replaced by a simple `info[splat]` and this function can
+   be removed. */
+const splat = (info: TransformableInfo) => info[SPLAT as unknown as string];
+
+const logger = createLogger({
+    format: format.combine(
+        format(info => ({
+            ...info,
+            message: splat(info)
+                ? `${info.message} ${splat(info).join(' ')}`
+                : info.message,
+        }))(),
+        format.timestamp(),
+        format.printf(
+            ({ timestamp, level, message }) =>
+                `${timestamp} ${level.toUpperCase()} ${message || ''}`
+        )
+    ),
+    transports: logTransports,
+}) as SharedLogger;
+
+logger.initialise = () => {
+    logger.add(
+        new transports.File({
+            filename: logFilePath(),
+            level: 'debug',
+        })
+    );
+};
+
+logger.getAndClearEntries = () => logBuffer.clear();
+
+logger.openLogFile = () => {
+    try {
+        openFile(logFilePath());
+    } catch (error) {
+        logger.logError('Unable to open log file', error);
+    }
+};
+
+logger.logError = (message: string, error: unknown) => {
+    const errorMessage =
+        error == null ? message : `${message}: ${describeError(error)}`;
+
+    logger.error(errorMessage);
+};
+
+export default logger;

package/src/logging/logBuffer.test.ts

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import createLogBuffer from './logBuffer';
+
+describe('logBuffer', () => {
+    let logBuffer: ReturnType<typeof createLogBuffer>;
+
+    beforeEach(() => {
+        logBuffer = createLogBuffer();
+    });
+
+    it('should have no entries when buffer is empty', () => {
+        expect(logBuffer.size()).toEqual(0);
+    });
+
+    it('should have 1 entry when 1 entry has been added', () => {
+        logBuffer.addEntry({ id: 0, level: '', message: '' });
+        expect(logBuffer.size()).toEqual(1);
+    });
+
+    it('should return all added entries when clearing buffer', () => {
+        const inputEntries = [
+            { id: 0, level: '', message: '' },
+            { id: 1, level: '', message: '' },
+        ];
+        logBuffer.addEntry(inputEntries[0]);
+        logBuffer.addEntry(inputEntries[1]);
+        const outputEntries = logBuffer.clear();
+        expect(outputEntries).toEqual(inputEntries);
+    });
+
+    it('should have no entries when buffer has been cleared', () => {
+        logBuffer.addEntry({ id: 0, level: '', message: '' });
+        logBuffer.clear();
+        expect(logBuffer.size()).toEqual(0);
+    });
+});

package/src/logging/logBuffer.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { LogEntry } from 'winston';
+
+class LogBuffer {
+    entries: LogEntry[] = [];
+    addEntry = (entry: LogEntry) => {
+        this.entries.push(entry);
+    };
+    clear() {
+        return this.entries.splice(0, this.size());
+    }
+    size() {
+        return this.entries.length;
+    }
+}
+
+const createLogBuffer = () => new LogBuffer();
+
+export default createLogBuffer;

package/src/logging/sendInitialLogMessages.ts

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { getModuleVersions } from '@nordicsemiconductor/nrf-device-lib-js';
+
+import { inMain as appDetails } from '../../ipc/appDetails';
+import {
+    getDeviceLibContext,
+    getModuleVersion,
+} from '../Device/deviceLibWrapper';
+import { getAppDataDir } from '../utils/appDirs';
+import describeVersion from '../utils/describeVersion';
+import logLibVersions from '../utils/logLibVersions';
+import logger from '.';
+
+let initialMessagesSent = false;
+export default async () => {
+    if (initialMessagesSent) return;
+    initialMessagesSent = true;
+
+    logLibVersions();
+    logger.debug(`Application data folder: ${getAppDataDir()}`);
+
+    const details = await appDetails.getAppDetails();
+
+    const {
+        name,
+        currentVersion,
+        engineVersion,
+        coreVersion,
+        corePath,
+        installed,
+        homeDir,
+        tmpDir,
+        bundledJlink,
+        source,
+    } = details;
+
+    logger.debug(`App ${name} v${currentVersion} (${source})`);
+    logger.debug(`App path: ${installed.path}`);
+    logger.debug(
+        `nRFConnect ${coreVersion}, required by the app is (${engineVersion})`
+    );
+    logger.debug(`nRFConnect path: ${corePath}`);
+    logger.debug(`HomeDir: ${homeDir}`);
+    logger.debug(`TmpDir: ${tmpDir}`);
+
+    if (bundledJlink) {
+        const versions = await getModuleVersions(getDeviceLibContext());
+        const jlinkVersion = getModuleVersion('JlinkARM', versions);
+
+        if (!describeVersion(jlinkVersion).includes(bundledJlink)) {
+            logger.info(
+                `Installed JLink version does not match the provided version (${bundledJlink})`
+            );
+        }
+    }
+};

package/src/store.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { AnyAction, configureStore, ThunkAction } from '@reduxjs/toolkit';
+import { Reducer } from 'redux';
+
+import { reducer as shortcuts } from './About/shortcutSlice';
+import { reducer as appLayout } from './App/appLayout';
+import { reducer as brokenDeviceDialog } from './Device/BrokenDeviceDialog/brokenDeviceDialogSlice';
+import { reducer as deviceAutoSelect } from './Device/deviceAutoSelectSlice';
+import { reducer as deviceSetup } from './Device/deviceSetupSlice';
+import { reducer as device } from './Device/deviceSlice';
+import { reducer as errorDialog } from './ErrorDialog/errorDialogSlice';
+import { reducer as flashMessages } from './FlashMessage/FlashMessageSlice';
+import { reducer as log } from './Log/logSlice';
+
+const ifBuiltForDevelopment = <X>(value: X) =>
+    process.env.NODE_ENV === 'development' ? value : undefined;
+
+const noopReducer: Reducer = (state = null) => state;
+
+export const rootReducerSpec = (appReducer: Reducer = noopReducer) => ({
+    app: appReducer,
+    appLayout,
+    device,
+    deviceSetup,
+    deviceAutoSelect,
+    brokenDeviceDialog,
+    errorDialog,
+    log,
+    shortcuts,
+    flashMessages,
+});
+
+const store = (appReducer?: Reducer) =>
+    configureStore({
+        reducer: rootReducerSpec(appReducer),
+        devTools: {
+            maxAge: ifBuiltForDevelopment(100),
+            serialize: ifBuiltForDevelopment(true),
+        },
+        middleware: getDefaultMiddleware =>
+            getDefaultMiddleware({
+                serializableCheck: false,
+            }),
+    });
+
+// Needed only to infer the types below
+const concreteStore = store();
+
+export type AppThunk<AppLayout = RootState, ReturnType = void> = ThunkAction<
+    ReturnType,
+    AppLayout,
+    unknown,
+    AnyAction
+>;
+export type RootState = ReturnType<typeof concreteStore.getState>;
+export type AppDispatch = typeof concreteStore.dispatch;
+
+export interface NrfConnectState<AppState> extends RootState {
+    app: AppState;
+}
+
+export default store;

package/src/svg.d.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+declare module '!!@svgr!*.svg' {
+    const svg: React.ElementType;
+    export default svg;
+}
+
+declare module '*.svg' {
+    const url: string;
+    export default url;
+}

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,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',
+};