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

package/src/Toggle/Toggle.tsx

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import React, { FC, ReactNode } from 'react';
+
+import classNames from '../utils/classNames';
+
+import './toggle.scss';
+
+export interface Props {
+    id?: string;
+    title?: string;
+    isToggled: boolean;
+    onToggle?: (isToggled: boolean) => void;
+    label?: ReactNode;
+    labelRight?: boolean;
+    variant?: 'primary' | 'secondary';
+    barColor?: string;
+    barColorToggled?: string;
+    handleColor?: string;
+    handleColorToggled?: string;
+    width?: string;
+    disabled?: boolean;
+    children?: ReactNode;
+}
+
+export const Toggle: FC<Props> = ({
+    id,
+    title,
+    isToggled,
+    onToggle,
+    label,
+    labelRight = false,
+    variant = 'primary',
+    barColor,
+    barColorToggled,
+    handleColor,
+    handleColorToggled,
+    width,
+    disabled = false,
+    children,
+}) => {
+    const isPrimary = variant === 'primary';
+    const isSecondary = variant === 'secondary';
+
+    const handleToggle = () => {
+        if (onToggle) {
+            onToggle(!isToggled);
+        }
+    };
+
+    const [labelText, ...remainingChildren] = Array.isArray(children)
+        ? children
+        : [children || label];
+
+    const labelElement = labelText && (
+        <span className="toggle-label">{labelText}</span>
+    );
+
+    return (
+        <div
+            title={title}
+            className={classNames('toggle', disabled && 'disabled')}
+            style={{ width }}
+        >
+            <label htmlFor={id}>
+                {!labelRight && labelElement}
+                <div
+                    className={classNames(
+                        'toggle-bar',
+                        isPrimary &&
+                            `toggle-bar-primary${isToggled ? '-toggled' : ''}`,
+                        isSecondary &&
+                            `toggle-bar-secondary${isToggled ? '-toggled' : ''}`
+                    )}
+                    style={{
+                        backgroundColor: isToggled ? barColorToggled : barColor,
+                    }}
+                >
+                    <input
+                        id={id}
+                        type="checkbox"
+                        checked={isToggled}
+                        onChange={disabled ? undefined : handleToggle}
+                        aria-checked={isToggled}
+                        disabled={disabled}
+                    />
+                    <span
+                        className={classNames(
+                            'toggle-handle',
+                            isToggled && 'toggle-handle-toggled',
+                            isPrimary &&
+                                `toggle-handle-primary${
+                                    isToggled ? '-toggled' : ''
+                                }`,
+                            isSecondary &&
+                                `toggle-handle-secondary${
+                                    isToggled ? '-toggled' : ''
+                                }`
+                        )}
+                        style={{
+                            backgroundColor: isToggled
+                                ? handleColorToggled
+                                : handleColor,
+                        }}
+                    />
+                </div>
+                {labelRight && labelElement}
+            </label>
+            {remainingChildren.length > 0 && (
+                <div className="toggle-label toggle-label-rest">
+                    {remainingChildren}
+                </div>
+            )}
+        </div>
+    );
+};

package/src/Toggle/toggle.scss

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+@import "../variables";
+
+.toggle {
+  display: flex;
+  flex-direction: column;
+}
+
+.toggle.disabled .toggle-handle {
+  cursor: default;
+}
+
+.toggle-bar {
+  position: relative;
+  font-family: sans-serif;
+  display: flex;
+  flex-direction: row;
+  min-width: 28px;
+  border-radius: 8px;
+  height: 16px;
+}
+
+.toggle-bar-primary {
+  background: $gray-700;
+}
+
+.toggle-bar-primary-toggled {
+  background: $primary;
+}
+
+.toggle-bar-secondary {
+  background: $gray-300;
+}
+
+.toggle-bar-secondary-toggled {
+  background: $primary;
+}
+
+.toggle-handle {
+  position: absolute;
+  transform: translate3d(0px, 0, 0);
+  top: 2px;
+  left: 2px;
+  height: 12px;
+  width: 12px;
+  transition: all 0.2s ease;
+  border-radius: 50%;
+  cursor: pointer;
+  z-index: 1;
+  box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2);
+}
+
+.toggle-handle-toggled {
+  transform: translate3d(12px, 0, 0);
+  transition: all 0.1s ease;
+  transition-property: transform;
+}
+
+.toggle-handle-primary {
+  background: $gray-300;
+}
+
+.toggle-handle-primary-toggled {
+  background: $white;
+}
+
+.toggle-handle-secondary {
+  background: $gray-700;
+}
+
+.toggle-handle-secondary-toggled {
+  background: $white;
+}
+
+.toggle label {
+  display: flex;
+  flex: 1;
+  flex-direction: row;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 0;
+  margin-right: -0.5rem;
+}
+
+.toggle label > * {
+  margin-right: 0.5rem;
+}
+
+.toggle-label {
+  font-size: 0.8rem;
+  white-space: pre-wrap;
+}
+
+.toggle-label-rest {
+  text-align: end;
+}
+
+.toggle input {
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  position: absolute;
+}

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,150 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+import { hideDialog, showDialog } from './ErrorDialog/errorDialogSlice';
+
+export const ErrorDialogActions = { hideDialog, showDialog };
+
+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 NumberInputSliderWithUnit } from './NumberInputWithSlider/NumberInputSliderWithUnit';
+
+export { default as MasonryLayout } from './MasonryLayout/MasonryLayout';
+
+export { default as useStopwatch } from './utils/useStopwatch';
+export { default as useFocusedOnVisible } from './utils/useFocusedOnVisible';
+
+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,
+    persistNickname,
+    getPersistedNickname,
+} from './utils/persistentStore';
+
+export { jprogDeviceSetup } from './Device/jprogOperations';
+
+export { sdfuDeviceSetup } from './Device/sdfuOperations';
+
+export {
+    selectedDevice,
+    getReadbackProtection,
+    persistSerialPortOptions,
+    type Device,
+} from './Device/deviceSlice';
+export {
+    setWaitForDevice,
+    getAutoReselect,
+    getWaitingForDeviceTimeout,
+    getWaitingToAutoReselect,
+    getWaitForDevice,
+} from './Device/deviceAutoSelectSlice';
+export { clearWaitForDevice } from './Device/deviceLister';
+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 type { AppDispatch, AppThunk, NrfConnectState } from './store';
+
+export {
+    type DeviceSetupConfig,
+    type DeviceSetup,
+    prepareDevice,
+} from './Device/deviceSetup';
+
+export {
+    addNewMessage,
+    newCopiedFlashMessage,
+    newInfoFlashMessage,
+    newWarningFlashMessage,
+    newErrorFlashMessage,
+    newSuccessFlashMessage,
+} from './FlashMessage/FlashMessageSlice';
+
+export { inMain as apps } from '../ipc/apps';
+export { inMain as openWindow } from '../ipc/openWindow';
+export { inMain as preventSleep } from '../ipc/preventSleep';

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