@nordicsemiconductor/pc-nrfconnect-shared 121.0.0 → 123.0.0

package/src/Device/deviceSlice.ts

@@ -8,7 +8,8 @@ import { createSlice, PayloadAction } from '@reduxjs/toolkit';
 import type { AutoDetectTypes } from '@serialport/bindings-cpp';
 import { SerialPortOpenOptions } from 'serialport';
 
-import { NrfutilDevice, SerialPort } from '../../nrfutil/device/common';
+import { DeviceInfo } from '../../nrfutil';
+import { NrfutilDevice } from '../../nrfutil/device/common';
 import type { RootState } from '../store';
 import {
     getPersistedIsFavorite,
@@ -20,65 +21,83 @@ import {
 } from '../utils/persistentStore';
 
 export interface Device extends NrfutilDevice {
-    serialNumber: string;
-    boardVersion?: string;
     nickname?: string;
-    serialport?: SerialPort;
     favorite?: boolean;
-    id: number;
     persistedSerialPortOptions?: SerialPortOpenOptions<AutoDetectTypes>;
 }
 
+export interface DeviceWithSerialNumber extends Device {
+    serialNumber: string;
+}
+
+export const isDeviceWithSerialNumber = (
+    device: Device
+): device is DeviceWithSerialNumber =>
+    !!(device as DeviceWithSerialNumber).serialNumber;
+
+const findDeviceItem = (
+    devices: Device[],
+    id: number,
+    serialNumber?: string | null
+) => {
+    const index = devices.findIndex(
+        d => d.id === id || d.serialNumber === serialNumber
+    );
+
+    return { index, device: devices[index] };
+};
+
 const updateDevice = (
     state: DeviceState,
-    serialNumber: string,
-    updateToMergeIn: Partial<Device>
+    updateToMergeIn: Partial<Device>,
+    id: number,
+    serialNumber?: string | null
 ) => {
-    const device = state.devices.get(serialNumber);
+    const device = findDeviceItem(state.devices, id, serialNumber).device;
     if (device) {
         Object.assign(device, updateToMergeIn);
     }
 };
 
 export interface DeviceState {
-    devices: Map<string, Device>;
-    deviceInfo: Device | null;
-    selectedSerialNumber: string | null;
+    devices: Device[];
     readbackProtection: 'unknown' | 'protected' | 'unprotected';
+    selectedDevice?: Device;
+    selectedDeviceInfo?: DeviceInfo;
 }
 
 const initialState: DeviceState = {
-    devices: new Map(),
-    selectedSerialNumber: null,
-    deviceInfo: null,
+    devices: [],
     readbackProtection: 'unknown',
 };
 
 const setPersistedData = (device: Device) => {
-    const newDevice = {
-        ...device,
-        favorite: getPersistedIsFavorite(device.serialNumber),
-        nickname: getPersistedNickname(device.serialNumber),
-    };
-
-    const persistedSerialPortSettings = getPersistedSerialPortSettings(
-        newDevice.serialNumber
-    );
-
-    if (persistedSerialPortSettings) {
-        const path =
-            newDevice.serialPorts?.[persistedSerialPortSettings.vComIndex]
-                ?.comName;
-
-        if (path) {
-            newDevice.persistedSerialPortOptions = {
-                ...persistedSerialPortSettings.serialPortOptions,
-                path,
-            };
+    if (device.serialNumber) {
+        const newDevice = { ...device };
+        newDevice.favorite = getPersistedIsFavorite(device.serialNumber);
+        newDevice.nickname = getPersistedNickname(device.serialNumber);
+
+        const persistedSerialPortSettings = getPersistedSerialPortSettings(
+            device.serialNumber
+        );
+
+        if (persistedSerialPortSettings) {
+            const path =
+                newDevice.serialPorts?.[persistedSerialPortSettings.vComIndex]
+                    ?.comName;
+
+            if (path) {
+                newDevice.persistedSerialPortOptions = {
+                    ...persistedSerialPortSettings.serialPortOptions,
+                    path,
+                };
+            }
         }
+
+        return newDevice;
     }
 
-    return newDevice;
+    return device;
 };
 
 const slice = createSlice({
@@ -89,104 +108,158 @@ const slice = createSlice({
          * Indicates that a device has been selected.
          */
         selectDevice: (state, action: PayloadAction<Device>) => {
-            state.selectedSerialNumber = action.payload.serialNumber;
+            state.selectedDevice = action.payload;
+        },
+
+        setSelectedDeviceInfo: (
+            state,
+            action: PayloadAction<DeviceInfo | undefined>
+        ) => {
+            state.selectedDeviceInfo = action.payload;
         },
 
         /*
          * Indicates that the currently selected device has been deselected.
          */
         deselectDevice: state => {
-            state.selectedSerialNumber = null;
-            state.deviceInfo = null;
+            state.selectedDevice = undefined;
+            state.selectedDeviceInfo = undefined;
             state.readbackProtection = 'unknown';
         },
 
         addDevice: (state, action: PayloadAction<Device>) => {
-            state.devices.set(
-                action.payload.serialNumber,
-                setPersistedData(action.payload)
+            const index = state.devices.findIndex(
+                item =>
+                    item.serialNumber === action.payload.serialNumber ||
+                    item.id === action.payload.id
             );
+
+            const device = setPersistedData(action.payload);
+            if (index !== -1) {
+                state.devices[index] = device;
+            } else {
+                state.devices.push(device);
+            }
         },
 
         persistSerialPortOptions: (
             state,
             action: PayloadAction<SerialPortOpenOptions<AutoDetectTypes>>
         ) => {
-            if (state.selectedSerialNumber === null) return;
+            if (!state.selectedDevice) return;
 
-            const selectedDevice = state.devices.get(
-                state.selectedSerialNumber
-            );
+            const selectedDevice = state.selectedDevice;
 
             if (selectedDevice) {
                 const vComIndex = selectedDevice.serialPorts?.findIndex(
                     e => e.comName === action.payload.path
                 );
 
-                if (vComIndex !== undefined && vComIndex !== -1) {
+                if (
+                    selectedDevice.serialNumber && // we want to disregard comparing devices with no sn
+                    vComIndex !== undefined &&
+                    vComIndex !== -1
+                ) {
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars -- used to filter out the path property
                     const { path: _, ...serialPortOptions } = action.payload;
 
                     persistSerialPortSettingsToStore(
-                        state.selectedSerialNumber,
+                        selectedDevice.serialNumber,
                         {
                             serialPortOptions,
                             vComIndex,
                         }
                     );
 
-                    state.devices.set(state.selectedSerialNumber, {
-                        ...selectedDevice,
-                        persistedSerialPortOptions: action.payload,
-                    });
+                    updateDevice(
+                        state,
+                        {
+                            ...selectedDevice,
+                            persistedSerialPortOptions: action.payload,
+                        },
+                        selectedDevice.id,
+                        selectedDevice.serialNumber
+                    );
                 }
             }
         },
 
         removeDevice: (state, action: PayloadAction<Device>) => {
-            state.devices.delete(action.payload.serialNumber);
-
-            if (state.selectedSerialNumber === action.payload.serialNumber) {
-                state.selectedSerialNumber = null;
-                state.deviceInfo = null;
+            const index = findDeviceItem(
+                state.devices,
+                action.payload.id,
+                action.payload.serialNumber
+            ).index;
+            state.devices.splice(index, 1);
+
+            if (action.payload.id === state.selectedDevice?.id) {
+                state.selectedDevice = undefined;
+                state.selectedDeviceInfo = undefined;
             }
         },
 
-        toggleDeviceFavorited: (state, action: PayloadAction<string>) => {
-            const newFavoriteState = !state.devices.get(action.payload)
-                ?.favorite;
-            persistIsFavorite(action.payload, newFavoriteState);
-            updateDevice(state, action.payload, {
-                favorite: newFavoriteState,
-            });
+        toggleDeviceFavorited: (state, action: PayloadAction<Device>) => {
+            const device = findDeviceItem(
+                state.devices,
+                action.payload.id,
+                action.payload.serialNumber
+            ).device;
+
+            if (!device.serialNumber) return;
+
+            const newFavoriteState = !device.favorite;
+
+            persistIsFavorite(device.serialNumber, newFavoriteState);
+            updateDevice(
+                state,
+                {
+                    favorite: newFavoriteState,
+                },
+                action.payload.id,
+                action.payload.serialNumber
+            );
         },
 
         setDeviceNickname: {
-            prepare: (serialNumber: string, nickname: string) => ({
-                payload: { serialNumber, nickname },
+            prepare: (device: Device, nickname: string) => ({
+                payload: { device, nickname },
             }),
             reducer: (
                 state,
                 action: PayloadAction<{
-                    serialNumber: string;
+                    device: Device;
                     nickname: string;
                 }>
             ) => {
+                if (!action.payload.device.serialNumber) return;
+
                 persistNickname(
-                    action.payload.serialNumber,
+                    action.payload.device.serialNumber,
                     action.payload.nickname
                 );
-                updateDevice(state, action.payload.serialNumber, {
-                    nickname: action.payload.nickname,
-                });
+                updateDevice(
+                    state,
+                    {
+                        nickname: action.payload.nickname,
+                    },
+                    action.payload.device.id,
+                    action.payload.device.serialNumber
+                );
             },
         },
 
-        resetDeviceNickname: (state, action: PayloadAction<string>) => {
-            persistNickname(action.payload, '');
-            updateDevice(state, action.payload, {
-                nickname: '',
-            });
+        resetDeviceNickname: (state, action: PayloadAction<Device>) => {
+            if (!action.payload.serialNumber) return;
+
+            persistNickname(action.payload.serialNumber, '');
+            updateDevice(
+                state,
+                {
+                    nickname: '',
+                },
+                action.payload.id,
+                action.payload.serialNumber
+            );
         },
 
         setReadbackProtected: (
@@ -204,6 +277,7 @@ export const {
         deselectDevice,
         resetDeviceNickname,
         selectDevice,
+        setSelectedDeviceInfo,
         addDevice,
         removeDevice,
         setDeviceNickname,
@@ -213,22 +287,21 @@ export const {
     },
 } = slice;
 
-export const getDevice = (serialNumber: string) => (state: RootState) =>
-    state.device.devices.get(serialNumber);
+export const getDevice = (state: RootState, serialNumber: string) =>
+    state.device.devices.find(d => d.serialNumber === serialNumber);
 
 export const getDevices = (state: RootState) => state.device.devices;
 
 export const deviceIsSelected = (state: RootState) =>
-    state.device.selectedSerialNumber != null;
+    !!state.device.selectedDevice;
+
+export const selectedDevice = (state: RootState) => state.device.selectedDevice;
 
-export const selectedDevice = (state: RootState) =>
-    state.device.selectedSerialNumber !== null
-        ? state.device.devices.get(state.device.selectedSerialNumber)
-        : undefined;
+export const selectedDeviceInfo = (state: RootState) =>
+    state.device.selectedDevice ? state.device.selectedDeviceInfo : undefined;
 
-export const deviceInfo = (state: RootState) => state.device.deviceInfo;
 export const selectedSerialNumber = (state: RootState) =>
-    state.device.selectedSerialNumber;
+    state.device.selectedDevice?.serialNumber;
 
 export const getReadbackProtection = (state: RootState) =>
     state.device.readbackProtection;

package/src/Device/jprogOperations.ts

@@ -5,6 +5,7 @@
  */
 
 import NrfutilDeviceLib from '../../nrfutil/device/device';
+import { DeviceInfo } from '../../nrfutil/device/deviceInfo';
 import { FWInfo } from '../../nrfutil/device/getFwInfo';
 import logger from '../logging';
 import type { AppThunk, RootState } from '../store';
@@ -18,14 +19,15 @@ const getDeviceReadProtection = async (
     readbackProtection: 'unknown' | 'protected' | 'unprotected';
 }> => {
     try {
+        logger.info('Checking readback protection on device');
         const info = await NrfutilDeviceLib.getFwInfo(device);
         return {
             fwInfo: info,
             readbackProtection: 'unprotected',
         };
-    } catch (error) {
-        // @ts-expect-error Wrongly typed in device lib at the moment
-        if (error.error_code === 24) {
+    } catch (e) {
+        const error = e as Error;
+        if (error.message.includes('NotAvailableBecauseProtection')) {
             logger.warn(
                 'Readback protection on device enabled. Unable to verify that the firmware version is correct.'
             );
@@ -49,29 +51,50 @@ const programDeviceWithFw =
     ): AppThunk<RootState, Promise<Device>> =>
     async (dispatch, getState) => {
         try {
-            if (getState().device.readbackProtection === 'protected') {
-                logger.info('Recovering device');
-                onProgress(0, 'Recovering device');
-                await NrfutilDeviceLib.recover(device, 'Application');
+            const batch = NrfutilDeviceLib.batch();
+            if (getState().device.readbackProtection !== 'unprotected') {
+                batch.recover('Application', {
+                    onTaskBegin: () =>
+                        logger.info(`Device protected, recovering device`),
+                    onTaskEnd: () => logger.info(`Finished recovering device.`),
+                    onException: () =>
+                        logger.error(`Failed to recover device.`),
+                    onProgress: progress => {
+                        onProgress(
+                            progress.totalProgressPercentage,
+                            'Recovering device'
+                        );
+                    },
+                });
             }
 
-            logger.debug(
-                `Programming ${device.serialNumber} with ${selectedFw.fw}`
-            );
-            await NrfutilDeviceLib.program(
-                device,
-                selectedFw.fw,
-                progress => {
+            batch.program(selectedFw.fw, 'Application', undefined, undefined, {
+                onTaskBegin: () => logger.info(`Programming device`),
+                onTaskEnd: () => logger.info(`Finished programming device.`),
+                onException: () => logger.error(`Failed to program device.`),
+                onProgress: progress => {
                     onProgress(
                         progress.totalProgressPercentage,
                         progress.message ?? 'programming'
                     );
                 },
-                'Application'
-            );
-            logger.debug(`Resetting ${device.serialNumber}`);
-            onProgress(100, 'Resetting device');
+            });
+
+            batch.reset('Application', undefined, {
+                onTaskBegin: () => logger.info(`Resting device`),
+                onTaskEnd: () => logger.info(`Finished resting device.`),
+                onException: () => logger.error(`Failed to reset device.`),
+                onProgress: progress => {
+                    onProgress(
+                        progress.totalProgressPercentage,
+                        'Resetting device'
+                    );
+                },
+            });
+
+            await batch.run(device);
             await NrfutilDeviceLib.reset(device);
+            onProgress(0, 'Updating readback protection');
             const { readbackProtection } = await getDeviceReadProtection(
                 device
             );
@@ -88,12 +111,18 @@ const programDeviceWithFw =
         return device;
     };
 
-const firmwareOptions = (device: Device, firmware: JprogEntry[]) =>
+const firmwareOptions = (
+    device: Device,
+    firmware: JprogEntry[],
+    deviceInfo?: DeviceInfo
+) =>
     firmware.filter(fw => {
-        const family = (device.jlink?.deviceFamily || '').toLowerCase();
-        const deviceType = (device.jlink?.deviceVersion || '').toLowerCase();
+        const family = (device.devkit?.deviceFamily || '').toLowerCase();
+        const deviceType = (
+            deviceInfo?.jlink?.deviceVersion || ''
+        ).toLowerCase();
         const shortDeviceType = deviceType.split('_').shift();
-        const boardVersion = (device.jlink?.boardVersion || '').toLowerCase();
+        const boardVersion = (device.devkit?.boardVersion || '').toLowerCase();
 
         const key = fw.key.toLowerCase();
         return (
@@ -108,11 +137,11 @@ export const jprogDeviceSetup = (
     firmware: JprogEntry[],
     needSerialport = false
 ): DeviceSetup => ({
-    supportsProgrammingMode: (device: Device) =>
+    supportsProgrammingMode: device =>
         (needSerialport === !!device.traits.serialPorts || !needSerialport) &&
         !!device.traits.jlink,
-    getFirmwareOptions: device =>
-        firmwareOptions(device, firmware).map(firmwareOption => ({
+    getFirmwareOptions: (device, deviceInfo) =>
+        firmwareOptions(device, firmware, deviceInfo).map(firmwareOption => ({
             key: firmwareOption.key,
             description: firmwareOption.description,
             programDevice: onProgress => dispatch =>
@@ -120,8 +149,8 @@ export const jprogDeviceSetup = (
                     programDeviceWithFw(device, firmwareOption, onProgress)
                 ),
         })),
-    isExpectedFirmware: (device: Device) => dispatch => {
-        const fwVersions = firmwareOptions(device, firmware);
+    isExpectedFirmware: (device, deviceInfo) => dispatch => {
+        const fwVersions = firmwareOptions(device, firmware, deviceInfo);
         if (fwVersions.length === 0) {
             return Promise.resolve({
                 device,

package/src/Device/sdfuOperations.ts

@@ -46,8 +46,9 @@ export const isDeviceInDFUBootloader = (device: Device) => {
             d.idProduct === NORDIC_DFU_PRODUCT_ID
         );
     }
-    if (device.serialport) {
-        const { vendorId, productId } = device.serialport;
+
+    if (device.serialPorts && device.serialPorts[0]) {
+        const { vendorId, productId } = device.serialPorts[0];
         return vendorId === '1915' && productId?.toUpperCase() === '521F';
     }
     return false;
@@ -410,9 +411,7 @@ const programInDFUBootloader =
         onFail: (reason?: unknown) => void
     ): AppThunk<RootState, Promise<void>> =>
     async dispatch => {
-        logger.debug(
-            `${device.serialNumber} on ${device.serialport?.comName} is now in DFU-Bootloader...`
-        );
+        logger.debug(`${device.serialNumber} on is now in DFU-Bootloader...`);
         const { application, softdevice } = dfu;
         const params: Partial<InitPacket> = dfu.params || {};
 
@@ -545,9 +544,9 @@ export const sdfuDeviceSetup = (
     dfuFirmware: DfuEntry[],
     needSerialport = false
 ): DeviceSetup => ({
-    supportsProgrammingMode: (device: Device) =>
-        ((!!device.dfuTriggerVersion &&
-            device.dfuTriggerVersion.semVer.length > 0) ||
+    supportsProgrammingMode: (device, deviceInfo) =>
+        ((!!deviceInfo?.dfuTriggerVersion &&
+            deviceInfo.dfuTriggerVersion.semVer.length > 0) ||
             isDeviceInDFUBootloader(device)) &&
         (needSerialport === device.traits.serialPorts || !needSerialport),
     getFirmwareOptions: device =>
@@ -559,31 +558,26 @@ export const sdfuDeviceSetup = (
                     programDeviceWithFw(device, firmwareOption, onProgress)
                 ),
         })),
-    isExpectedFirmware: (device: Device) => () =>
-        new Promise<{
-            device: Device;
-            validFirmware: boolean;
-        }>(resolve => {
-            if (device.dfuTriggerVersion) {
-                logger.debug(
-                    'Device has DFU trigger interface, the device is in Application mode'
-                );
+    isExpectedFirmware: (device, deviceInfo) => () => {
+        if (deviceInfo?.dfuTriggerVersion) {
+            logger.debug(
+                'Device has DFU trigger interface, the device is in Application mode'
+            );
 
-                const { semVer } = device.dfuTriggerVersion;
+            const { semVer } = deviceInfo.dfuTriggerVersion;
 
-                resolve({
-                    device,
-                    validFirmware:
-                        dfuFirmware.filter(fw => fw.semver === semVer).length >
-                        0,
-                });
-            } else {
-                resolve({
-                    device,
-                    validFirmware: false,
-                });
-            }
-        }),
+            return Promise.resolve({
+                device,
+                validFirmware:
+                    dfuFirmware.filter(fw => fw.semver === semVer).length > 0,
+            });
+        }
+
+        return Promise.resolve({
+            device,
+            validFirmware: false,
+        });
+    },
     tryToSwitchToApplicationMode: device => dispatch =>
         new Promise<Device>((resolve, reject) => {
             dispatch(switchToApplicationMode(device, resolve, reject));

package/src/ErrorBoundary/ErrorBoundary.tsx

@@ -13,27 +13,20 @@ import FactoryResetButton from '../FactoryReset/FactoryResetButton';
 import { CollapsibleGroup } from '../SidePanel/Group';
 import Spinner from '../Spinner/Spinner';
 import { openUrl } from '../utils/open';
-import packageJson from '../utils/packageJson';
+import { packageJson } from '../utils/packageJson';
 import { getAppSpecificStore as store } from '../utils/persistentStore';
 import { generateSystemReport } from '../utils/systemReport';
-import {
-    init as initGA,
-    isEnabled,
-    isInitialized as isGAInitialized,
-    sendErrorReport,
-} from '../utils/usageData';
+import usageData from '../utils/usageData';
 import bugIcon from './bug.svg';
 
 import './error-boundary.scss';
 
 const sendGAEvent = (error: string) => {
-    if (!isEnabled()) {
+    if (!usageData.isEnabled()) {
         return;
     }
-    if (!isGAInitialized()) {
-        initGA(packageJson());
-    }
-    sendErrorReport(error);
+
+    usageData.sendErrorReport(error);
 };
 
 interface Props {
@@ -97,7 +90,8 @@ class ErrorBoundary extends React.Component<
             return children;
         }
 
-        const appDisplayName = appName || packageJson().displayName;
+        const appDisplayName =
+            appName || packageJson().displayName || packageJson().name;
 
         return (
             <div className="error-boundary__container">

package/src/Feedback/sendFeedback.ts

@@ -5,18 +5,16 @@
  */
 
 import { isDevelopment } from '../utils/environment';
-import packageJson from '../utils/packageJson';
+import { packageJson } from '../utils/packageJson';
 
 const formURL =
     isDevelopment === true
         ? 'https://formkeep.com/f/87deb409a565'
         : 'https://formkeep.com/f/36b394b92851';
 
-const getAppName = () => packageJson().name;
-
 export default async (feedback: string, category?: string) => {
     const data: Record<string, unknown> = {
-        name: getAppName(),
+        name: packageJson().name,
         feedback,
         platform: process.platform,
     };

package/src/InlineInput/NumberInlineInput.tsx

@@ -19,7 +19,7 @@ import InlineInput from './InlineInput';
 
 import './number-inline-input.scss';
 
-export interface NumberInlineInput {
+interface NumberInlineInput {
     disabled?: boolean;
     value: number;
     range: RangeOrValues;