@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre2 → 76.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,64 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { getModuleVersions } from '@nordicsemiconductor/nrf-device-lib-js';
+import { ipcRenderer } from 'electron';
+
+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 () => {
+    if (initialMessagesSent) return;
+    initialMessagesSent = true;
+
+    logLibVersions();
+    logger.debug(`Application data folder: ${getAppDataDir()}`);
+
+    ipcRenderer.once('app-details', async (_event, details) => {
+        const {
+            name,
+            currentVersion,
+            engineVersion,
+            coreVersion,
+            corePath,
+            isOfficial,
+            installed,
+            homeDir,
+            tmpDir,
+            bundledJlink,
+        } = details;
+
+        const official = isOfficial ? 'official' : 'local';
+
+        logger.debug(`App ${name} v${currentVersion} ${official}`);
+        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})`
+                );
+            }
+        }
+    });
+    ipcRenderer.send('get-app-details');
+};

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/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%);
+}