@nordicsemiconductor/pc-nrfconnect-shared 102.0.0 → 104.0.0

package/nrfutil/device/batch.ts

@@ -4,31 +4,37 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { v4 as uuid } from 'uuid';
+
 import { TaskEnd } from '../sandboxTypes';
 import { BatchOperationWrapper, Callbacks } from './batchTypes';
 import {
     DeviceCore,
+    DeviceTraits,
+    deviceTraitsToArgs,
     getDeviceSandbox,
     NrfutilDeviceWithSerialnumber,
     ResetKind,
 } from './common';
-import eraseBatch from './eraseBatch';
-import firmwareReadBatch from './firmwareReadBatch';
+import { DeviceBuffer } from './firmwareRead';
 import { DeviceCoreInfo } from './getCoreInfo';
-import getCoreInfoBatch from './getCoreInfoBatch';
 import { FWInfo } from './getFwInfo';
-import getFwInfoBatch from './getFwInfoBatch';
 import { GetProtectionStatusResult } from './getProtectionStatus';
-import getProtectionStatusBatch from './getProtectionStatusBatch';
-import { FirmwareType, ProgrammingOptions } from './program';
-import programBatch from './programBatch';
-import recoverBatch from './recoverBatch';
-import resetBatch from './resetBatch';
+import {
+    FirmwareType,
+    ProgrammingOptions,
+    programmingOptionsToArgs,
+} from './program';
 
-type BatchOperationWrapperUnknown = BatchOperationWrapper<unknown, unknown>;
+type BatchOperationWrapperUnknown = BatchOperationWrapper<unknown>;
+type CallbacksUnknown = Callbacks<unknown>;
 
 export class Batch {
-    private operations: BatchOperationWrapperUnknown[];
+    private operationBatchGeneration: Promise<BatchOperationWrapperUnknown>[] =
+        [];
 
     private collectOperations: {
         callback: (completedTasks: TaskEnd<unknown>[]) => void;
@@ -36,24 +42,63 @@ export class Batch {
         count: number;
     }[] = [];
 
-    constructor(operations?: BatchOperationWrapperUnknown[]) {
-        this.operations = operations ?? [];
+    private enqueueBatchOperationObject(
+        command: string,
+        core: DeviceCore,
+        callbacks?: Callbacks<unknown>,
+        args: string[] = []
+    ) {
+        const getPromise = async () => {
+            const box = await getDeviceSandbox();
+
+            const batchOperation =
+                await box.singleInfoOperationOptionalData<object>(
+                    command,
+                    undefined,
+                    [
+                        '--serial-number', // this is a workaround this param should now be needed with --generate
+                        '123',
+                        '--generate',
+                        '--core',
+                        core,
+                    ].concat(args)
+                );
+
+            return {
+                operation: {
+                    ...batchOperation,
+                },
+                ...callbacks,
+            };
+        };
+
+        this.operationBatchGeneration.push(getPromise());
     }
 
     public erase(core: DeviceCore, callbacks?: Callbacks) {
-        this.operations.push(
-            eraseBatch(core, { callbacks }) as BatchOperationWrapperUnknown
+        this.enqueueBatchOperationObject(
+            'erase',
+            core,
+            callbacks as CallbacksUnknown
         );
 
         return this;
     }
 
     public firmwareRead(core: DeviceCore, callbacks?: Callbacks<Buffer>) {
-        this.operations.push(
-            firmwareReadBatch(core, {
-                callbacks,
-            }) as BatchOperationWrapperUnknown
-        );
+        this.enqueueBatchOperationObject('fw-read', core, {
+            ...callbacks,
+            onTaskEnd: (taskEnd: TaskEnd<DeviceBuffer>) => {
+                if (taskEnd.result === 'success' && taskEnd.data)
+                    callbacks?.onTaskEnd?.({
+                        ...taskEnd,
+                        data: Buffer.from(taskEnd.data.buffer, 'base64'),
+                    });
+                else {
+                    callbacks?.onException?.(new Error('Read failed'));
+                }
+            },
+        } as CallbacksUnknown);
 
         return this;
     }
@@ -62,20 +107,20 @@ export class Batch {
         core: DeviceCore,
         callbacks?: Callbacks<DeviceCoreInfo>
     ) {
-        this.operations.push(
-            getCoreInfoBatch(core, {
-                callbacks,
-            }) as BatchOperationWrapperUnknown
+        this.enqueueBatchOperationObject(
+            'core-info',
+            core,
+            callbacks as CallbacksUnknown
         );
 
         return this;
     }
 
     public getFwInfo(core: DeviceCore, callbacks?: Callbacks<FWInfo>) {
-        this.operations.push(
-            getFwInfoBatch(core, {
-                callbacks,
-            }) as BatchOperationWrapperUnknown
+        this.enqueueBatchOperationObject(
+            'fw-info',
+            core,
+            callbacks as CallbacksUnknown
         );
 
         return this;
@@ -85,10 +130,10 @@ export class Batch {
         core: DeviceCore,
         callbacks?: Callbacks<GetProtectionStatusResult>
     ) {
-        this.operations.push(
-            getProtectionStatusBatch(core, {
-                callbacks,
-            }) as BatchOperationWrapperUnknown
+        this.enqueueBatchOperationObject(
+            'protection-get',
+            core,
+            callbacks as CallbacksUnknown
         );
 
         return this;
@@ -98,32 +143,69 @@ export class Batch {
         firmware: FirmwareType,
         core: DeviceCore,
         programmingOptions?: ProgrammingOptions,
+        deviceTraits?: DeviceTraits,
         callbacks?: Callbacks
     ) {
-        this.operations.push(
-            programBatch(firmware, core, {
-                programmingOptions,
-                callbacks,
-            }) as BatchOperationWrapperUnknown
+        let args = [
+            ...(deviceTraits ? deviceTraitsToArgs(deviceTraits) : []),
+            ...programmingOptionsToArgs(programmingOptions),
+        ];
+        let newCallbacks = { ...callbacks };
+
+        if (typeof firmware === 'string') {
+            args = ['--firmware', firmware].concat(args);
+        } else {
+            const saveTemp = (): string => {
+                let tempFilePath;
+                do {
+                    tempFilePath = path.join(
+                        os.tmpdir(),
+                        `${uuid()}.${firmware.type}`
+                    );
+                } while (fs.existsSync(tempFilePath));
+
+                fs.writeFileSync(tempFilePath, firmware.buffer);
+
+                return tempFilePath;
+            };
+            const tempFilePath = saveTemp();
+            args = ['--firmware', tempFilePath].concat(args);
+
+            newCallbacks = {
+                ...callbacks,
+                onTaskEnd: (taskEnd: TaskEnd<void>) => {
+                    fs.unlinkSync(tempFilePath);
+                    callbacks?.onTaskEnd?.(taskEnd);
+                },
+            } as CallbacksUnknown;
+        }
+
+        this.enqueueBatchOperationObject(
+            'program',
+            core,
+            newCallbacks as CallbacksUnknown,
+            args
         );
 
         return this;
     }
 
     public recover(core: DeviceCore, callbacks?: Callbacks) {
-        this.operations.push(
-            recoverBatch(core, { callbacks }) as BatchOperationWrapperUnknown
+        this.enqueueBatchOperationObject(
+            'recover',
+            core,
+            callbacks as CallbacksUnknown
         );
 
         return this;
     }
 
     public reset(core: DeviceCore, reset?: ResetKind, callbacks?: Callbacks) {
-        this.operations.push(
-            resetBatch(core, {
-                reset,
-                callbacks,
-            }) as BatchOperationWrapperUnknown
+        this.enqueueBatchOperationObject(
+            'reset',
+            core,
+            callbacks as CallbacksUnknown,
+            reset ? ['--reset-kind', reset] : undefined
         );
 
         return this;
@@ -135,7 +217,7 @@ export class Batch {
     ) {
         this.collectOperations.push({
             callback,
-            operationId: this.operations.length - 1,
+            operationId: this.operationBatchGeneration.length - 1,
             count,
         });
 
@@ -149,9 +231,21 @@ export class Batch {
         let beginId = 0;
         let endId = 0;
         const results: TaskEnd<unknown>[] = [];
+        const operations: BatchOperationWrapperUnknown[] = [];
+
+        const promiseResults =
+            await Promise.allSettled<BatchOperationWrapperUnknown>(
+                this.operationBatchGeneration
+            );
+        promiseResults.forEach(r => {
+            if (r.status === 'rejected') {
+                throw r.reason;
+            }
+            operations.push(r.value);
+        });
 
-        const operations = {
-            operations: this.operations.map((operation, index) => ({
+        const batchOperation = {
+            operations: operations.map((operation, index) => ({
                 operationId: index.toString(),
                 ...operation.operation,
             })),
@@ -165,21 +259,21 @@ export class Batch {
                     '--serial-number',
                     device.serialNumber,
                     '--batch-json',
-                    JSON.stringify(operations),
+                    JSON.stringify(batchOperation),
                 ],
                 (progress, task) => {
                     if (task) {
-                        this.operations[endId].onProgress?.(progress, task);
+                        operations[endId].onProgress?.(progress, task);
                     }
                 },
                 onTaskBegin => {
                     beginId += 1;
-                    this.operations[endId].onTaskBegin?.(onTaskBegin);
+                    operations[endId].onTaskBegin?.(onTaskBegin);
                 },
                 taskEnd => {
                     results.push(taskEnd);
 
-                    this.operations[endId].onTaskEnd?.(taskEnd);
+                    operations[endId].onTaskEnd?.(taskEnd);
 
                     this.collectOperations
                         .filter(operation => operation.operationId === endId)
@@ -204,12 +298,12 @@ export class Batch {
                         .map(e => `error: ${e.error}, message: ${e.message}`)
                         .join('\n')}`
                 );
-                this.operations[endId].onException?.(error);
+                operations[endId].onException?.(error);
                 throw error;
             }
         } catch (error) {
             if (beginId !== endId) {
-                this.operations[beginId].onException?.(error as Error);
+                operations[beginId].onException?.(error as Error);
             }
             throw error;
         }

package/nrfutil/device/batchTypes.ts

@@ -13,8 +13,8 @@ import {
     ProgrammingOptions,
 } from './program';
 
-export interface BatchOperationWrapper<OperationType, T = void> {
-    operation: GenericOperation<OperationType>;
+export interface BatchOperationWrapper<T = void> {
+    operation: object;
     onProgress?: (progress: Progress, task?: Task) => void;
     onTaskBegin?: TaskBeginCallback;
     onTaskEnd?: TaskEndCallback<T>;

package/nrfutil/device/common.ts

@@ -205,12 +205,6 @@ export const getDeviceSandbox = async () => {
         deviceSandbox = await promiseDeviceSandbox;
 
         deviceSandbox.onLogging(evt => {
-            if (
-                process.env.NODE_ENV === 'production' &&
-                deviceSandbox?.logLevel !== 'trace'
-            )
-                return;
-
             const deviceLogger = getNrfutilLogger();
             switch (evt.level) {
                 case 'TRACE':
@@ -238,10 +232,11 @@ export const getDeviceSandbox = async () => {
             }
         });
 
-        // Temporary until nrfutil fixes off log level NRFU-616
-        // const fallbackLevel =
-        //     process.env.NODE_ENV === 'production' ? 'off' : 'error';
-        deviceSandbox.setLogLevel(getIsLoggingVerbose() ? 'trace' : 'error');
+        const fallbackLevel =
+            process.env.NODE_ENV === 'production' ? 'off' : 'error';
+        deviceSandbox.setLogLevel(
+            getIsLoggingVerbose() ? 'trace' : fallbackLevel
+        );
         // Only the first reset after selecting "reset with verbose logging" is relevant
         persistIsLoggingVerbose(false);
     }

package/nrfutil/device/device.ts

@@ -31,11 +31,10 @@ const setLogLevel = async (level: LogLevel) => {
 
 const setVerboseLogging = async (verbose: boolean) => {
     const sandbox = await getDeviceSandbox();
-    // Temporary until nrfutil fixes off log level NRFU-616
-    // const fallbackLevel =
-    //     process.env.NODE_ENV === 'production' ? 'off' : 'error';
+    const fallbackLevel =
+        process.env.NODE_ENV === 'production' ? 'off' : 'error';
 
-    sandbox.setLogLevel(verbose ? 'trace' : 'error');
+    sandbox.setLogLevel(verbose ? 'trace' : fallbackLevel);
 };
 const getModuleVersion = async () => {
     const sandbox = await getDeviceSandbox();

package/nrfutil/device/list.ts

@@ -39,8 +39,7 @@ export default async (
     },
     timeout = 3000
 ) => {
-    const args: string[] = [];
-    args.concat(deviceTraitsToArgs(traits));
+    const args: string[] = deviceTraitsToArgs(traits);
 
     if (onHotplugEvent) {
         args.push('--hotplug');

package/nrfutil/device/program.ts

@@ -72,7 +72,7 @@ const deviceTraitsToArgs = (traits: DeviceTraits) => {
     return args;
 };
 
-const programmingOptionsToArgs = (options?: ProgrammingOptions) => {
+export const programmingOptionsToArgs = (options?: ProgrammingOptions) => {
     if (!options) return [];
 
     const args: string[] = [];

package/nrfutil/sandbox.ts

@@ -449,6 +449,26 @@ export class NrfutilSandbox {
         throw new Error('Unexpected result');
     };
 
+    public singleInfoOperationOptionalData = async <T = void>(
+        command: string,
+        controller?: AbortController,
+        args: string[] = []
+    ) => {
+        const results = await this.execSubcommand<T>(
+            command,
+            args,
+            undefined,
+            undefined,
+            undefined,
+            controller
+        );
+
+        if (results.info.length === 1) {
+            return results.info[0];
+        }
+        throw new Error('Unexpected result');
+    };
+
     public onLogging = (handler: (logging: LogMessage) => void) => {
         this.onLoggingHandlers.push(handler);
 

package/nrfutil/sandboxTypes.ts

@@ -82,6 +82,11 @@ type NrfutilJsonBegin = {
     data: TaskBegin;
 };
 
+type NrfutilJsonInfo<T> = {
+    type: 'info';
+    data: T;
+};
+
 type NrfutilJsonBatch<T = unknown> = {
     batch: {
         id: string;
@@ -98,10 +103,7 @@ export type NrfutilJsonBatchUpdate<T = unknown> = {
 };
 
 export type NrfutilJson<T = unknown> =
-    | {
-          type: 'info';
-          data: T;
-      }
+    | NrfutilJsonInfo<T>
     | NrfutilJsonBegin
     | NrfutilJsonEnd<T>
     | NrfutilJsonProgress

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nordicsemiconductor/pc-nrfconnect-shared",
-    "version": "102.0.0",
+    "version": "104.0.0",
     "description": "Shared commodities for developing pc-nrfconnect-* packages",
     "repository": {
         "type": "git",

package/src/App/App.tsx

@@ -24,11 +24,11 @@ import {
 } from '../Device/deviceSlice';
 import ErrorBoundary from '../ErrorBoundary/ErrorBoundary';
 import ErrorDialog from '../ErrorDialog/ErrorDialog';
+import FeedbackPane, { FeedbackPaneProps } from '../Feedback/FeedbackPane';
 import FlashMessages from '../FlashMessage/FlashMessage';
 import LogViewer from '../Log/LogViewer';
 import logger from '../logging';
 import NavBar from '../NavBar/NavBar';
-import FeedbackPane, { FeedbackPaneProps } from '../Panes/FeedbackPane';
 import classNames from '../utils/classNames';
 import packageJson from '../utils/packageJson';
 import { getPersistedCurrentPane } from '../utils/persistentStore';

package/src/Button/Button.tsx

@@ -39,37 +39,36 @@ const Button: React.FC<ButtonProps> = ({
     title,
     size = 'sm',
 }) => (
-    <div className={`tw-preflight ${className}`}>
-        <button
-            type="button"
-            id={id}
-            className={`${classNames(
-                size === 'sm' && 'tw-h-6 tw-px-2 tw-text-xs',
-                size === 'lg' && 'tw-h-8 tw-px-4 tw-text-sm',
-                size === 'xl' && 'tw-h-8 tw-px-4 tw-text-base',
-                variant === 'primary' &&
-                    'tw-bg-nordicBlue tw-text-white active:enabled:tw-bg-nordicBlue-700',
-                variant === 'secondary' &&
-                    'tw-border tw-border-gray-700 tw-bg-white tw-text-gray-700  active:enabled:tw-bg-gray-50',
-                variant === 'success' &&
-                    'tw-bg-green tw-text-white  active:enabled:tw-bg-green-700',
-                variant === 'info' &&
-                    'tw-bg-nordicBlue tw-text-white active:enabled:tw-bg-nordicBlue-700',
-                variant === 'warning' &&
-                    'tw-bg-orange tw-text-white active:enabled:tw-bg-orange-700',
-                variant === 'danger' &&
-                    'tw-bg-red tw-text-white active:enabled:tw-bg-red-700',
-                variant === 'link-button' &&
-                    'tw-border tw-border-nordicBlue tw-bg-white tw-text-nordicBlue active:enabled:tw-bg-gray-50',
-                className
-            )}`}
-            disabled={disabled}
-            onClick={onClick}
-            title={title}
-        >
-            {children}
-        </button>
-    </div>
+    <button
+        type="button"
+        id={id}
+        className={`${classNames(
+            'tw-preflight',
+            size === 'sm' && 'tw-h-6 tw-px-2 tw-text-xs',
+            size === 'lg' && 'tw-h-8 tw-px-4 tw-text-sm',
+            size === 'xl' && 'tw-h-8 tw-px-4 tw-text-base',
+            variant === 'primary' &&
+                'tw-bg-nordicBlue tw-text-white active:enabled:tw-bg-nordicBlue-700',
+            variant === 'secondary' &&
+                'tw-border tw-border-gray-700 tw-bg-white tw-text-gray-700  active:enabled:tw-bg-gray-50',
+            variant === 'success' &&
+                'tw-bg-green tw-text-white  active:enabled:tw-bg-green-700',
+            variant === 'info' &&
+                'tw-bg-nordicBlue tw-text-white active:enabled:tw-bg-nordicBlue-700',
+            variant === 'warning' &&
+                'tw-bg-orange tw-text-white active:enabled:tw-bg-orange-700',
+            variant === 'danger' &&
+                'tw-bg-red tw-text-white active:enabled:tw-bg-red-700',
+            variant === 'link-button' &&
+                'tw-border tw-border-nordicBlue tw-bg-white tw-text-nordicBlue active:enabled:tw-bg-gray-50',
+            className
+        )}`}
+        disabled={disabled}
+        onClick={onClick}
+        title={title}
+    >
+        {children}
+    </button>
 );
 
 export default Button;

package/src/Dialog/Dialog.tsx

@@ -82,7 +82,9 @@ Dialog.Body = ({ children }: { children: ReactNode }) => (
 );
 
 Dialog.Footer = ({ children }: { children: ReactNode }) => (
-    <Modal.Footer>{children}</Modal.Footer>
+    <Modal.Footer className="tw-preflight tw-flex tw-flex-row-reverse tw-justify-start tw-gap-1 tw-border-none tw-p-4">
+        {children}
+    </Modal.Footer>
 );
 
 export interface DialogButtonProps {

package/src/Dialog/dialog.scss

@@ -40,12 +40,4 @@
             font-size: 14px;
         }
     }
-
-    .modal-footer {
-        padding: 16px;
-        border: 0 transparent;
-        flex-direction: row-reverse;
-        justify-content: end;
-        display: flex;
-    }
 }

package/src/{Panes → Feedback}/FeedbackPane.tsx

@@ -9,8 +9,8 @@ import React, { useMemo, useState } from 'react';
 import Button from '../Button/Button';
 import Dropdown, { DropdownItem } from '../Dropdown/Dropdown';
 import logger from '../logging';
-import { isDevelopment } from '../utils/environment';
-import packageJson from '../utils/packageJson';
+import describeError from '../logging/describeError';
+import sendFeedback from './sendFeedback';
 
 export interface FeedbackPaneProps {
     categories?: string[];
@@ -136,49 +136,18 @@ export default ({ categories }: FeedbackPaneProps) => {
     );
 };
 
-const formURL =
-    isDevelopment === true
-        ? 'https://formkeep.com/f/87deb409a565'
-        : 'https://formkeep.com/f/36b394b92851';
-
 const handleFormData = async (
     feedback: string,
     setResponse: (response: boolean) => void,
     category?: string
 ) => {
-    const data: Record<string, unknown> = {
-        name: getAppName(),
-        feedback,
-        platform: process.platform,
-    };
-
-    if (category && category !== 'Select a category') {
-        data.category = category;
-    }
-
     try {
-        const response = await fetch(formURL, {
-            method: 'POST',
-            body: JSON.stringify(data),
-            headers: {
-                'Content-Type': 'application/json',
-                enctype: 'multipart/form-data',
-            },
-        });
+        await sendFeedback(feedback, category);
 
-        if (response.ok) {
-            setResponse(true);
-            return;
-        }
-
-        logger.error(
-            `FeedbackForm: Server responded with status code ${response.status}`
-        );
+        setResponse(true);
     } catch (error: unknown) {
         logger.error(
-            `FeedbackForm: Could not send feedback. ${JSON.stringify(error)}`
+            `FeedbackForm: Could not send feedback. ${describeError(error)}`
         );
     }
 };
-
-const getAppName = () => packageJson().name;

package/src/Feedback/sendFeedback.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { isDevelopment } from '../utils/environment';
+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(),
+        feedback,
+        platform: process.platform,
+    };
+
+    if (category && category !== 'Select a category') {
+        data.category = category;
+    }
+
+    const response = await fetch(formURL, {
+        method: 'POST',
+        body: JSON.stringify(data),
+        headers: {
+            'Content-Type': 'application/json',
+            enctype: 'multipart/form-data',
+        },
+    });
+
+    if (response.ok) {
+        return;
+    }
+
+    throw new Error(`Server responded with status code ${response.status}`);
+};