@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1

package/typings/generated/src/utils/open.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Open a file in the default text application, depending on the user's OS.
+ *
+ * @param {string} filePath path to the file to open.
+ * @returns {void}
+ */
+declare function openFile(filePath: string): void;
+/**
+ * Open a URL in the user's default web browser.
+ *
+ * @param {string} url The URL to open.
+ * @returns {void}
+ */
+declare function openUrl(url: string): void;
+export { openFile, openUrl };

package/typings/generated/src/utils/packageJson.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson } from './AppTypes';
+export declare const loadPackageJson: (packageJsonPath: string) => void;
+declare const _default: () => PackageJson;
+export default _default;

package/typings/generated/src/utils/persistentStore.d.ts

@@ -0,0 +1,35 @@
+import type { AutoDetectTypes } from '@serialport/bindings-cpp';
+import Store from 'electron-store';
+import { SerialPortOpenOptions } from 'serialport';
+export interface SerialSettings {
+    serialPortOptions: Omit<SerialPortOpenOptions<AutoDetectTypes>, 'path'>;
+    lastUpdated: number;
+    vComIndex: number;
+}
+export interface TerminalSettings {
+    lineMode: boolean;
+    echoOnShell: boolean;
+    lineEnding: string;
+    clearOnSend: boolean;
+}
+export declare const persistNickname: (serialNumber: string, nickname: string) => void;
+export declare const getPersistedNickname: (serialNumber: string) => string;
+export declare const persistIsFavorite: (serialNumber: string, value: boolean) => void;
+export declare const getPersistedIsFavorite: (serialNumber: string) => boolean;
+export declare const persistSerialPortSettings: (serialNumber: string, serialPortSettings: Omit<SerialSettings, 'lastUpdated'>) => void;
+export declare const getPersistedSerialPortSettings: (serialNumber: string) => SerialSettings | undefined;
+export declare const persistTerminalSettings: (serialNumber: string, vComIndex: number, terminalSettings: TerminalSettings) => void;
+export declare const getPersistedTerminalSettings: (serialNumber: string, vComIndex: number) => TerminalSettings | undefined;
+export declare const persistIsSendingUsageData: (value: boolean) => void;
+export declare const getIsSendingUsageData: () => boolean | undefined;
+export declare const deleteIsSendingUsageData: () => void;
+export declare const getUsageDataClientId: () => string;
+export declare const persistIsLoggingVerbose: (value: boolean) => void;
+export declare const getIsLoggingVerbose: () => boolean;
+interface SharedAppSpecificStoreSchema {
+    currentPane?: number;
+}
+export declare const getAppSpecificStore: <StoreSchema extends Record<string, any>>(options?: Store.Options<any>) => Store<StoreSchema & SharedAppSpecificStoreSchema>;
+export declare const persistCurrentPane: (currentPane: number) => void;
+export declare const getPersistedCurrentPane: () => number | undefined;
+export {};

package/typings/generated/src/utils/systemReport.d.ts

@@ -0,0 +1,4 @@
+import { Device } from '../Device/deviceSlice';
+export declare const generateSystemReport: (timestamp: string, allDevices?: Device[], currentDevice?: Device, currentSerialNumber?: string) => Promise<string>;
+declare const _default: (allDevices: Device[], currentSerialNumber: string, currentDevice: Device | null) => Promise<void>;
+export default _default;

package/typings/generated/src/utils/truncateMiddle.d.ts

@@ -0,0 +1,2 @@
+declare const truncateMiddle: (str: string, clipStart?: number, clipEnd?: number) => string;
+export { truncateMiddle };

package/typings/generated/src/utils/truncateMiddle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/typings/generated/src/utils/usageData.d.ts

@@ -0,0 +1,63 @@
+import { PackageJson } from './AppTypes';
+/**
+ * Initialize instance to send user data
+ * @param {*} packageJson the app's package json
+ *
+ * @returns {Promise<void>} void
+ */
+export declare const init: (packageJson: PackageJson) => void;
+/**
+ * Checks if usage report instance is initialized and ready to be sent
+ *
+ * @returns {Boolean} returns whether the setting is on, off or undefined
+ */
+export declare const isInitialized: () => boolean;
+/**
+ * Check the status of usage data
+ *
+ * @returns {Boolean | undefined} returns whether the setting is on, off or undefined
+ */
+export declare const isEnabled: () => boolean | undefined;
+/**
+ * Enable sending usage data
+ *
+ * @returns {void}
+ */
+export declare const enable: () => void;
+/**
+ * Disable sending usage data
+ *
+ * @returns {void}
+ */
+export declare const disable: () => void;
+/**
+ * Reset settings so that launcher is able to
+ * ask the user to enable or disable sending usage data
+ *
+ * @returns {void}
+ */
+export declare const reset: () => void;
+/**
+ * Send usage data event to Google Analytics
+ * @param {string} action The event action
+ * @param {string} label The event label
+ * @returns {void}
+ */
+export declare const sendUsageData: <T extends string>(action: T, label?: string) => void;
+/**
+ * Send error usage data event to Google Analytics and also show it in the logger view
+ * @param {string} error The event action
+ * @returns {void}
+ */
+export declare const sendErrorReport: (error: string) => void;
+declare const _default: {
+    disable: () => void;
+    enable: () => void;
+    init: (packageJson: PackageJson) => void;
+    isEnabled: () => boolean | undefined;
+    isInitialized: () => boolean;
+    reset: () => void;
+    sendErrorReport: (error: string) => void;
+    sendUsageData: <T extends string>(action: T, label?: string | undefined) => void;
+};
+export default _default;

package/typings/generated/src/utils/useHotKey.d.ts

@@ -0,0 +1,6 @@
+import { DependencyList } from 'react';
+import { Shortcut } from '../About/shortcutSlice';
+declare const useNewHotKey: (shortcut: Shortcut, deps?: DependencyList) => void;
+declare const useLegacyHotKey: (hotKey: string | string[], action: () => void) => void;
+declare const _default: (...args: Parameters<typeof useNewHotKey> | Parameters<typeof useLegacyHotKey>) => void;
+export default _default;

package/typings/generated/src/utils/useStopwatch.d.ts

@@ -0,0 +1,22 @@
+export interface ITimer {
+    now: () => number;
+    setTimeout: (callback: () => void, ms: number) => () => void;
+}
+export type Stopwatch = {
+    autoStart: boolean;
+    resolution?: number;
+    timer?: ITimer;
+};
+declare const _default: ({ autoStart, timer, resolution, }: Stopwatch) => {
+    start: (elapsedTime?: any) => void;
+    pause: () => void;
+    reset: () => void;
+    isRunning: boolean;
+    time: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    millisecond: number;
+};
+export default _default;

package/typings/generated/src/utils/useStopwatch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/typings/generated/test/dispatchTo.d.ts

@@ -0,0 +1,3 @@
+import { Action, Reducer } from 'redux';
+declare const _default: <State>(aReducer: Reducer<State, import("redux").AnyAction>, actions?: Action[]) => State & ({} | null);
+export default _default;

package/typings/generated/test/testrenderer.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Action, Reducer } from 'redux';
+export declare const testRendererForApps: (appReducer?: Reducer) => (element: React.ReactElement, actions?: Action[]) => import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries")>;
+declare const _default: (element: React.ReactElement, actions?: Action[], appReducer?: Reducer) => import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries")>;
+export default _default;

package/typings/nrf-intel-hex.d.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+/**
+ * Parser/writer for the "Intel hex" format.
+ */
+
+declare module 'nrf-intel-hex' {
+    export type MemoryBlocks =
+        | { [x: number]: Uint8Array }
+        | [number, Uint8Array][]
+        | [string, Uint8Array][];
+
+    export type Overlap = [string, Uint8Array][];
+    export type Overlaps = Map<number, Overlap>;
+    export type MemoryMapTuple = [string, MemoryMap];
+    export type MemoryMaps = MemoryMapTuple[];
+
+    export default class MemoryMap extends Map<number, Uint8Array> {
+        static flattenOverlaps(overlaps: Overlaps): MemoryMap;
+
+        static overlapMemoryMaps(memoryMaps: MemoryMaps): Overlaps;
+
+        static fromHex(hexText: string, maxBlockSize?: number): MemoryMap;
+
+        public join(maxBlockSize: number): MemoryMap;
+
+        public paginate(pageSize?: number, pad?: number): MemoryMap;
+
+        public getUint32(
+            offset: number,
+            littleEndian?: boolean
+        ): number | undefined;
+
+        public asHexString(lineSize?: number): string;
+
+        public clone(): MemoryMap;
+
+        static fromPaddedUint8Array(
+            bytes: Uint8Array,
+            padByte?: number,
+            minPadLength?: number
+        ): MemoryMap;
+
+        public slice(address: number, length: number): MemoryMap;
+
+        public slicePad(
+            address: number,
+            length: number,
+            padByte?: number
+        ): Uint8Array;
+
+        public contains(memMap: MemoryMap): boolean;
+    }
+}