@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1

package/src/bootstrap.scss

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+@import './variables';
+@import 'bootstrap/scss/bootstrap';
+ 
+@each $color, $value in $theme-colors {
+    .btn-#{$color}, .btn-#{$color}.disabled, .btn-#{$color}:disabled {
+        border-color: $gray-200;
+    }
+}
+ 

package/src/index.ts

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+import { hideDialog, showDialog } from './ErrorDialog/errorDialogSlice';
+
+const ErrorDialogActions = { hideDialog, showDialog };
+
+export { ErrorDialogActions };
+
+export { default as App, type PaneProps } from './App/App';
+export { default as Logo } from './Logo/Logo';
+export {
+    default as DeviceSelector,
+    type Props as DeviceSelectorProps,
+} from './Device/DeviceSelector/DeviceSelector';
+export {
+    Dialog,
+    GenericDialog,
+    ConfirmationDialog,
+    InfoDialog,
+    ErrorDialog,
+    DialogButton,
+} from './Dialog/Dialog';
+export type { DialogButtonProps } from './Dialog/Dialog';
+export { default as Slider } from './Slider/Slider';
+export { Toggle } from './Toggle/Toggle';
+export { default as RootErrorDialog } from './ErrorDialog/ErrorDialog';
+export { Alert } from './Alert/Alert';
+export { default as Main } from './Main/Main';
+export { default as Button } from './Button/Button';
+export type { ButtonVariants } from './Button/Button';
+export { default as Card } from './Card/Card';
+export { default as ErrorBoundary } from './ErrorBoundary/ErrorBoundary';
+export { default as StateSelector } from './StateSelector/StateSelector';
+export { default as Dropdown, type DropdownItem } from './Dropdown/Dropdown';
+export { default as StartStopButton } from './StartStopButton/StartStopButton';
+export { default as DocumentationSection } from './About/DocumentationSection';
+export { default as Stepper } from './Stepper/Stepper';
+export type { Step } from './Stepper/Stepper';
+
+export { default as SidePanel } from './SidePanel/SidePanel';
+export { Group, CollapsibleGroup } from './SidePanel/Group';
+
+export { default as InlineInput } from './InlineInput/InlineInput';
+export { default as NumberInlineInput } from './InlineInput/NumberInlineInput';
+
+export { default as MasonryLayout } from './MasonryLayout/MasonryLayout';
+
+export { default as useStopwatch } from './utils/useStopwatch';
+
+export { reducer as errorDialogReducer } from './ErrorDialog/errorDialogSlice';
+export { default as logger } from './logging';
+export { default as bleChannels } from './utils/bleChannels';
+export { colors } from './utils/colors';
+
+export {
+    setAppDirs,
+    getAppDir,
+    getAppFile,
+    getAppDataDir,
+    getAppLogDir,
+    getUserDataDir,
+} from './utils/appDirs';
+
+export { openUrl } from './utils/open';
+export { default as systemReport } from './utils/systemReport';
+
+export { default as usageData } from './utils/usageData';
+export { default as classNames } from './utils/classNames';
+export { truncateMiddle } from './utils/truncateMiddle';
+
+export { default as useHotKey } from './utils/useHotKey';
+export { isDevelopment } from './utils/environment';
+
+export { currentPane, setCurrentPane } from './App/appLayout';
+
+export { isLoggingVerbose } from './Log/logSlice';
+
+export {
+    getAppSpecificStore as getPersistentStore,
+    persistTerminalSettings,
+    getPersistedTerminalSettings,
+} from './utils/persistentStore';
+
+export { jprogDeviceSetup } from './Device/jprogOperations';
+
+export { sdfuDeviceSetup } from './Device/sdfuOperations';
+
+export {
+    selectedDevice,
+    getReadbackProtection,
+    persistSerialPortOptions,
+    type Device,
+} from './Device/deviceSlice';
+export {
+    setWaitForDevice,
+    clearWaitForDevice,
+    getAutoReselect,
+    getWaitingForDeviceTimeout,
+    getWaitingToAutoReselect,
+    getWaitForDevice,
+} from './Device/deviceAutoSelectSlice';
+export { deviceInfo } from './Device/deviceInfo/deviceInfo';
+export { getDeviceLibContext } from './Device/deviceLibWrapper';
+export { isDeviceInDFUBootloader } from './Device/sdfuOperations';
+export {
+    default as sdfuOperations,
+    switchToBootloaderMode,
+    switchToApplicationMode,
+} from './Device/sdfuOperations';
+export {
+    defaultInitPacket,
+    type DfuImage,
+    FwType,
+    HashType,
+} from './Device/initPacket';
+
+export { default as describeError } from './logging/describeError';
+
+export {
+    createSerialPort,
+    getSerialPortOptions,
+    type SerialPort,
+} from './SerialPort/SerialPort';
+export { default as ConflictingSettingsDialog } from './SerialPort/ConflictingSettingsDialog';
+
+export { openAppWindow } from './OpenApp/openApp';
+
+export type { NrfConnectState } from './store';
+
+export {
+    type DeviceSetupConfig,
+    type DeviceSetup,
+    prepareDevice,
+} from './Device/deviceSetup';
+
+export type {
+    AppInfo,
+    AppVersions,
+    PackageJson,
+    SourceJson,
+} from './utils/AppTypes';
+
+export { default as FeedbackPane } from './Panes/FeedbackPane';

package/src/logging/appTransport.test.ts

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import AppTransport from './appTransport';
+
+describe('AppTransport', () => {
+    const info = {
+        message: 'Foobar message',
+        level: 'info',
+        timestamp: '2019-07-31T11:00:42.660Z',
+    };
+
+    it('should throw error if onLogEntry is not provided to constructor', () => {
+        expect(() => new AppTransport(<never>{})).toThrow();
+    });
+
+    it('should include message in log entry', () => {
+        const onLogEntry = jest.fn();
+        const appTransport = new AppTransport({ onLogEntry });
+        const { message } = info;
+        appTransport.log(info, () => {});
+
+        expect(onLogEntry).toHaveBeenCalledWith(
+            expect.objectContaining({
+                message,
+            })
+        );
+    });
+
+    it('should include level in log entry', () => {
+        const onLogEntry = jest.fn();
+        const appTransport = new AppTransport({ onLogEntry });
+        const { level } = info;
+
+        appTransport.log(info, () => {});
+
+        expect(onLogEntry).toHaveBeenCalledWith(
+            expect.objectContaining({
+                level,
+            })
+        );
+    });
+
+    it('should include timestamp in log entry', () => {
+        const onLogEntry = jest.fn();
+        const appTransport = new AppTransport({ onLogEntry });
+
+        appTransport.log(info, () => {});
+
+        expect(typeof onLogEntry.mock.calls[0][0].timestamp).toBe('string');
+    });
+
+    it('should increment the log entry id', () => {
+        const onLogEntry = jest.fn();
+        const appTransport = new AppTransport({ onLogEntry });
+
+        appTransport.log(info, () => {});
+        appTransport.log(info, () => {});
+        appTransport.log(info, () => {});
+
+        expect(onLogEntry.mock.calls[0][0].id).toEqual(0);
+        expect(onLogEntry.mock.calls[1][0].id).toEqual(1);
+        expect(onLogEntry.mock.calls[2][0].id).toEqual(2);
+    });
+
+    it('should invoke the provided callback function when log completed', () => {
+        const onLogEntry = jest.fn();
+        const onLogDone = jest.fn();
+        const appTransport = new AppTransport({ onLogEntry });
+
+        appTransport.log(info, onLogDone);
+
+        expect(onLogDone).toHaveBeenCalled();
+    });
+});

package/src/logging/appTransport.ts

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { LogEntry } from 'winston';
+import Transport, { TransportStreamOptions } from 'winston-transport';
+
+interface Options extends TransportStreamOptions {
+    onLogEntry: (entry: LogEntry) => void;
+}
+
+export default class AppTransport extends Transport {
+    private onLogEntry: (entry: LogEntry) => void;
+    private entryCount: number;
+
+    constructor(options: Options) {
+        super(options);
+
+        if (!options.onLogEntry) {
+            throw new Error(
+                'Property onLogEntry was not provided to AppTransport'
+            );
+        }
+
+        this.onLogEntry = options.onLogEntry;
+        this.entryCount = 0;
+    }
+
+    log({ level, message, timestamp }: LogEntry, next: () => void) {
+        this.onLogEntry({
+            id: this.entryCount,
+            timestamp,
+            level,
+            message,
+        });
+        this.entryCount += 1;
+        next();
+    }
+}

package/src/logging/describeError.test.ts

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import describeError from './describeError';
+
+describe('a reasonable string representation for an error', () => {
+    it('is just that string for null or undefined', () => {
+        expect(describeError(null)).toBe('null');
+        expect(describeError(undefined)).toBe('undefined');
+    });
+
+    it('uses the default string representation if it is an instance of Error', () => {
+        expect(describeError(URIError('Wrong'))).toBe('URIError: Wrong');
+    });
+
+    it('uses the error message if one exists', () => {
+        expect(describeError({ message: 'a message' })).toBe('a message');
+    });
+
+    it('stringifies the error if it is anything else', () => {
+        expect(describeError({ an: 'object' })).toBe('{"an":"object"}');
+        expect(describeError('a string message')).toBe('"a string message"');
+        expect(describeError(['some', 'array'])).toBe('["some","array"]');
+        expect(describeError(42)).toBe('42');
+    });
+
+    it('appends the error origin', () => {
+        expect(
+            describeError({
+                message: 'a message',
+                origin: SyntaxError('something'),
+            })
+        ).toBe('a message (Origin: SyntaxError: something)');
+    });
+});

package/src/logging/describeError.ts

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+interface MaybeWithMessageAndOrigin {
+    message?: string;
+    origin?: MaybeWithMessageAndOrigin;
+}
+
+function hasMaybeMessageAndOrigin(
+    error: unknown
+): error is MaybeWithMessageAndOrigin {
+    return error != null;
+}
+
+const describe = (error: MaybeWithMessageAndOrigin) => {
+    if (error instanceof Error) {
+        return String(error);
+    }
+
+    if (error.message != null) {
+        return error.message;
+    }
+
+    return JSON.stringify(error);
+};
+
+const describeOrigin = (origin?: MaybeWithMessageAndOrigin) => {
+    if (origin == null) {
+        return '';
+    }
+
+    return ` (Origin: ${describe(origin)})`;
+};
+
+export default (error: unknown) => {
+    if (error == null) {
+        return String(error);
+    }
+
+    /* Because we asserted that error is neither null nor undefined above, we
+       can access properties like `message` and `origin` from here on, without
+       fearing a "Cannot read property 'message' of null/undefined". But
+       TypeScript is not convinced of this. So here comes a statement with a
+       Error that should really never be thrown, just to convince TypeScript
+       of the fact that we can afterwards read the properties `message` and
+       `origin`.
+    */
+    if (!hasMaybeMessageAndOrigin(error)) {
+        throw Error('Will never be thrown');
+    }
+
+    return describe(error) + describeOrigin(error.origin);
+};

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,60 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { configureStore } from '@reduxjs/toolkit';
+import { Reducer } from 'redux';
+
+import { reducer as documentation } from './About/documentationSlice';
+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 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,
+    documentation,
+    shortcuts,
+});
+
+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 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;
+}