@onekeyfe/hd-shared 0.1.6

package/README.md

@@ -0,0 +1,3 @@
+# `shared`
+
+> Hardware SDK's shared tool library

package/dist/HardwareError.d.ts

@@ -0,0 +1,58 @@
+export interface IHardwareError {
+    errorCode: ValueOf<typeof HardwareErrorCode>;
+    message?: string;
+}
+declare type ValueOf<P extends object> = P[keyof P];
+declare type HardwareErrorCodeMessageMapping = {
+    [P in ValueOf<typeof HardwareErrorCode>]: string;
+};
+declare type ErrorCodeUnion = ValueOf<typeof HardwareErrorCode>;
+export declare class HardwareError extends Error {
+    errorCode: ErrorCodeUnion;
+    message: string;
+    constructor(hardwareError: IHardwareError | string);
+}
+export declare const HardwareErrorCode: {
+    readonly UnknownError: 0;
+    readonly DeviceFwException: 101;
+    readonly DeviceUnexpectedMode: 102;
+    readonly DeviceListNotInitialized: 103;
+    readonly SelectDevice: 104;
+    readonly DeviceNotFound: 105;
+    readonly DeviceInitializeFailed: 106;
+    readonly DeviceInterruptedFromOutside: 107;
+    readonly NotInitialized: 200;
+    readonly IFrameNotInitialized: 300;
+    readonly IFrameAleradyInitialized: 301;
+    readonly IFrameLoadFail: 302;
+    readonly IframeTimeout: 303;
+    readonly IframeBlocked: 304;
+    readonly CallMethodError: 400;
+    readonly CallMethodNotResponse: 404;
+    readonly CallMethodInvalidParameter: 405;
+    readonly FirmwareUpdateDownloadFailed: 406;
+    readonly NetworkError: 500;
+    readonly TransportNotConfigured: 600;
+    readonly TransportCallInProgress: 601;
+    readonly TransportNotFound: 602;
+    readonly TransportInvalidProtobuf: 603;
+    readonly BleScanError: 700;
+    readonly BlePermissionError: 701;
+    readonly BleLocationError: 702;
+    readonly BleRequiredUUID: 703;
+    readonly BleConnectedError: 704;
+    readonly BleDeviceNotBonded: 705;
+    readonly BleServiceNotFound: 706;
+    readonly BleCharacteristicNotFound: 707;
+    readonly BleMonitorError: 708;
+    readonly RuntimeError: 800;
+    readonly PinInvalid: 801;
+    readonly PinCancelled: 802;
+    readonly ActionCancelled: 803;
+    readonly FirmwareError: 804;
+};
+export declare const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping;
+export declare const TypedError: (hardwareError: ErrorCodeUnion | string, message?: string | undefined) => HardwareError;
+export declare const serializeError: (payload: any) => any;
+export {};
+//# sourceMappingURL=HardwareError.d.ts.map

package/dist/HardwareError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardwareError.d.ts","sourceRoot":"","sources":["../src/HardwareError.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,aAAK,OAAO,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE5C,aAAK,+BAA+B,GAAG;KAAG,CAAC,IAAI,OAAO,CAAC,OAAO,iBAAiB,CAAC,GAAG,MAAM;CAAE,CAAC;AAE5F,aAAK,cAAc,GAAG,OAAO,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAMxD,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAS,EAAE,cAAc,CAAkC;IAE3D,OAAO,SAAM;gBAED,aAAa,EAAE,cAAc,GAAG,MAAM;CAkBnD;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0JpB,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,+BAqE7B,CAAC;AAEX,eAAO,MAAM,UAAU,kBAAmB,cAAc,GAAG,MAAM,gDAKhE,CAAC;AAEF,eAAO,MAAM,cAAc,YAAa,GAAG,QAQ1C,CAAC"}

package/dist/deferred.d.ts

@@ -0,0 +1,9 @@
+export declare type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+export declare function createDeferred<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+//# sourceMappingURL=deferred.d.ts.map

package/dist/deferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred.d.ts","sourceRoot":"","sources":["../src/deferred.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,IAAI;IAC1C,EAAE,CAAC,EAAE,CAAC,CAAC;IACP,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACxB,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;CAC5B,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CA0BxF"}

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+declare type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+declare function createDeferred<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+
+interface IHardwareError {
+    errorCode: ValueOf<typeof HardwareErrorCode>;
+    message?: string;
+}
+declare type ValueOf<P extends object> = P[keyof P];
+declare type HardwareErrorCodeMessageMapping = {
+    [P in ValueOf<typeof HardwareErrorCode>]: string;
+};
+declare type ErrorCodeUnion = ValueOf<typeof HardwareErrorCode>;
+declare class HardwareError extends Error {
+    errorCode: ErrorCodeUnion;
+    message: string;
+    constructor(hardwareError: IHardwareError | string);
+}
+declare const HardwareErrorCode: {
+    readonly UnknownError: 0;
+    readonly DeviceFwException: 101;
+    readonly DeviceUnexpectedMode: 102;
+    readonly DeviceListNotInitialized: 103;
+    readonly SelectDevice: 104;
+    readonly DeviceNotFound: 105;
+    readonly DeviceInitializeFailed: 106;
+    readonly DeviceInterruptedFromOutside: 107;
+    readonly NotInitialized: 200;
+    readonly IFrameNotInitialized: 300;
+    readonly IFrameAleradyInitialized: 301;
+    readonly IFrameLoadFail: 302;
+    readonly IframeTimeout: 303;
+    readonly IframeBlocked: 304;
+    readonly CallMethodError: 400;
+    readonly CallMethodNotResponse: 404;
+    readonly CallMethodInvalidParameter: 405;
+    readonly FirmwareUpdateDownloadFailed: 406;
+    readonly NetworkError: 500;
+    readonly TransportNotConfigured: 600;
+    readonly TransportCallInProgress: 601;
+    readonly TransportNotFound: 602;
+    readonly TransportInvalidProtobuf: 603;
+    readonly BleScanError: 700;
+    readonly BlePermissionError: 701;
+    readonly BleLocationError: 702;
+    readonly BleRequiredUUID: 703;
+    readonly BleConnectedError: 704;
+    readonly BleDeviceNotBonded: 705;
+    readonly BleServiceNotFound: 706;
+    readonly BleCharacteristicNotFound: 707;
+    readonly BleMonitorError: 708;
+    readonly RuntimeError: 800;
+    readonly PinInvalid: 801;
+    readonly PinCancelled: 802;
+    readonly ActionCancelled: 803;
+    readonly FirmwareError: 804;
+};
+declare const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping;
+declare const TypedError: (hardwareError: ErrorCodeUnion | string, message?: string | undefined) => HardwareError;
+declare const serializeError: (payload: any) => any;
+
+type HardwareError$1_IHardwareError = IHardwareError;
+type HardwareError$1_HardwareError = HardwareError;
+declare const HardwareError$1_HardwareError: typeof HardwareError;
+declare const HardwareError$1_HardwareErrorCode: typeof HardwareErrorCode;
+declare const HardwareError$1_HardwareErrorCodeMessage: typeof HardwareErrorCodeMessage;
+declare const HardwareError$1_TypedError: typeof TypedError;
+declare const HardwareError$1_serializeError: typeof serializeError;
+declare namespace HardwareError$1 {
+  export {
+    HardwareError$1_IHardwareError as IHardwareError,
+    HardwareError$1_HardwareError as HardwareError,
+    HardwareError$1_HardwareErrorCode as HardwareErrorCode,
+    HardwareError$1_HardwareErrorCodeMessage as HardwareErrorCodeMessage,
+    HardwareError$1_TypedError as TypedError,
+    HardwareError$1_serializeError as serializeError,
+  };
+}
+
+export { Deferred, HardwareError$1 as ERRORS, HardwareError, HardwareErrorCode, HardwareErrorCodeMessage, IHardwareError, TypedError, createDeferred, serializeError };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,191 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function createDeferred(arg, data) {
+    let localResolve = (_t) => { };
+    let localReject = (_e) => { };
+    let id;
+    const promise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        localResolve = resolve;
+        localReject = reject;
+        if (typeof arg === 'function') {
+            try {
+                yield arg();
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+        if (typeof arg === 'string')
+            id = arg;
+    }));
+    return {
+        id,
+        data,
+        resolve: localResolve,
+        reject: localReject,
+        promise,
+    };
+}
+
+function fillStringWithArguments(value, object) {
+    return value.replace(/\{([^}]+)\}/g, (_, arg) => object[arg] || '?');
+}
+class HardwareError extends Error {
+    constructor(hardwareError) {
+        var _a;
+        super();
+        this.errorCode = HardwareErrorCode.UnknownError;
+        this.message = '';
+        const errorMessageMapping = HardwareErrorCodeMessage;
+        this.message = errorMessageMapping[HardwareErrorCode.UnknownError];
+        if (typeof hardwareError === 'string') {
+            this.errorCode = HardwareErrorCode.UnknownError;
+            this.message = hardwareError;
+        }
+        else {
+            const message = (_a = (hardwareError.message || errorMessageMapping[hardwareError.errorCode])) !== null && _a !== void 0 ? _a : '';
+            if (message) {
+                this.message = fillStringWithArguments(message, hardwareError);
+            }
+            this.errorCode = hardwareError.errorCode;
+        }
+        this.name = 'HardwareError';
+    }
+}
+const HardwareErrorCode = {
+    UnknownError: 0,
+    DeviceFwException: 101,
+    DeviceUnexpectedMode: 102,
+    DeviceListNotInitialized: 103,
+    SelectDevice: 104,
+    DeviceNotFound: 105,
+    DeviceInitializeFailed: 106,
+    DeviceInterruptedFromOutside: 107,
+    NotInitialized: 200,
+    IFrameNotInitialized: 300,
+    IFrameAleradyInitialized: 301,
+    IFrameLoadFail: 302,
+    IframeTimeout: 303,
+    IframeBlocked: 304,
+    CallMethodError: 400,
+    CallMethodNotResponse: 404,
+    CallMethodInvalidParameter: 405,
+    FirmwareUpdateDownloadFailed: 406,
+    NetworkError: 500,
+    TransportNotConfigured: 600,
+    TransportCallInProgress: 601,
+    TransportNotFound: 602,
+    TransportInvalidProtobuf: 603,
+    BleScanError: 700,
+    BlePermissionError: 701,
+    BleLocationError: 702,
+    BleRequiredUUID: 703,
+    BleConnectedError: 704,
+    BleDeviceNotBonded: 705,
+    BleServiceNotFound: 706,
+    BleCharacteristicNotFound: 707,
+    BleMonitorError: 708,
+    RuntimeError: 800,
+    PinInvalid: 801,
+    PinCancelled: 802,
+    ActionCancelled: 803,
+    FirmwareError: 804,
+};
+const HardwareErrorCodeMessage = {
+    [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
+    [HardwareErrorCode.DeviceFwException]: 'Firmware version mismatch',
+    [HardwareErrorCode.DeviceUnexpectedMode]: 'Device unexpected mode',
+    [HardwareErrorCode.DeviceListNotInitialized]: 'Device list is not initialized',
+    [HardwareErrorCode.SelectDevice]: 'Please select the connected device',
+    [HardwareErrorCode.DeviceNotFound]: 'Device not found',
+    [HardwareErrorCode.DeviceInitializeFailed]: 'Device initialization failed',
+    [HardwareErrorCode.DeviceInterruptedFromOutside]: 'Device interrupted',
+    [HardwareErrorCode.NotInitialized]: 'Not initialized',
+    [HardwareErrorCode.IFrameNotInitialized]: 'IFrame not initialized',
+    [HardwareErrorCode.IFrameAleradyInitialized]: 'IFrame alerady initialized',
+    [HardwareErrorCode.IFrameLoadFail]: 'IFrame load fail',
+    [HardwareErrorCode.IframeTimeout]: 'init iframe time out',
+    [HardwareErrorCode.IframeBlocked]: 'IFrame blocked',
+    [HardwareErrorCode.CallMethodError]: 'Runtime errors during method execution',
+    [HardwareErrorCode.CallMethodNotResponse]: 'Method does not responding',
+    [HardwareErrorCode.CallMethodInvalidParameter]: 'Call method invalid parameter',
+    [HardwareErrorCode.FirmwareUpdateDownloadFailed]: 'Firmware update download failed',
+    [HardwareErrorCode.NetworkError]: 'Network request error',
+    [HardwareErrorCode.TransportNotConfigured]: 'Transport not configured',
+    [HardwareErrorCode.TransportCallInProgress]: 'Transport call in progress',
+    [HardwareErrorCode.TransportNotFound]: 'Transport not found',
+    [HardwareErrorCode.TransportInvalidProtobuf]: 'Transport invalid protobuf',
+    [HardwareErrorCode.BleScanError]: 'BLE scan error',
+    [HardwareErrorCode.BlePermissionError]: 'Bluetooth required to be turned on',
+    [HardwareErrorCode.BleLocationError]: 'Device is not authorized to use BluetoothLE',
+    [HardwareErrorCode.BleRequiredUUID]: 'uuid is required',
+    [HardwareErrorCode.BleConnectedError]: 'connected error is always runtime error',
+    [HardwareErrorCode.BleDeviceNotBonded]: 'device is not bonded',
+    [HardwareErrorCode.BleServiceNotFound]: 'BLEServiceNotFound: service not found',
+    [HardwareErrorCode.BleCharacteristicNotFound]: 'BLEServiceNotFound: service not found',
+    [HardwareErrorCode.BleMonitorError]: 'Monitor Error: characteristic not found',
+    [HardwareErrorCode.RuntimeError]: 'Runtime error',
+    [HardwareErrorCode.PinInvalid]: 'Pin invalid',
+    [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
+    [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
+    [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
+};
+const TypedError = (hardwareError, message) => {
+    if (typeof hardwareError === 'string') {
+        return new HardwareError(hardwareError);
+    }
+    return new HardwareError({ errorCode: hardwareError, message: message !== null && message !== void 0 ? message : '' });
+};
+const serializeError = (payload) => {
+    if (payload && payload.error instanceof HardwareError) {
+        return { error: payload.error.message, code: payload.error.errorCode };
+    }
+    if (payload && payload.error instanceof Error) {
+        return { error: payload.error.message, code: payload.error.code };
+    }
+    return payload;
+};
+
+var HardwareError$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HardwareError: HardwareError,
+    HardwareErrorCode: HardwareErrorCode,
+    HardwareErrorCodeMessage: HardwareErrorCodeMessage,
+    TypedError: TypedError,
+    serializeError: serializeError
+});
+
+exports.ERRORS = HardwareError$1;
+exports.HardwareError = HardwareError;
+exports.HardwareErrorCode = HardwareErrorCode;
+exports.HardwareErrorCodeMessage = HardwareErrorCodeMessage;
+exports.TypedError = TypedError;
+exports.createDeferred = createDeferred;
+exports.serializeError = serializeError;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@onekeyfe/hd-shared",
+  "version": "0.1.6",
+  "description": "Hardware SDK's shared tool library",
+  "keywords": [
+    "Hardware-SDK",
+    "shared",
+    "utils"
+  ],
+  "author": "Leon <lixiao.dev@gmail.com>",
+  "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/hardware-js-sdk.git"
+  },
+  "scripts": {
+    "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
+    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "gitHead": "ebe2789fa24cbfb798c9be445678e71e67e33d71"
+}

package/src/HardwareError.ts

@@ -0,0 +1,283 @@
+export interface IHardwareError {
+  errorCode: ValueOf<typeof HardwareErrorCode>;
+  message?: string;
+}
+
+type ValueOf<P extends object> = P[keyof P];
+
+type HardwareErrorCodeMessageMapping = { [P in ValueOf<typeof HardwareErrorCode>]: string };
+
+type ErrorCodeUnion = ValueOf<typeof HardwareErrorCode>;
+
+function fillStringWithArguments(value: string, object: object) {
+  return value.replace(/\{([^}]+)\}/g, (_, arg: string) => (object as unknown as any)[arg] || '?');
+}
+
+export class HardwareError extends Error {
+  errorCode: ErrorCodeUnion = HardwareErrorCode.UnknownError;
+
+  message = '';
+
+  constructor(hardwareError: IHardwareError | string) {
+    super();
+    const errorMessageMapping = HardwareErrorCodeMessage;
+    this.message = errorMessageMapping[HardwareErrorCode.UnknownError];
+
+    if (typeof hardwareError === 'string') {
+      this.errorCode = HardwareErrorCode.UnknownError;
+      this.message = hardwareError;
+    } else {
+      const message = (hardwareError.message || errorMessageMapping[hardwareError.errorCode]) ?? '';
+      if (message) {
+        this.message = fillStringWithArguments(message, hardwareError);
+      }
+      this.errorCode = hardwareError.errorCode;
+    }
+
+    this.name = 'HardwareError';
+  }
+}
+
+export const HardwareErrorCode = {
+  /**
+   * This error can be thrown when unexpected error occurred and in most cases it is related to implementation bug.
+   * Original message is available in message property.
+   */
+  UnknownError: 0,
+
+  /**
+   * Firmware version mismatch
+   */
+  DeviceFwException: 101,
+
+  /**
+   * Device unexpected mode
+   */
+  DeviceUnexpectedMode: 102,
+
+  /**
+   * Device list is not initialized
+   */
+  DeviceListNotInitialized: 103,
+
+  /**
+   * Please select the connected device
+   */
+  SelectDevice: 104,
+
+  /**
+   * Device not found
+   */
+  DeviceNotFound: 105,
+
+  /**
+   * Device is not initialized
+   */
+  DeviceInitializeFailed: 106,
+
+  /**
+   * Device interrupted from another operation
+   */
+  DeviceInterruptedFromOutside: 107,
+
+  /**
+   * Not initialized
+   */
+  NotInitialized: 200,
+
+  /**
+   * Iframe not initialized
+   */
+  IFrameNotInitialized: 300,
+
+  /**
+   * iframe repeat initialization
+   */
+  IFrameAleradyInitialized: 301,
+
+  /**
+   * iframe load failure
+   */
+  IFrameLoadFail: 302,
+
+  /**
+   * init iframe time out
+   */
+  IframeTimeout: 303,
+
+  /**
+   * iframe blocked
+   */
+  IframeBlocked: 304,
+
+  /**
+   * Runtime errors during method execution
+   */
+  CallMethodError: 400,
+
+  /**
+   * Method does not responding
+   */
+  CallMethodNotResponse: 404,
+
+  /**
+   * Call method invalid parameter
+   */
+  CallMethodInvalidParameter: 405,
+
+  /**
+   * firmware update download failed
+   */
+  FirmwareUpdateDownloadFailed: 406,
+
+  /**
+   * Netword request error
+   */
+  NetworkError: 500,
+
+  /**
+   * Transport not configured
+   */
+  TransportNotConfigured: 600,
+
+  /**
+   * Transport call in progress
+   */
+  TransportCallInProgress: 601,
+
+  /**
+   * Transport not found
+   */
+  TransportNotFound: 602,
+
+  /**
+   * Transport invalid protobuf
+   */
+  TransportInvalidProtobuf: 603,
+
+  /**
+   * Bluetooth error code
+   */
+  BleScanError: 700,
+  BlePermissionError: 701,
+  BleLocationError: 702,
+  BleRequiredUUID: 703,
+  BleConnectedError: 704,
+  BleDeviceNotBonded: 705,
+  BleServiceNotFound: 706,
+  BleCharacteristicNotFound: 707,
+  BleMonitorError: 708,
+
+  /**
+   * Hardware runtiome errors
+   */
+  RuntimeError: 800,
+
+  /**
+   * invalid pin
+   */
+  PinInvalid: 801,
+
+  /**
+   * pin cancelled by user
+   */
+  PinCancelled: 802,
+
+  /**
+   * Action cancelled by user
+   */
+  ActionCancelled: 803,
+
+  /**
+   * Firmware installation failed
+   */
+  FirmwareError: 804,
+} as const;
+
+export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
+  [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
+
+  /**
+   * Device Errors
+   */
+  [HardwareErrorCode.DeviceFwException]: 'Firmware version mismatch',
+  [HardwareErrorCode.DeviceUnexpectedMode]: 'Device unexpected mode',
+  [HardwareErrorCode.DeviceListNotInitialized]: 'Device list is not initialized',
+  [HardwareErrorCode.SelectDevice]: 'Please select the connected device',
+  [HardwareErrorCode.DeviceNotFound]: 'Device not found',
+  [HardwareErrorCode.DeviceInitializeFailed]: 'Device initialization failed',
+  [HardwareErrorCode.DeviceInterruptedFromOutside]: 'Device interrupted',
+
+  /**
+   * Node Errors
+   */
+  [HardwareErrorCode.NotInitialized]: 'Not initialized',
+  /**
+   * Iframe Errors
+   */
+  [HardwareErrorCode.IFrameNotInitialized]: 'IFrame not initialized',
+  [HardwareErrorCode.IFrameAleradyInitialized]: 'IFrame alerady initialized',
+  [HardwareErrorCode.IFrameLoadFail]: 'IFrame load fail',
+  [HardwareErrorCode.IframeTimeout]: 'init iframe time out',
+  [HardwareErrorCode.IframeBlocked]: 'IFrame blocked',
+
+  /**
+   * Method Errors
+   */
+  [HardwareErrorCode.CallMethodError]: 'Runtime errors during method execution',
+  [HardwareErrorCode.CallMethodNotResponse]: 'Method does not responding',
+  [HardwareErrorCode.CallMethodInvalidParameter]: 'Call method invalid parameter',
+  [HardwareErrorCode.FirmwareUpdateDownloadFailed]: 'Firmware update download failed',
+
+  /**
+   * Network Errors
+   */
+  [HardwareErrorCode.NetworkError]: 'Network request error',
+
+  /**
+   * Transport Errors
+   */
+  [HardwareErrorCode.TransportNotConfigured]: 'Transport not configured',
+  [HardwareErrorCode.TransportCallInProgress]: 'Transport call in progress',
+  [HardwareErrorCode.TransportNotFound]: 'Transport not found',
+  [HardwareErrorCode.TransportInvalidProtobuf]: 'Transport invalid protobuf',
+
+  /**
+   * Bluetooth Error
+   */
+  [HardwareErrorCode.BleScanError]: 'BLE scan error',
+  [HardwareErrorCode.BlePermissionError]: 'Bluetooth required to be turned on',
+  [HardwareErrorCode.BleLocationError]: 'Device is not authorized to use BluetoothLE',
+  [HardwareErrorCode.BleRequiredUUID]: 'uuid is required',
+  [HardwareErrorCode.BleConnectedError]: 'connected error is always runtime error',
+  [HardwareErrorCode.BleDeviceNotBonded]: 'device is not bonded',
+  [HardwareErrorCode.BleServiceNotFound]: 'BLEServiceNotFound: service not found',
+  [HardwareErrorCode.BleCharacteristicNotFound]: 'BLEServiceNotFound: service not found',
+  [HardwareErrorCode.BleMonitorError]: 'Monitor Error: characteristic not found',
+
+  /**
+   * Runtime Error
+   */
+  [HardwareErrorCode.RuntimeError]: 'Runtime error',
+  [HardwareErrorCode.PinInvalid]: 'Pin invalid',
+  [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
+  [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
+  [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
+} as const;
+
+export const TypedError = (hardwareError: ErrorCodeUnion | string, message?: string) => {
+  if (typeof hardwareError === 'string') {
+    return new HardwareError(hardwareError);
+  }
+  return new HardwareError({ errorCode: hardwareError, message: message ?? '' });
+};
+
+export const serializeError = (payload: any) => {
+  if (payload && payload.error instanceof HardwareError) {
+    return { error: payload.error.message, code: payload.error.errorCode };
+  }
+  if (payload && payload.error instanceof Error) {
+    return { error: payload.error.message, code: payload.error.code };
+  }
+  return payload;
+};

package/src/deferred.ts

@@ -0,0 +1,35 @@
+export type Deferred<T, I = any, D = any> = {
+  id?: I;
+  data?: D;
+  promise: Promise<T>;
+  resolve: (t: T) => void;
+  reject: (e: Error) => void;
+};
+
+export function createDeferred<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D> {
+  let localResolve: (t: T) => void = (_t: T) => {};
+  let localReject: (e?: Error) => void = (_e?: Error) => {};
+  let id: I | undefined;
+
+  // eslint-disable-next-line no-async-promise-executor
+  const promise: Promise<T> = new Promise(async (resolve, reject) => {
+    localResolve = resolve;
+    localReject = reject;
+    if (typeof arg === 'function') {
+      try {
+        await arg();
+      } catch (error) {
+        reject(error);
+      }
+    }
+    if (typeof arg === 'string') id = arg;
+  });
+
+  return {
+    id,
+    data,
+    resolve: localResolve,
+    reject: localReject,
+    promise,
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './deferred';
+export * from './HardwareError';
+export * as ERRORS from './HardwareError';

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+  },
+  "include": ["./src"]
+}