@ledgerhq/device-management-kit 0.5.0 → 0.6.0

package/lib/esm/src/internal/transport/ble/transport/BleDeviceConnection.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/ble/transport/BleDeviceConnection.ts"],
-  "sourcesContent": ["import { type Either, Left, Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { type DmkError } from \"@api/Error\";\nimport { type ApduReceiverService } from \"@internal/device-session/service/ApduReceiverService\";\nimport { type ApduSenderService } from \"@internal/device-session/service/ApduSenderService\";\nimport { type DefaultApduSenderServiceConstructorArgs } from \"@internal/device-session/service/DefaultApduSenderService\";\nimport type { LoggerPublisherService } from \"@internal/logger-publisher/service/LoggerPublisherService\";\nimport { type DeviceConnection } from \"@internal/transport/model/DeviceConnection\";\nimport {\n  DeviceNotInitializedError,\n  ReconnectionFailedError,\n} from \"@internal/transport/model/Errors\";\n\ntype BleDeviceConnectionConstructorArgs = {\n  writeCharacteristic: BluetoothRemoteGATTCharacteristic;\n  notifyCharacteristic: BluetoothRemoteGATTCharacteristic;\n  apduSenderFactory: (\n    args: DefaultApduSenderServiceConstructorArgs,\n  ) => ApduSenderService;\n  apduReceiverFactory: () => ApduReceiverService;\n};\n\nexport type DataViewEvent = Event & {\n  target: {\n    value: DataView;\n  };\n};\n\nexport class BleDeviceConnection implements DeviceConnection {\n  private _writeCharacteristic: BluetoothRemoteGATTCharacteristic;\n  private _notifyCharacteristic: BluetoothRemoteGATTCharacteristic;\n  private readonly _logger: LoggerPublisherService;\n  private _apduSender: Maybe<ApduSenderService>;\n  private readonly _apduSenderFactory: (\n    args: DefaultApduSenderServiceConstructorArgs,\n  ) => ApduSenderService;\n  private readonly _apduReceiver: ApduReceiverService;\n  private _isDeviceReady: boolean;\n  private _sendApduPromiseResolver: Maybe<{\n    resolve(value: Either<DmkError, ApduResponse>): void;\n  }>;\n  private _settleReconnectionPromiseResolvers: Maybe<{\n    resolve(): void;\n    reject(err: DmkError): void;\n  }>;\n\n  constructor(\n    {\n      writeCharacteristic,\n      notifyCharacteristic,\n      apduSenderFactory,\n      apduReceiverFactory,\n    }: BleDeviceConnectionConstructorArgs,\n    loggerServiceFactory: (tag: string) => LoggerPublisherService,\n  ) {\n    this._apduSenderFactory = apduSenderFactory;\n    this._apduSender = Nothing;\n    this._apduReceiver = apduReceiverFactory();\n    this._logger = loggerServiceFactory(\"BleDeviceConnection\");\n    this._writeCharacteristic = writeCharacteristic;\n    this._notifyCharacteristic = notifyCharacteristic;\n    this._notifyCharacteristic.oncharacteristicvaluechanged =\n      this.onNotifyCharacteristicValueChanged;\n    this._isDeviceReady = false;\n    this._sendApduPromiseResolver = Maybe.zero();\n    this._settleReconnectionPromiseResolvers = Maybe.zero();\n  }\n\n  /**\n   * NotifyCharacteristic setter\n   * Register a listener on characteristic value change\n   * @param notifyCharacteristic\n   * @private\n   */\n  private set notifyCharacteristic(\n    notifyCharacteristic: BluetoothRemoteGATTCharacteristic,\n  ) {\n    this._notifyCharacteristic = notifyCharacteristic;\n    this._notifyCharacteristic.oncharacteristicvaluechanged =\n      this.onNotifyCharacteristicValueChanged;\n  }\n\n  /**\n   * WriteCharacteristic setter\n   * @param writeCharacteristic\n   * @private\n   */\n  private set writeCharacteristic(\n    writeCharacteristic: BluetoothRemoteGATTCharacteristic,\n  ) {\n    this._writeCharacteristic = writeCharacteristic;\n  }\n\n  /**\n   * Event handler to setup the mtu size in response of 0x0800000000 APDU\n   * @param value\n   * @private\n   */\n  private onReceiveSetupApduResponse(value: ArrayBuffer) {\n    const mtuResponse = new Uint8Array(value);\n    // the mtu is the 5th byte of the response\n    const [frameSize] = mtuResponse.slice(5);\n    if (frameSize) {\n      this._apduSender = Maybe.of(this._apduSenderFactory({ frameSize }));\n      this._settleReconnectionPromiseResolvers.ifJust((promise) => {\n        promise.resolve();\n        this._settleReconnectionPromiseResolvers = Maybe.zero();\n      });\n      this._isDeviceReady = true;\n    }\n  }\n\n  /**\n   * Main event handler for BLE notify characteristic\n   * Call _onReceiveSetupApduResponse if device mtu is not set\n   * Call receiveApdu otherwise\n   * @param event\n   */\n  private onNotifyCharacteristicValueChanged = (event: Event) => {\n    if (!this.isDataViewEvent(event)) {\n      return;\n    }\n    const {\n      target: {\n        value: { buffer },\n      },\n    } = event;\n    if (!this._isDeviceReady) {\n      this.onReceiveSetupApduResponse(buffer);\n    } else {\n      this.receiveApdu(buffer);\n    }\n  };\n\n  /**\n   * Setup BleDeviceConnection\n   *\n   * The device is considered as ready once the mtu had been set\n   * APDU 0x0800000000 is used to get this mtu size\n   */\n  public async setup() {\n    const requestMtuApdu = Uint8Array.from([0x08, 0x00, 0x00, 0x00, 0x00]);\n\n    await this._notifyCharacteristic.startNotifications();\n    await this._writeCharacteristic.writeValueWithoutResponse(requestMtuApdu);\n  }\n\n  /**\n   * Receive APDU response\n   * Resolve sendApdu promise once the framer receives all the frames of the response\n   * @param data\n   */\n  receiveApdu(data: ArrayBuffer) {\n    const response = this._apduReceiver.handleFrame(new Uint8Array(data));\n\n    response\n      .map((maybeApduResponse) => {\n        maybeApduResponse.map((apduResponse) => {\n          this._logger.debug(\"Received APDU Response\", {\n            data: { response: apduResponse },\n          });\n          this._sendApduPromiseResolver.map(({ resolve }) =>\n            resolve(Right(apduResponse)),\n          );\n        });\n      })\n      .mapLeft((error) => {\n        this._sendApduPromiseResolver.map(({ resolve }) =>\n          resolve(Left(error)),\n        );\n      });\n  }\n\n  /**\n   * Send apdu if the mtu had been set\n   *\n   * Get all frames for a given APDU\n   * Save a promise that would be completed once the response had been received\n   * @param apdu\n   * @param triggersDisconnection\n   */\n  async sendApdu(\n    apdu: Uint8Array,\n    triggersDisconnection?: boolean,\n  ): Promise<Either<DmkError, ApduResponse>> {\n    if (!this._isDeviceReady) {\n      return Promise.resolve(\n        Left(new DeviceNotInitializedError(\"Unknown MTU\")),\n      );\n    }\n    // Create a promise that would be resolved once the response had been received\n    const resultPromise = new Promise<Either<DmkError, ApduResponse>>(\n      (resolve) => {\n        this._sendApduPromiseResolver = Maybe.of({\n          resolve,\n        });\n      },\n    );\n    const frames = this._apduSender.mapOrDefault(\n      (apduSender) => apduSender.getFrames(apdu),\n      [],\n    );\n    for (const frame of frames) {\n      try {\n        this._logger.debug(\"Sending Frame\", {\n          data: { frame: frame.getRawData() },\n        });\n        await this._writeCharacteristic.writeValueWithoutResponse(\n          frame.getRawData(),\n        );\n      } catch (error) {\n        this._logger.error(\"Error sending frame\", { data: { error } });\n      }\n    }\n    const response = await resultPromise;\n    this._sendApduPromiseResolver = Maybe.zero();\n    return response.caseOf({\n      Right: async (apduResponse) => {\n        if (\n          triggersDisconnection &&\n          CommandUtils.isSuccessResponse(apduResponse)\n        ) {\n          const reconnectionRes = await this.setupWaitForReconnection();\n          return reconnectionRes.map(() => apduResponse);\n        } else {\n          return Right(apduResponse);\n        }\n      },\n      Left: async (error) => Promise.resolve(Left(error)),\n    });\n  }\n\n  /**\n   * Typeguard to check if an event contains target value of type DataView\n   *\n   * @param event\n   * @private\n   */\n  private isDataViewEvent(event: Event): event is DataViewEvent {\n    return (\n      event.target !== null &&\n      \"value\" in event.target &&\n      event.target.value instanceof DataView\n    );\n  }\n\n  /**\n   * Setup a promise that would be resolved once the device is reconnected\n   *\n   * @private\n   */\n  private setupWaitForReconnection(): Promise<Either<DmkError, void>> {\n    return new Promise<Either<DmkError, void>>((resolve) => {\n      this._settleReconnectionPromiseResolvers = Maybe.of({\n        resolve: () => resolve(Right(undefined)),\n        reject: (error: DmkError) => resolve(Left(error)),\n      });\n    });\n  }\n\n  /**\n   * Reconnect to the device by resetting new ble characteristics\n   * @param writeCharacteristic\n   * @param notifyCharacteristic\n   */\n  public async reconnect(\n    writeCharacteristic: BluetoothRemoteGATTCharacteristic,\n    notifyCharacteristic: BluetoothRemoteGATTCharacteristic,\n  ) {\n    this._isDeviceReady = false;\n    this.notifyCharacteristic = notifyCharacteristic;\n    this.writeCharacteristic = writeCharacteristic;\n    await this.setup();\n  }\n\n  /**\n   * Disconnect from the device\n   */\n  public disconnect() {\n    // if a reconnection promise is pending, reject it\n    this._settleReconnectionPromiseResolvers.ifJust((promise) => {\n      promise.reject(new ReconnectionFailedError());\n      this._settleReconnectionPromiseResolvers = Maybe.zero();\n    });\n    this._isDeviceReady = false;\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["Left", "Maybe", "Nothing", "Right", "CommandUtils", "DeviceNotInitializedError", "ReconnectionFailedError", "BleDeviceConnection", "writeCharacteristic", "notifyCharacteristic", "apduSenderFactory", "apduReceiverFactory", "loggerServiceFactory", "value", "mtuResponse", "frameSize", "promise", "event", "buffer", "requestMtuApdu", "data", "maybeApduResponse", "apduResponse", "resolve", "error", "apdu", "triggersDisconnection", "resultPromise", "frames", "apduSender", "frame", "response"]
-}

package/lib/esm/src/internal/transport/ble/transport/BleDeviceConnection.test.js

@@ -1,2 +0,0 @@
-import{Left as p,Right as l}from"purify-ts";import{defaultApduReceiverServiceStubBuilder as f}from"../../../device-session/service/DefaultApduReceiverService.stub";import{defaultApduSenderServiceStubBuilder as m}from"../../../device-session/service/DefaultApduSenderService.stub";import{DefaultLoggerPublisherService as A}from"../../../logger-publisher/service/DefaultLoggerPublisherService";import{bleCharacteristicStubBuilder as u}from"../../../transport/ble/model/BleDevice.stub";import{DeviceNotInitializedError as x}from"../../../transport/model/Errors";import{ApduResponse as h}from"../../../../../src";import{BleDeviceConnection as a}from"./BleDeviceConnection";const v=new Uint8Array([8,0,0,0,0]),d=new Uint8Array([0,0,0,0,0,66]),w=Uint8Array.from([0,0,0,0,0,0,0,0]);describe("BleDeviceConnection",()=>{let t,n,r,o;const i=e=>new A([],e);beforeEach(()=>{t=u(),n=u(),r=jest.fn(()=>m(void 0,i)),o=jest.fn(()=>f(void 0,i))});function s(e,c=Uint8Array.from([])){e.onNotifyCharacteristicValueChanged({target:{value:new DataView(c.buffer)}})}describe("sendApdu",()=>{it("should return an error if the device isn't setup",async()=>{const c=await new a({writeCharacteristic:t,notifyCharacteristic:n,apduSenderFactory:r,apduReceiverFactory:o},i).sendApdu(Uint8Array.from([]));expect(c).toStrictEqual(p(new x("Unknown MTU")))}),it("should send apdu without error if device is setup",async()=>{const e=new a({writeCharacteristic:t,notifyCharacteristic:n,apduSenderFactory:r,apduReceiverFactory:o},i);s(e,d);const c=e.sendApdu(new Uint8Array([]));s(e,w),expect(t.writeValueWithoutResponse).toHaveBeenCalledTimes(1),expect(await c).toStrictEqual(l(new h({statusCode:Uint8Array.from([]),data:Uint8Array.from([])})))})}),describe("setup",()=>{it("should send the apdu 0x0800000000 to get mtu size",async()=>{await new a({writeCharacteristic:t,notifyCharacteristic:n,apduSenderFactory:r,apduReceiverFactory:o},i).setup(),expect(t.writeValueWithoutResponse).toHaveBeenCalledWith(new Uint8Array(v))}),it("should setup apduSender with the correct mtu size",()=>{const e=new a({writeCharacteristic:t,notifyCharacteristic:n,apduSenderFactory:r,apduReceiverFactory:o},i);s(e,d),expect(r).toHaveBeenCalledWith({frameSize:66})})})});
-//# sourceMappingURL=BleDeviceConnection.test.js.map

package/lib/esm/src/internal/transport/ble/transport/BleDeviceConnection.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/ble/transport/BleDeviceConnection.test.ts"],
-  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { type ApduReceiverService } from \"@internal/device-session/service/ApduReceiverService\";\nimport { type ApduSenderService } from \"@internal/device-session/service/ApduSenderService\";\nimport { defaultApduReceiverServiceStubBuilder } from \"@internal/device-session/service/DefaultApduReceiverService.stub\";\nimport { defaultApduSenderServiceStubBuilder } from \"@internal/device-session/service/DefaultApduSenderService.stub\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/DefaultLoggerPublisherService\";\nimport { bleCharacteristicStubBuilder } from \"@internal/transport/ble/model/BleDevice.stub\";\nimport { DeviceNotInitializedError } from \"@internal/transport/model/Errors\";\nimport { ApduResponse } from \"@root/src\";\n\nimport { BleDeviceConnection, type DataViewEvent } from \"./BleDeviceConnection\";\n\nconst GET_MTU_APDU = new Uint8Array([0x08, 0x00, 0x00, 0x00, 0x00]);\nconst GET_MTU_APDU_RESPONSE = new Uint8Array([\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x42,\n]);\nconst EMPTY_APDU_RESPONSE = Uint8Array.from([\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\ndescribe(\"BleDeviceConnection\", () => {\n  let writeCharacteristic: BluetoothRemoteGATTCharacteristic;\n  let notifyCharacteristic: BluetoothRemoteGATTCharacteristic;\n  let apduSenderFactory: () => ApduSenderService;\n  let apduReceiverFactory: () => ApduReceiverService;\n  const logger = (tag: string) => new DefaultLoggerPublisherService([], tag);\n\n  beforeEach(() => {\n    writeCharacteristic = bleCharacteristicStubBuilder();\n    notifyCharacteristic = bleCharacteristicStubBuilder();\n    apduSenderFactory = jest.fn(() =>\n      defaultApduSenderServiceStubBuilder(undefined, logger),\n    );\n    apduReceiverFactory = jest.fn(() =>\n      defaultApduReceiverServiceStubBuilder(undefined, logger),\n    );\n  });\n\n  function receiveApdu(\n    connection: BleDeviceConnection,\n    buffer: Uint8Array = Uint8Array.from([]),\n  ) {\n    // @ts-expect-error private function call to mock web ble response\n    connection.onNotifyCharacteristicValueChanged({\n      target: {\n        value: new DataView(buffer.buffer),\n      },\n    } as DataViewEvent);\n  }\n\n  describe(\"sendApdu\", () => {\n    it(\"should return an error if the device isn't setup\", async () => {\n      // given\n      const connection = new BleDeviceConnection(\n        {\n          writeCharacteristic,\n          notifyCharacteristic,\n          apduSenderFactory,\n          apduReceiverFactory,\n        },\n        logger,\n      );\n      // when\n      const errorOrApduResponse = await connection.sendApdu(\n        Uint8Array.from([]),\n      );\n      // then\n      expect(errorOrApduResponse).toStrictEqual(\n        Left(new DeviceNotInitializedError(\"Unknown MTU\")),\n      );\n    });\n\n    it(\"should send apdu without error if device is setup\", async () => {\n      // given\n      const connection = new BleDeviceConnection(\n        {\n          writeCharacteristic,\n          notifyCharacteristic,\n          apduSenderFactory,\n          apduReceiverFactory,\n        },\n        logger,\n      );\n      // when\n      receiveApdu(connection, GET_MTU_APDU_RESPONSE);\n      const response = connection.sendApdu(new Uint8Array([]));\n      receiveApdu(connection, EMPTY_APDU_RESPONSE);\n      // then\n      expect(\n        writeCharacteristic.writeValueWithoutResponse,\n      ).toHaveBeenCalledTimes(1);\n      expect(await response).toStrictEqual(\n        Right(\n          new ApduResponse({\n            statusCode: Uint8Array.from([]),\n            data: Uint8Array.from([]),\n          }),\n        ),\n      );\n    });\n  });\n  describe(\"setup\", () => {\n    it(\"should send the apdu 0x0800000000 to get mtu size\", async () => {\n      // given\n      const connection = new BleDeviceConnection(\n        {\n          writeCharacteristic,\n          notifyCharacteristic,\n          apduSenderFactory,\n          apduReceiverFactory,\n        },\n        logger,\n      );\n      // when\n      await connection.setup();\n      // then\n      expect(\n        writeCharacteristic.writeValueWithoutResponse,\n      ).toHaveBeenCalledWith(new Uint8Array(GET_MTU_APDU));\n    });\n    it(\"should setup apduSender with the correct mtu size\", () => {\n      // given\n      const connection = new BleDeviceConnection(\n        {\n          writeCharacteristic,\n          notifyCharacteristic,\n          apduSenderFactory,\n          apduReceiverFactory,\n        },\n        logger,\n      );\n      // when\n      receiveApdu(connection, GET_MTU_APDU_RESPONSE);\n      // then\n      expect(apduSenderFactory).toHaveBeenCalledWith({ frameSize: 0x42 });\n    });\n  });\n});\n"],
-  "mappings": "AAAA,OAAS,QAAAA,EAAM,SAAAC,MAAa,YAI5B,OAAS,yCAAAC,MAA6C,mEACtD,OAAS,uCAAAC,MAA2C,iEACpD,OAAS,iCAAAC,MAAqC,mEAC9C,OAAS,gCAAAC,MAAoC,+CAC7C,OAAS,6BAAAC,MAAiC,mCAC1C,OAAS,gBAAAC,MAAoB,YAE7B,OAAS,uBAAAC,MAA+C,wBAExD,MAAMC,EAAe,IAAI,WAAW,CAAC,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,EAC5DC,EAAwB,IAAI,WAAW,CAC3C,EAAM,EAAM,EAAM,EAAM,EAAM,EAChC,CAAC,EACKC,EAAsB,WAAW,KAAK,CAC1C,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAC5C,CAAC,EAED,SAAS,sBAAuB,IAAM,CACpC,IAAIC,EACAC,EACAC,EACAC,EACJ,MAAMC,EAAUC,GAAgB,IAAIb,EAA8B,CAAC,EAAGa,CAAG,EAEzE,WAAW,IAAM,CACfL,EAAsBP,EAA6B,EACnDQ,EAAuBR,EAA6B,EACpDS,EAAoB,KAAK,GAAG,IAC1BX,EAAoC,OAAWa,CAAM,CACvD,EACAD,EAAsB,KAAK,GAAG,IAC5Bb,EAAsC,OAAWc,CAAM,CACzD,CACF,CAAC,EAED,SAASE,EACPC,EACAC,EAAqB,WAAW,KAAK,CAAC,CAAC,EACvC,CAEAD,EAAW,mCAAmC,CAC5C,OAAQ,CACN,MAAO,IAAI,SAASC,EAAO,MAAM,CACnC,CACF,CAAkB,CACpB,CAEA,SAAS,WAAY,IAAM,CACzB,GAAG,mDAAoD,SAAY,CAYjE,MAAMC,EAAsB,MAVT,IAAIb,EACrB,CACE,oBAAAI,EACA,qBAAAC,EACA,kBAAAC,EACA,oBAAAC,CACF,EACAC,CACF,EAE6C,SAC3C,WAAW,KAAK,CAAC,CAAC,CACpB,EAEA,OAAOK,CAAmB,EAAE,cAC1BrB,EAAK,IAAIM,EAA0B,aAAa,CAAC,CACnD,CACF,CAAC,EAED,GAAG,oDAAqD,SAAY,CAElE,MAAMa,EAAa,IAAIX,EACrB,CACE,oBAAAI,EACA,qBAAAC,EACA,kBAAAC,EACA,oBAAAC,CACF,EACAC,CACF,EAEAE,EAAYC,EAAYT,CAAqB,EAC7C,MAAMY,EAAWH,EAAW,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,EACvDD,EAAYC,EAAYR,CAAmB,EAE3C,OACEC,EAAoB,yBACtB,EAAE,sBAAsB,CAAC,EACzB,OAAO,MAAMU,CAAQ,EAAE,cACrBrB,EACE,IAAIM,EAAa,CACf,WAAY,WAAW,KAAK,CAAC,CAAC,EAC9B,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,CACH,CACF,CACF,CAAC,CACH,CAAC,EACD,SAAS,QAAS,IAAM,CACtB,GAAG,oDAAqD,SAAY,CAYlE,MAVmB,IAAIC,EACrB,CACE,oBAAAI,EACA,qBAAAC,EACA,kBAAAC,EACA,oBAAAC,CACF,EACAC,CACF,EAEiB,MAAM,EAEvB,OACEJ,EAAoB,yBACtB,EAAE,qBAAqB,IAAI,WAAWH,CAAY,CAAC,CACrD,CAAC,EACD,GAAG,oDAAqD,IAAM,CAE5D,MAAMU,EAAa,IAAIX,EACrB,CACE,oBAAAI,EACA,qBAAAC,EACA,kBAAAC,EACA,oBAAAC,CACF,EACAC,CACF,EAEAE,EAAYC,EAAYT,CAAqB,EAE7C,OAAOI,CAAiB,EAAE,qBAAqB,CAAE,UAAW,EAAK,CAAC,CACpE,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["Left", "Right", "defaultApduReceiverServiceStubBuilder", "defaultApduSenderServiceStubBuilder", "DefaultLoggerPublisherService", "bleCharacteristicStubBuilder", "DeviceNotInitializedError", "ApduResponse", "BleDeviceConnection", "GET_MTU_APDU", "GET_MTU_APDU_RESPONSE", "EMPTY_APDU_RESPONSE", "writeCharacteristic", "notifyCharacteristic", "apduSenderFactory", "apduReceiverFactory", "logger", "tag", "receiveApdu", "connection", "buffer", "errorOrApduResponse", "response"]
-}

package/lib/esm/src/internal/transport/ble/transport/WebBleTransport.js

@@ -1,2 +0,0 @@
-var _=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var u=(a,e,i,t)=>{for(var r=t>1?void 0:t?w(e,i):e,n=a.length-1,o;n>=0;n--)(o=a[n])&&(r=(t?o(e,i,r):o(r))||r);return t&&r&&_(e,i,r),r},d=(a,e)=>(i,t)=>e(i,t,a);import{inject as D,injectable as C}from"inversify";import{EitherAsync as m,Left as c,Maybe as h,Right as v}from"purify-ts";import{from as f,switchMap as E,timer as S}from"rxjs";import{v4 as T}from"uuid";import{BuiltinTransports as M}from"../../../../api/transport/model/TransportIdentifier";import{deviceModelTypes as A}from"../../../device-model/di/deviceModelTypes";import{loggerTypes as P}from"../../../logger-publisher/di/loggerTypes";import{bleDiTypes as G}from"../../../transport/ble/di/bleDiTypes";import{BleDeviceGattServerError as g,BleTransportNotSupportedError as N,DeviceAlreadyConnectedError as H,DeviceNotRecognizedError as F,NoAccessibleDeviceError as R,OpeningConnectionError as y,UnknownDeviceError as b}from"../../../transport/model/Errors";import{InternalConnectedDevice as U}from"../../../transport/model/InternalConnectedDevice";import{RECONNECT_DEVICE_TIMEOUT as L}from"../../../transport/usb/data/UsbHidConfig";let l=class{constructor(e,i,t){this._deviceModelDataSource=e;this._bleDeviceConnectionFactory=t;this._connectedDevices=[],this._internalDevicesById=new Map,this._deviceConnectionById=new Map,this._disconnectionHandlersById=new Map,this._logger=i("WebBleTransport")}_connectedDevices;_internalDevicesById;_deviceConnectionById;_disconnectionHandlersById;_logger;connectionType="BLE";identifier=M.BLE;getBluetoothApi(){return this.isSupported()?v(navigator.bluetooth):c(new N("WebBle not supported"))}isSupported(){try{return!!navigator?.bluetooth}catch{return!1}}getIdentifier(){return this.identifier}listenToKnownDevices(){return f([])}async getBleGattService(e){if(!e.gatt)return c(new g("Device gatt not found"));try{const[i]=await e.gatt.getPrimaryServices();return i?v(i):c(new g("bluetooth service not found"))}catch(i){return c(new g(i))}}getBleDeviceInfos(e){const t=this._deviceModelDataSource.getBluetoothServicesInfos()[e.uuid];return t?v(t):(this._logger.error(`Device not recognized: ${e.device.name}`),c(new F(`Device not recognized: ${e.device.name}`)))}promptDeviceAccess(){return m(async({liftEither:e,throwE:i})=>{const t=await e(this.getBluetoothApi());let r;try{r=await t.requestDevice({filters:this._deviceModelDataSource.getBluetoothServices().map(n=>({services:[n]}))})}catch(n){return i(new R(n))}return r})}getDiscoveredDeviceFrom(e){return{id:T(),deviceModel:e.deviceModel,transport:this.identifier}}setInternalDeviceFrom(e,i,t,r){const n={id:e.id,bleDevice:i,bleGattService:r,bleDeviceInfos:t,discoveredDevice:e};this._logger.debug(`Discovered device ${n.id} ${e.deviceModel.productName}`),this._internalDevicesById.set(n.id,n)}startDiscovering(){return this._logger.debug("startDiscovering"),f(this.promptDeviceAccess()).pipe(E(async e=>m(async({liftEither:i,fromPromise:t})=>{const r=await i(e);if(r.gatt)try{await r.gatt.connect()}catch(n){throw new y(n)}try{const n=await t(this.getBleGattService(r)),o=await i(this.getBleDeviceInfos(n)),s=this.getDiscoveredDeviceFrom(o);return this.setInternalDeviceFrom(s,r,o,n),s}catch(n){throw await r.forget(),n}}).caseOf({Right:i=>i,Left:i=>{throw this._logger.error("Error while getting accessible device",{data:{error:i}}),i}})))}stopDiscovering(){this._logger.debug("stopDiscovering")}async connect({deviceId:e,onDisconnect:i}){const t=this._internalDevicesById.get(e);if(!t)return this._logger.error(`Unknown device ${e}`,{data:{internalDevices:this._internalDevicesById}}),this._logger.debug("Available devices",{data:{devices:this._internalDevicesById}}),c(new b(`Unknown device ${e}`));if(this._connectedDevices.includes(t.bleDevice))return this._internalDevicesById.delete(e),c(new H("Device already connected"));const{discoveredDevice:{deviceModel:r}}=t;try{const[n,o]=await Promise.all([t.bleGattService.getCharacteristic(t.bleDeviceInfos.writeCmdUuid),t.bleGattService.getCharacteristic(t.bleDeviceInfos.notifyUuid)]),s=this._bleDeviceConnectionFactory.create(n,o);await s.setup();const p=new U({sendApdu:(B,I)=>s.sendApdu(B,I),deviceModel:r,id:e,type:this.connectionType,transport:this.identifier});return t.bleDevice.ongattserverdisconnected=this._getDeviceDisconnectedHandler(t,s),this._deviceConnectionById.set(t.id,s),this._disconnectionHandlersById.set(t.id,()=>{this.disconnect({connectedDevice:p}).then(()=>i(e))}),this._connectedDevices.push(t.bleDevice),v(p)}catch(n){return await t.bleDevice.forget(),this._internalDevicesById.delete(e),this._logger.error("Error while getting characteristics",{data:{error:n}}),c(new y(n))}}_getDeviceDisconnectedHandler(e,i){return async()=>{const t=S(L).subscribe(()=>{this._logger.debug("disconnection timer over"),h.fromNullable(this._disconnectionHandlersById.get(e.id)).map(o=>o())});await e.bleDevice.gatt?.connect(),t.unsubscribe();const r=await this.getBleGattService(e.bleDevice);if(r.isRight()){const[n,o]=await Promise.all([r.extract().getCharacteristic(e.bleDeviceInfos.writeCmdUuid),r.extract().getCharacteristic(e.bleDeviceInfos.notifyUuid)]);await i.reconnect(n,o)}}}async disconnect(e){const i=h.fromNullable(this._internalDevicesById.get(e.connectedDevice.id));return this._logger.debug("disconnect device",{data:{connectedDevice:e.connectedDevice}}),i.isNothing()?(this._logger.error(`Unknown device ${e.connectedDevice.id}`),c(new b(`Unknown device ${e.connectedDevice.id}`))):(i.map(t=>{const{bleDevice:r}=t;h.fromNullable(this._deviceConnectionById.get(t.id)).map(o=>o.disconnect()),r.gatt?.connected&&r.gatt.disconnect(),this._internalDevicesById.delete(t.id),this._deviceConnectionById.delete(t.id),this._disconnectionHandlersById.delete(t.id),this._connectedDevices.includes(r)&&delete this._connectedDevices[this._connectedDevices.indexOf(r)]}),v(void 0))}};l=u([C(),d(0,D(A.DeviceModelDataSource)),d(1,D(P.LoggerPublisherServiceFactory)),d(2,D(G.BleDeviceConnectionFactory))],l);export{l as WebBleTransport};
-//# sourceMappingURL=WebBleTransport.js.map

package/lib/esm/src/internal/transport/ble/transport/WebBleTransport.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/ble/transport/WebBleTransport.ts"],
-  "sourcesContent": ["import { inject, injectable } from \"inversify\";\nimport { Either, EitherAsync, Left, Maybe, Right } from \"purify-ts\";\nimport { from, Observable, switchMap, timer } from \"rxjs\";\nimport { v4 as uuid } from \"uuid\";\n\nimport { DeviceId } from \"@api/device/DeviceModel\";\nimport { ConnectionType } from \"@api/discovery/ConnectionType\";\nimport { DmkError } from \"@api/Error\";\nimport { Transport } from \"@api/transport/model/Transport\";\nimport {\n  BuiltinTransports,\n  TransportIdentifier,\n} from \"@api/transport/model/TransportIdentifier\";\nimport type { DeviceModelDataSource } from \"@internal/device-model/data/DeviceModelDataSource\";\nimport { deviceModelTypes } from \"@internal/device-model/di/deviceModelTypes\";\nimport { loggerTypes } from \"@internal/logger-publisher/di/loggerTypes\";\nimport type { LoggerPublisherService } from \"@internal/logger-publisher/service/LoggerPublisherService\";\nimport { bleDiTypes } from \"@internal/transport/ble/di/bleDiTypes\";\nimport { BleDeviceInfos } from \"@internal/transport/ble/model/BleDeviceInfos\";\nimport { BleDeviceConnectionFactory } from \"@internal/transport/ble/service/BleDeviceConnectionFactory\";\nimport { BleDeviceConnection } from \"@internal/transport/ble/transport/BleDeviceConnection\";\nimport { DisconnectHandler } from \"@internal/transport/model/DeviceConnection\";\nimport {\n  BleDeviceGattServerError,\n  BleTransportNotSupportedError,\n  ConnectError,\n  DeviceAlreadyConnectedError,\n  DeviceNotRecognizedError,\n  NoAccessibleDeviceError,\n  OpeningConnectionError,\n  type PromptDeviceAccessError,\n  UnknownDeviceError,\n} from \"@internal/transport/model/Errors\";\nimport { InternalConnectedDevice } from \"@internal/transport/model/InternalConnectedDevice\";\nimport { InternalDiscoveredDevice } from \"@internal/transport/model/InternalDiscoveredDevice\";\nimport { RECONNECT_DEVICE_TIMEOUT } from \"@internal/transport/usb/data/UsbHidConfig\";\n\n// An attempt to manage the state of several devices with one transport. Not final.\ntype WebBleInternalDevice = {\n  id: DeviceId;\n  bleDevice: BluetoothDevice;\n  bleDeviceInfos: BleDeviceInfos;\n  bleGattService: BluetoothRemoteGATTService;\n  discoveredDevice: InternalDiscoveredDevice;\n};\n\n@injectable()\nexport class WebBleTransport implements Transport {\n  private readonly _connectedDevices: Array<BluetoothDevice>;\n  private readonly _internalDevicesById: Map<DeviceId, WebBleInternalDevice>;\n  private _deviceConnectionById: Map<DeviceId, BleDeviceConnection>;\n  private _disconnectionHandlersById: Map<DeviceId, () => void>;\n  private _logger: LoggerPublisherService;\n  private readonly connectionType: ConnectionType = \"BLE\";\n  private readonly identifier: TransportIdentifier = BuiltinTransports.BLE;\n\n  constructor(\n    @inject(deviceModelTypes.DeviceModelDataSource)\n    private _deviceModelDataSource: DeviceModelDataSource,\n    @inject(loggerTypes.LoggerPublisherServiceFactory)\n    loggerServiceFactory: (tag: string) => LoggerPublisherService,\n    @inject(bleDiTypes.BleDeviceConnectionFactory)\n    private _bleDeviceConnectionFactory: BleDeviceConnectionFactory,\n  ) {\n    this._connectedDevices = [];\n    this._internalDevicesById = new Map();\n    this._deviceConnectionById = new Map();\n    this._disconnectionHandlersById = new Map();\n    this._logger = loggerServiceFactory(\"WebBleTransport\");\n  }\n\n  /**\n   * Get the Bluetooth API if supported or error\n   * @returns `Either<BleTransportNotSupportedError, Bluetooth>`\n   */\n  private getBluetoothApi(): Either<BleTransportNotSupportedError, Bluetooth> {\n    if (this.isSupported()) {\n      return Right(navigator.bluetooth);\n    }\n\n    return Left(new BleTransportNotSupportedError(\"WebBle not supported\"));\n  }\n\n  isSupported(): boolean {\n    try {\n      const result = !!navigator?.bluetooth;\n      return result;\n    } catch {\n      return false;\n    }\n  }\n\n  getIdentifier(): TransportIdentifier {\n    return this.identifier;\n  }\n\n  listenToKnownDevices(): Observable<InternalDiscoveredDevice[]> {\n    return from([]);\n  }\n\n  /**\n   * Get Bluetooth GATT Primary service that is used to get writeCharacteristic and notifyCharacteristic\n   * @param bleDevice\n   * @private\n   */\n  private async getBleGattService(\n    bleDevice: BluetoothDevice,\n  ): Promise<Either<BleDeviceGattServerError, BluetoothRemoteGATTService>> {\n    if (!bleDevice.gatt) {\n      return Left(new BleDeviceGattServerError(\"Device gatt not found\"));\n    }\n    try {\n      const [bleGattService] = await bleDevice.gatt.getPrimaryServices();\n      if (!bleGattService) {\n        return Left(\n          new BleDeviceGattServerError(\"bluetooth service not found\"),\n        );\n      }\n      return Right(bleGattService);\n    } catch (e) {\n      return Left(new BleDeviceGattServerError(e));\n    }\n  }\n\n  /**\n   * BleDeviceInfos to map primary service uuid to device model & characteristics uuid\n   * @param bleGattService\n   * @private\n   */\n  private getBleDeviceInfos(\n    bleGattService: BluetoothRemoteGATTService,\n  ): Either<DeviceNotRecognizedError, BleDeviceInfos> {\n    const serviceToBleInfos =\n      this._deviceModelDataSource.getBluetoothServicesInfos();\n    const bleDeviceInfos = serviceToBleInfos[bleGattService.uuid];\n\n    if (!bleDeviceInfos) {\n      this._logger.error(\n        `Device not recognized: ${bleGattService.device.name}`,\n      );\n      return Left(\n        new DeviceNotRecognizedError(\n          `Device not recognized: ${bleGattService.device.name}`,\n        ),\n      );\n    }\n    return Right(bleDeviceInfos);\n  }\n\n  /**\n   * Prompt device selection in navigator\n   *\n   * @private\n   */\n  private promptDeviceAccess(): EitherAsync<\n    PromptDeviceAccessError,\n    BluetoothDevice\n  > {\n    return EitherAsync(async ({ liftEither, throwE }) => {\n      const bluetoothApi = await liftEither(this.getBluetoothApi());\n      let bleDevice: BluetoothDevice;\n\n      try {\n        bleDevice = await bluetoothApi.requestDevice({\n          filters: this._deviceModelDataSource\n            .getBluetoothServices()\n            .map((serviceUuid) => ({\n              services: [serviceUuid],\n            })),\n        });\n      } catch (error) {\n        return throwE(new NoAccessibleDeviceError(error));\n      }\n\n      return bleDevice;\n    });\n  }\n\n  /**\n   * Generate a discovered device from BluetoothDevice, BleGATT primary service and BLE device infos\n   * @param bleDeviceInfos\n   * @private\n   */\n  private getDiscoveredDeviceFrom(\n    bleDeviceInfos: BleDeviceInfos,\n  ): InternalDiscoveredDevice {\n    return {\n      id: uuid(),\n      deviceModel: bleDeviceInfos.deviceModel,\n      transport: this.identifier,\n    };\n  }\n\n  /**\n   * Generate an InternalDevice from a unique id, a BluetoothDevice, BleGATT primary service and BLE device infos\n   * @param discoveredDevice\n   * @param bleDevice\n   * @param bleDeviceInfos\n   * @param bleGattService\n   * @private\n   */\n  private setInternalDeviceFrom(\n    discoveredDevice: InternalDiscoveredDevice,\n    bleDevice: BluetoothDevice,\n    bleDeviceInfos: BleDeviceInfos,\n    bleGattService: BluetoothRemoteGATTService,\n  ) {\n    const internalDevice: WebBleInternalDevice = {\n      id: discoveredDevice.id,\n      bleDevice,\n      bleGattService,\n      bleDeviceInfos,\n      discoveredDevice,\n    };\n\n    this._logger.debug(\n      `Discovered device ${internalDevice.id} ${discoveredDevice.deviceModel.productName}`,\n    );\n    this._internalDevicesById.set(internalDevice.id, internalDevice);\n  }\n\n  /**\n   * Main method to get a device from a button click handler\n   * The GATT connection is done here in order to populate InternalDiscoveredDevice with deviceModel\n   */\n  startDiscovering(): Observable<InternalDiscoveredDevice> {\n    this._logger.debug(\"startDiscovering\");\n\n    return from(this.promptDeviceAccess()).pipe(\n      switchMap(async (errorOrBleDevice) =>\n        EitherAsync(async ({ liftEither, fromPromise }) => {\n          const bleDevice = await liftEither(errorOrBleDevice);\n          if (bleDevice.gatt) {\n            try {\n              await bleDevice.gatt.connect();\n            } catch (error) {\n              throw new OpeningConnectionError(error);\n            }\n          }\n          try {\n            const bleGattService = await fromPromise(\n              this.getBleGattService(bleDevice),\n            );\n            const bleDeviceInfos = await liftEither(\n              this.getBleDeviceInfos(bleGattService),\n            );\n            const discoveredDevice =\n              this.getDiscoveredDeviceFrom(bleDeviceInfos);\n            this.setInternalDeviceFrom(\n              discoveredDevice,\n              bleDevice,\n              bleDeviceInfos,\n              bleGattService,\n            );\n            return discoveredDevice;\n          } catch (error) {\n            await bleDevice.forget();\n            throw error;\n          }\n        }).caseOf({\n          Right: (discoveredDevice) => discoveredDevice,\n          Left: (error) => {\n            this._logger.error(\"Error while getting accessible device\", {\n              data: { error },\n            });\n            throw error;\n          },\n        }),\n      ),\n    );\n  }\n\n  stopDiscovering(): void {\n    this._logger.debug(\"stopDiscovering\");\n  }\n\n  /**\n   * Connect to a BLE device and update the internal state of the associated device\n   * Handle ondisconnect event on the device in order to try a reconnection\n   */\n  async connect({\n    deviceId,\n    onDisconnect,\n  }: {\n    deviceId: DeviceId;\n    onDisconnect: DisconnectHandler;\n  }): Promise<Either<ConnectError, InternalConnectedDevice>> {\n    const internalDevice = this._internalDevicesById.get(deviceId);\n\n    if (!internalDevice) {\n      this._logger.error(`Unknown device ${deviceId}`, {\n        data: { internalDevices: this._internalDevicesById },\n      });\n      this._logger.debug(\"Available devices\", {\n        data: { devices: this._internalDevicesById },\n      });\n      return Left(new UnknownDeviceError(`Unknown device ${deviceId}`));\n    }\n    // if device already connected, remove device id from internal state and remove error\n    if (this._connectedDevices.includes(internalDevice.bleDevice)) {\n      this._internalDevicesById.delete(deviceId);\n      return Left(new DeviceAlreadyConnectedError(\"Device already connected\"));\n    }\n\n    const {\n      discoveredDevice: { deviceModel },\n    } = internalDevice;\n\n    try {\n      const [writeCharacteristic, notifyCharacteristic] = await Promise.all([\n        internalDevice.bleGattService.getCharacteristic(\n          internalDevice.bleDeviceInfos.writeCmdUuid,\n        ),\n        internalDevice.bleGattService.getCharacteristic(\n          internalDevice.bleDeviceInfos.notifyUuid,\n        ),\n      ]);\n      const deviceConnection = this._bleDeviceConnectionFactory.create(\n        writeCharacteristic,\n        notifyCharacteristic,\n      );\n      await deviceConnection.setup();\n      const connectedDevice = new InternalConnectedDevice({\n        sendApdu: (apdu, triggersDisconnection) =>\n          deviceConnection.sendApdu(apdu, triggersDisconnection),\n        deviceModel,\n        id: deviceId,\n        type: this.connectionType,\n        transport: this.identifier,\n      });\n      internalDevice.bleDevice.ongattserverdisconnected =\n        this._getDeviceDisconnectedHandler(internalDevice, deviceConnection);\n      this._deviceConnectionById.set(internalDevice.id, deviceConnection);\n      this._disconnectionHandlersById.set(internalDevice.id, () => {\n        this.disconnect({ connectedDevice }).then(() => onDisconnect(deviceId));\n      });\n      this._connectedDevices.push(internalDevice.bleDevice);\n      return Right(connectedDevice);\n    } catch (error) {\n      await internalDevice.bleDevice.forget();\n      this._internalDevicesById.delete(deviceId);\n      this._logger.error(\"Error while getting characteristics\", {\n        data: { error },\n      });\n      return Left(new OpeningConnectionError(error));\n    }\n  }\n\n  /**\n   * Get the device disconnected handler\n   * @param internalDevice WebBleInternalDevice\n   * @param deviceConnection BleDeviceConnection\n   * @returns async () => void\n   * @private\n   */\n  private _getDeviceDisconnectedHandler(\n    internalDevice: WebBleInternalDevice,\n    deviceConnection: BleDeviceConnection,\n  ) {\n    return async () => {\n      // start a timer to disconnect the device if it does not reconnect\n      const disconnectObserver = timer(RECONNECT_DEVICE_TIMEOUT).subscribe(\n        () => {\n          this._logger.debug(\"disconnection timer over\");\n          // retrieve the disconnect handler and call it\n          const disconnectHandler = Maybe.fromNullable(\n            this._disconnectionHandlersById.get(internalDevice.id),\n          );\n          disconnectHandler.map((handler) => handler());\n        },\n      );\n      // connect to the navigator device\n      await internalDevice.bleDevice.gatt?.connect();\n      // cancel disconnection timeout\n      disconnectObserver.unsubscribe();\n      // retrieve new ble characteristics\n      const service = await this.getBleGattService(internalDevice.bleDevice);\n      if (service.isRight()) {\n        const [writeC, notifyC] = await Promise.all([\n          service\n            .extract()\n            .getCharacteristic(internalDevice.bleDeviceInfos.writeCmdUuid),\n          service\n            .extract()\n            .getCharacteristic(internalDevice.bleDeviceInfos.notifyUuid),\n        ]);\n        // reconnect device connection\n        await deviceConnection.reconnect(writeC, notifyC);\n      }\n    };\n  }\n\n  /**\n   * Disconnect from a BLE device and delete its handlers\n   *\n   * @param params { connectedDevice: InternalConnectedDevice }\n   */\n  async disconnect(params: {\n    connectedDevice: InternalConnectedDevice;\n  }): Promise<Either<DmkError, void>> {\n    // retrieve internal device\n    const maybeInternalDevice = Maybe.fromNullable(\n      this._internalDevicesById.get(params.connectedDevice.id),\n    );\n    this._logger.debug(\"disconnect device\", {\n      data: { connectedDevice: params.connectedDevice },\n    });\n\n    if (maybeInternalDevice.isNothing()) {\n      this._logger.error(`Unknown device ${params.connectedDevice.id}`);\n      return Left(\n        new UnknownDeviceError(`Unknown device ${params.connectedDevice.id}`),\n      );\n    }\n    maybeInternalDevice.map((device) => {\n      const { bleDevice } = device;\n      // retrieve device connection and disconnect it\n      const maybeDeviceConnection = Maybe.fromNullable(\n        this._deviceConnectionById.get(device.id),\n      );\n      maybeDeviceConnection.map((dConnection) => dConnection.disconnect());\n      // disconnect device gatt server\n      if (bleDevice.gatt?.connected) {\n        bleDevice.gatt.disconnect();\n      }\n      // clean up objects\n      this._internalDevicesById.delete(device.id);\n      this._deviceConnectionById.delete(device.id);\n      this._disconnectionHandlersById.delete(device.id);\n      if (this._connectedDevices.includes(bleDevice)) {\n        delete this._connectedDevices[\n          this._connectedDevices.indexOf(bleDevice)\n        ];\n      }\n    });\n\n    return Right(void 0);\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["inject", "injectable", "EitherAsync", "Left", "Maybe", "Right", "from", "switchMap", "timer", "uuid", "BuiltinTransports", "deviceModelTypes", "loggerTypes", "bleDiTypes", "BleDeviceGattServerError", "BleTransportNotSupportedError", "DeviceAlreadyConnectedError", "DeviceNotRecognizedError", "NoAccessibleDeviceError", "OpeningConnectionError", "UnknownDeviceError", "InternalConnectedDevice", "RECONNECT_DEVICE_TIMEOUT", "WebBleTransport", "_deviceModelDataSource", "loggerServiceFactory", "_bleDeviceConnectionFactory", "BuiltinTransports", "Right", "Left", "BleTransportNotSupportedError", "from", "bleDevice", "BleDeviceGattServerError", "bleGattService", "e", "bleDeviceInfos", "DeviceNotRecognizedError", "EitherAsync", "liftEither", "throwE", "bluetoothApi", "serviceUuid", "error", "NoAccessibleDeviceError", "uuid", "discoveredDevice", "internalDevice", "switchMap", "errorOrBleDevice", "fromPromise", "OpeningConnectionError", "deviceId", "onDisconnect", "UnknownDeviceError", "DeviceAlreadyConnectedError", "deviceModel", "writeCharacteristic", "notifyCharacteristic", "deviceConnection", "connectedDevice", "InternalConnectedDevice", "apdu", "triggersDisconnection", "disconnectObserver", "timer", "RECONNECT_DEVICE_TIMEOUT", "Maybe", "handler", "service", "writeC", "notifyC", "params", "maybeInternalDevice", "device", "dConnection", "__decorateClass", "injectable", "__decorateParam", "inject", "deviceModelTypes", "loggerTypes", "bleDiTypes"]
-}

package/lib/esm/src/internal/transport/ble/transport/WebBleTransport.test.js

@@ -1,2 +0,0 @@
-import{Left as l,Right as f}from"purify-ts";import{StaticDeviceModelDataSource as m}from"../../../device-model/data/StaticDeviceModelDataSource";import{DefaultLoggerPublisherService as g}from"../../../logger-publisher/service/DefaultLoggerPublisherService";import{bleDeviceStubBuilder as b}from"../../../transport/ble/model/BleDevice.stub";import{bleDeviceConnectionFactoryStubBuilder as D}from"../../../transport/ble/service/BleDeviceConnectionFactory.stub";import{BleDeviceGattServerError as u,BleTransportNotSupportedError as w,NoAccessibleDeviceError as v,OpeningConnectionError as E,UnknownDeviceError as p}from"../../../transport/model/Errors";import{RECONNECT_DEVICE_TIMEOUT as h}from"../../../transport/usb/data/UsbHidConfig";import{WebBleTransport as k}from"./WebBleTransport";jest.mock("@internal/logger-publisher/service/LoggerPublisherService");const x=new m,O=new g([],"web-ble"),i=b();describe("WebBleTransport",()=>{let c;beforeEach(()=>{c=new k(x,()=>O,D()),jest.useFakeTimers()}),afterEach(()=>{jest.restoreAllMocks()});const r=(n,e)=>{c.startDiscovering().subscribe({next:n,error:e})};describe("When Web bluetooth API is not supported",()=>{it("should not support the transport",()=>{expect(c.isSupported()).toBe(!1)}),it("should emit a startDiscovering error",n=>{r(()=>{n("Should not emit any value")},e=>{expect(e).toBeInstanceOf(w),n()})})}),describe("When Web Bluetooth API is supported",()=>{const n=jest.fn();beforeAll(()=>{global.navigator={bluetooth:{requestDevice:n}}}),afterAll(()=>{jest.restoreAllMocks(),global.navigator=void 0}),it("should support the transport",()=>{expect(c.isSupported()).toBe(!0)}),describe("startDiscovering",()=>{it("should emit device if one new grant access",e=>{n.mockResolvedValueOnce(i),r(t=>{try{expect(t).toEqual(expect.objectContaining({deviceModel:expect.objectContaining({id:"nanoX",productName:"Ledger Nano X"})})),e()}catch(o){e(o)}},t=>{e(t)})}),it("should throw DeviceNotRecognizedError if the device is not recognized",e=>{n.mockResolvedValueOnce({...i,gatt:{...i.gatt,getPrimaryServices:jest.fn(()=>Promise.resolve([]))},productId:16962}),r(()=>{e("should not return a device")},t=>{expect(t).toBeInstanceOf(u),e()})}),it("should emit an error if the request device is in error",e=>{const t="request device error";n.mockImplementationOnce(()=>{throw new Error(t)}),r(()=>{e("should not return a device")},o=>{expect(o).toBeInstanceOf(v),expect(o).toStrictEqual(new v(new Error(t))),e()})}),it("should emit an error if the user did not grant us access to a device (clicking on cancel on the browser popup for ex)",e=>{n.mockResolvedValueOnce({forget:jest.fn()}),r(t=>{e(`Should not emit any value, but emitted ${JSON.stringify(t)}`)},t=>{try{expect(t).toBeInstanceOf(u),e()}catch(o){e(o)}})})}),describe("connect",()=>{it("should throw UnknownDeviceError if no internal device",async()=>{const e={deviceId:"fake",onDisconnect:jest.fn()},t=await c.connect(e);expect(t).toStrictEqual(l(new p("Unknown device fake")))}),it("should throw OpeningConnectionError if the device is already opened",async()=>{const e={deviceId:"fake",onDisconnect:jest.fn()},t=await c.connect(e);expect(t).toStrictEqual(l(new p("Unknown device fake")))}),it("should throw OpeningConnectionError if the device cannot be opened",e=>{const t="cannot be opened";n.mockResolvedValueOnce({...i,gatt:{connect:()=>{throw new Error(t)}}}),r(()=>{e()},o=>{expect(o).toBeInstanceOf(E),e()})}),it("should return the opened device",e=>{n.mockResolvedValueOnce({...i,gatt:{...i.gatt,connected:!0}}),r(t=>{c.connect({deviceId:t.id,onDisconnect:jest.fn()}).then(o=>{o.ifRight(s=>{expect(s).toEqual(expect.objectContaining({id:t.id})),e()}).ifLeft(()=>{e(o)})}).catch(o=>{e(o)})},t=>{e(t)})}),it("should return a device if available",e=>{n.mockResolvedValueOnce(i),r(t=>{c.connect({deviceId:t.id,onDisconnect:jest.fn()}).then(o=>{o.ifRight(s=>{expect(s).toEqual(expect.objectContaining({id:t.id})),e()}).ifLeft(()=>{e(o)})}).catch(o=>{e(o)})},t=>{e(t)})})}),describe("disconnect",()=>{it("should disconnect the device",e=>{n.mockResolvedValueOnce(i);const t=jest.fn();r(o=>{c.connect({deviceId:o.id,onDisconnect:t}).then(s=>{s.ifRight(a=>{c.disconnect({connectedDevice:a}).then(d=>{expect(d).toStrictEqual(f(void 0)),e()}).catch(d=>{e(d)})})})},o=>{e(o)})}),it("should call disconnect handler if device is hardware disconnected",e=>{const t=jest.fn(),o=jest.spyOn(c,"disconnect");n.mockResolvedValueOnce(i),r(s=>{c.connect({deviceId:s.id,onDisconnect:t}).then(()=>{i.ongattserverdisconnected(new Event("")),jest.advanceTimersByTime(h),expect(o).toHaveBeenCalled(),e()})},s=>{e(s)})})}),describe("reconnect",()=>{it("should not call disconnection if reconnection happen",e=>{const t=jest.fn(),o=jest.spyOn(c,"disconnect");n.mockResolvedValueOnce(i),r(s=>{c.connect({deviceId:s.id,onDisconnect:t}).then(()=>{i.ongattserverdisconnected(new Event("")),jest.advanceTimersByTime(h/3),expect(o).toHaveBeenCalledTimes(0),e()}).catch(a=>{e(a)})})})})})});
-//# sourceMappingURL=WebBleTransport.test.js.map

package/lib/esm/src/internal/transport/ble/transport/WebBleTransport.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/ble/transport/WebBleTransport.test.ts"],
-  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { type DeviceModel } from \"@api/device/DeviceModel\";\nimport { StaticDeviceModelDataSource } from \"@internal/device-model/data/StaticDeviceModelDataSource\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/DefaultLoggerPublisherService\";\nimport { bleDeviceStubBuilder } from \"@internal/transport/ble/model/BleDevice.stub\";\nimport { bleDeviceConnectionFactoryStubBuilder } from \"@internal/transport/ble/service/BleDeviceConnectionFactory.stub\";\nimport {\n  BleDeviceGattServerError,\n  BleTransportNotSupportedError,\n  NoAccessibleDeviceError,\n  OpeningConnectionError,\n  UnknownDeviceError,\n} from \"@internal/transport/model/Errors\";\nimport { type InternalDiscoveredDevice } from \"@internal/transport/model/InternalDiscoveredDevice\";\nimport { RECONNECT_DEVICE_TIMEOUT } from \"@internal/transport/usb/data/UsbHidConfig\";\n\nimport { WebBleTransport } from \"./WebBleTransport\";\n\njest.mock(\"@internal/logger-publisher/service/LoggerPublisherService\");\n\n// Our StaticDeviceModelDataSource can directly be used in our unit tests\nconst bleDeviceModelDataSource = new StaticDeviceModelDataSource();\nconst logger = new DefaultLoggerPublisherService([], \"web-ble\");\n\nconst stubDevice: BluetoothDevice = bleDeviceStubBuilder();\n\ndescribe(\"WebBleTransport\", () => {\n  let transport: WebBleTransport;\n\n  beforeEach(() => {\n    transport = new WebBleTransport(\n      bleDeviceModelDataSource,\n      () => logger,\n      bleDeviceConnectionFactoryStubBuilder(),\n    );\n    jest.useFakeTimers();\n  });\n\n  afterEach(() => {\n    jest.restoreAllMocks();\n  });\n\n  const discoverDevice = (\n    onSuccess: (discoveredDevice: InternalDiscoveredDevice) => void,\n    onError?: (error: unknown) => void,\n  ) => {\n    transport.startDiscovering().subscribe({\n      next: onSuccess,\n      error: onError,\n    });\n  };\n\n  describe(\"When Web bluetooth API is not supported\", () => {\n    it(\"should not support the transport\", () => {\n      expect(transport.isSupported()).toBe(false);\n    });\n\n    it(\"should emit a startDiscovering error\", (done) => {\n      discoverDevice(\n        () => {\n          done(\"Should not emit any value\");\n        },\n        (error) => {\n          expect(error).toBeInstanceOf(BleTransportNotSupportedError);\n          done();\n        },\n      );\n    });\n  });\n\n  describe(\"When Web Bluetooth API is supported\", () => {\n    const mockedRequestDevice = jest.fn();\n\n    beforeAll(() => {\n      global.navigator = {\n        bluetooth: {\n          requestDevice: mockedRequestDevice,\n        },\n      } as unknown as Navigator;\n    });\n\n    afterAll(() => {\n      jest.restoreAllMocks();\n      global.navigator = undefined as unknown as Navigator;\n    });\n\n    it(\"should support the transport\", () => {\n      expect(transport.isSupported()).toBe(true);\n    });\n\n    describe(\"startDiscovering\", () => {\n      it(\"should emit device if one new grant access\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce(stubDevice);\n\n        discoverDevice(\n          (discoveredDevice) => {\n            try {\n              expect(discoveredDevice).toEqual(\n                expect.objectContaining({\n                  deviceModel: expect.objectContaining({\n                    id: \"nanoX\",\n                    productName: \"Ledger Nano X\",\n                  }) as DeviceModel,\n                }),\n              );\n\n              done();\n            } catch (expectError) {\n              done(expectError);\n            }\n          },\n          (error) => {\n            done(error);\n          },\n        );\n      });\n\n      it(\"should throw DeviceNotRecognizedError if the device is not recognized\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce({\n          ...stubDevice,\n          gatt: {\n            ...stubDevice.gatt,\n            getPrimaryServices: jest.fn(() => Promise.resolve([])),\n          },\n          productId: 0x4242,\n        });\n\n        discoverDevice(\n          () => {\n            done(\"should not return a device\");\n          },\n          (error) => {\n            expect(error).toBeInstanceOf(BleDeviceGattServerError);\n            done();\n          },\n        );\n      });\n\n      it(\"should emit an error if the request device is in error\", (done) => {\n        const message = \"request device error\";\n        mockedRequestDevice.mockImplementationOnce(() => {\n          throw new Error(message);\n        });\n\n        discoverDevice(\n          () => {\n            done(\"should not return a device\");\n          },\n          (error) => {\n            expect(error).toBeInstanceOf(NoAccessibleDeviceError);\n            expect(error).toStrictEqual(\n              new NoAccessibleDeviceError(new Error(message)),\n            );\n            done();\n          },\n        );\n      });\n\n      it(\"should emit an error if the user did not grant us access to a device (clicking on cancel on the browser popup for ex)\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce({ forget: jest.fn() });\n\n        discoverDevice(\n          (discoveredDevice) => {\n            done(\n              `Should not emit any value, but emitted ${JSON.stringify(\n                discoveredDevice,\n              )}`,\n            );\n          },\n          (error) => {\n            try {\n              expect(error).toBeInstanceOf(BleDeviceGattServerError);\n              done();\n            } catch (expectError) {\n              done(expectError);\n            }\n          },\n        );\n      });\n    });\n\n    describe(\"connect\", () => {\n      it(\"should throw UnknownDeviceError if no internal device\", async () => {\n        const connectParams = {\n          deviceId: \"fake\",\n          onDisconnect: jest.fn(),\n        };\n\n        const connect = await transport.connect(connectParams);\n\n        expect(connect).toStrictEqual(\n          Left(new UnknownDeviceError(\"Unknown device fake\")),\n        );\n      });\n\n      it(\"should throw OpeningConnectionError if the device is already opened\", async () => {\n        const device = {\n          deviceId: \"fake\",\n          onDisconnect: jest.fn(),\n        };\n\n        const connect = await transport.connect(device);\n\n        expect(connect).toStrictEqual(\n          Left(new UnknownDeviceError(\"Unknown device fake\")),\n        );\n      });\n\n      it(\"should throw OpeningConnectionError if the device cannot be opened\", (done) => {\n        const message = \"cannot be opened\";\n        mockedRequestDevice.mockResolvedValueOnce({\n          ...stubDevice,\n          gatt: {\n            connect: () => {\n              throw new Error(message);\n            },\n          },\n        });\n\n        discoverDevice(\n          () => {\n            done();\n          },\n          (error) => {\n            expect(error).toBeInstanceOf(OpeningConnectionError);\n            done();\n          },\n        );\n      });\n\n      it(\"should return the opened device\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce({\n          ...stubDevice,\n          gatt: {\n            ...stubDevice.gatt,\n            connected: true,\n          },\n        });\n\n        discoverDevice(\n          (discoveredDevice) => {\n            transport\n              .connect({\n                deviceId: discoveredDevice.id,\n                onDisconnect: jest.fn(),\n              })\n              .then((connectedDevice) => {\n                connectedDevice\n                  .ifRight((device) => {\n                    expect(device).toEqual(\n                      expect.objectContaining({ id: discoveredDevice.id }),\n                    );\n                    done();\n                  })\n                  .ifLeft(() => {\n                    done(connectedDevice);\n                  });\n              })\n              .catch((error) => {\n                done(error);\n              });\n          },\n          (error) => {\n            done(error);\n          },\n        );\n      });\n\n      it(\"should return a device if available\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce(stubDevice);\n\n        discoverDevice(\n          (discoveredDevice) => {\n            transport\n              .connect({\n                deviceId: discoveredDevice.id,\n                onDisconnect: jest.fn(),\n              })\n              .then((connectedDevice) => {\n                connectedDevice\n                  .ifRight((device) => {\n                    expect(device).toEqual(\n                      expect.objectContaining({ id: discoveredDevice.id }),\n                    );\n                    done();\n                  })\n                  .ifLeft(() => {\n                    done(connectedDevice);\n                  });\n              })\n              .catch((error) => {\n                done(error);\n              });\n          },\n          (error) => {\n            done(error);\n          },\n        );\n      });\n    });\n\n    describe(\"disconnect\", () => {\n      it(\"should disconnect the device\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce(stubDevice);\n\n        const onDisconnect = jest.fn();\n\n        discoverDevice(\n          (discoveredDevice) => {\n            transport\n              .connect({\n                deviceId: discoveredDevice.id,\n                onDisconnect,\n              })\n              .then((connectedDevice) => {\n                connectedDevice.ifRight((device) => {\n                  transport\n                    .disconnect({ connectedDevice: device })\n                    .then((value) => {\n                      expect(value).toStrictEqual(Right(void 0));\n                      done();\n                    })\n                    .catch((error) => {\n                      done(error);\n                    });\n                });\n              });\n          },\n          (error) => {\n            done(error);\n          },\n        );\n      });\n      it(\"should call disconnect handler if device is hardware disconnected\", (done) => {\n        const onDisconnect = jest.fn();\n        const disconnectSpy = jest.spyOn(transport, \"disconnect\");\n        mockedRequestDevice.mockResolvedValueOnce(stubDevice);\n\n        discoverDevice(\n          (discoveredDevice) => {\n            transport\n              .connect({\n                deviceId: discoveredDevice.id,\n                onDisconnect,\n              })\n              .then(() => {\n                stubDevice.ongattserverdisconnected(new Event(\"\"));\n                jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);\n                expect(disconnectSpy).toHaveBeenCalled();\n                done();\n              });\n          },\n          (error) => {\n            done(error);\n          },\n        );\n      });\n    });\n\n    describe(\"reconnect\", () => {\n      it(\"should not call disconnection if reconnection happen\", (done) => {\n        // given\n        const onDisconnect = jest.fn();\n        const disconnectSpy = jest.spyOn(transport, \"disconnect\");\n        mockedRequestDevice.mockResolvedValueOnce(stubDevice);\n\n        // when\n        discoverDevice((discoveredDevice) => {\n          transport\n            .connect({\n              deviceId: discoveredDevice.id,\n              onDisconnect,\n            })\n            .then(() => {\n              stubDevice.ongattserverdisconnected(new Event(\"\"));\n\n              jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT / 3);\n\n              // then\n              expect(disconnectSpy).toHaveBeenCalledTimes(0);\n              done();\n            })\n            .catch((error) => {\n              done(error);\n            });\n        });\n      });\n    });\n  });\n});\n"],
-  "mappings": "AAAA,OAAS,QAAAA,EAAM,SAAAC,MAAa,YAG5B,OAAS,+BAAAC,MAAmC,0DAC5C,OAAS,iCAAAC,MAAqC,mEAC9C,OAAS,wBAAAC,MAA4B,+CACrC,OAAS,yCAAAC,MAA6C,kEACtD,OACE,4BAAAC,EACA,iCAAAC,EACA,2BAAAC,EACA,0BAAAC,EACA,sBAAAC,MACK,mCAEP,OAAS,4BAAAC,MAAgC,4CAEzC,OAAS,mBAAAC,MAAuB,oBAEhC,KAAK,KAAK,2DAA2D,EAGrE,MAAMC,EAA2B,IAAIX,EAC/BY,EAAS,IAAIX,EAA8B,CAAC,EAAG,SAAS,EAExDY,EAA8BX,EAAqB,EAEzD,SAAS,kBAAmB,IAAM,CAChC,IAAIY,EAEJ,WAAW,IAAM,CACfA,EAAY,IAAIJ,EACdC,EACA,IAAMC,EACNT,EAAsC,CACxC,EACA,KAAK,cAAc,CACrB,CAAC,EAED,UAAU,IAAM,CACd,KAAK,gBAAgB,CACvB,CAAC,EAED,MAAMY,EAAiB,CACrBC,EACAC,IACG,CACHH,EAAU,iBAAiB,EAAE,UAAU,CACrC,KAAME,EACN,MAAOC,CACT,CAAC,CACH,EAEA,SAAS,0CAA2C,IAAM,CACxD,GAAG,mCAAoC,IAAM,CAC3C,OAAOH,EAAU,YAAY,CAAC,EAAE,KAAK,EAAK,CAC5C,CAAC,EAED,GAAG,uCAAyCI,GAAS,CACnDH,EACE,IAAM,CACJG,EAAK,2BAA2B,CAClC,EACCC,GAAU,CACT,OAAOA,CAAK,EAAE,eAAed,CAA6B,EAC1Da,EAAK,CACP,CACF,CACF,CAAC,CACH,CAAC,EAED,SAAS,sCAAuC,IAAM,CACpD,MAAME,EAAsB,KAAK,GAAG,EAEpC,UAAU,IAAM,CACd,OAAO,UAAY,CACjB,UAAW,CACT,cAAeA,CACjB,CACF,CACF,CAAC,EAED,SAAS,IAAM,CACb,KAAK,gBAAgB,EACrB,OAAO,UAAY,MACrB,CAAC,EAED,GAAG,+BAAgC,IAAM,CACvC,OAAON,EAAU,YAAY,CAAC,EAAE,KAAK,EAAI,CAC3C,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,6CAA+CI,GAAS,CACzDE,EAAoB,sBAAsBP,CAAU,EAEpDE,EACGM,GAAqB,CACpB,GAAI,CACF,OAAOA,CAAgB,EAAE,QACvB,OAAO,iBAAiB,CACtB,YAAa,OAAO,iBAAiB,CACnC,GAAI,QACJ,YAAa,eACf,CAAC,CACH,CAAC,CACH,EAEAH,EAAK,CACP,OAASI,EAAa,CACpBJ,EAAKI,CAAW,CAClB,CACF,EACCH,GAAU,CACTD,EAAKC,CAAK,CACZ,CACF,CACF,CAAC,EAED,GAAG,wEAA0ED,GAAS,CACpFE,EAAoB,sBAAsB,CACxC,GAAGP,EACH,KAAM,CACJ,GAAGA,EAAW,KACd,mBAAoB,KAAK,GAAG,IAAM,QAAQ,QAAQ,CAAC,CAAC,CAAC,CACvD,EACA,UAAW,KACb,CAAC,EAEDE,EACE,IAAM,CACJG,EAAK,4BAA4B,CACnC,EACCC,GAAU,CACT,OAAOA,CAAK,EAAE,eAAef,CAAwB,EACrDc,EAAK,CACP,CACF,CACF,CAAC,EAED,GAAG,yDAA2DA,GAAS,CACrE,MAAMK,EAAU,uBAChBH,EAAoB,uBAAuB,IAAM,CAC/C,MAAM,IAAI,MAAMG,CAAO,CACzB,CAAC,EAEDR,EACE,IAAM,CACJG,EAAK,4BAA4B,CACnC,EACCC,GAAU,CACT,OAAOA,CAAK,EAAE,eAAeb,CAAuB,EACpD,OAAOa,CAAK,EAAE,cACZ,IAAIb,EAAwB,IAAI,MAAMiB,CAAO,CAAC,CAChD,EACAL,EAAK,CACP,CACF,CACF,CAAC,EAED,GAAG,wHAA0HA,GAAS,CACpIE,EAAoB,sBAAsB,CAAE,OAAQ,KAAK,GAAG,CAAE,CAAC,EAE/DL,EACGM,GAAqB,CACpBH,EACE,0CAA0C,KAAK,UAC7CG,CACF,CAAC,EACH,CACF,EACCF,GAAU,CACT,GAAI,CACF,OAAOA,CAAK,EAAE,eAAef,CAAwB,EACrDc,EAAK,CACP,OAASI,EAAa,CACpBJ,EAAKI,CAAW,CAClB,CACF,CACF,CACF,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,wDAAyD,SAAY,CACtE,MAAME,EAAgB,CACpB,SAAU,OACV,aAAc,KAAK,GAAG,CACxB,EAEMC,EAAU,MAAMX,EAAU,QAAQU,CAAa,EAErD,OAAOC,CAAO,EAAE,cACd3B,EAAK,IAAIU,EAAmB,qBAAqB,CAAC,CACpD,CACF,CAAC,EAED,GAAG,sEAAuE,SAAY,CACpF,MAAMkB,EAAS,CACb,SAAU,OACV,aAAc,KAAK,GAAG,CACxB,EAEMD,EAAU,MAAMX,EAAU,QAAQY,CAAM,EAE9C,OAAOD,CAAO,EAAE,cACd3B,EAAK,IAAIU,EAAmB,qBAAqB,CAAC,CACpD,CACF,CAAC,EAED,GAAG,qEAAuEU,GAAS,CACjF,MAAMK,EAAU,mBAChBH,EAAoB,sBAAsB,CACxC,GAAGP,EACH,KAAM,CACJ,QAAS,IAAM,CACb,MAAM,IAAI,MAAMU,CAAO,CACzB,CACF,CACF,CAAC,EAEDR,EACE,IAAM,CACJG,EAAK,CACP,EACCC,GAAU,CACT,OAAOA,CAAK,EAAE,eAAeZ,CAAsB,EACnDW,EAAK,CACP,CACF,CACF,CAAC,EAED,GAAG,kCAAoCA,GAAS,CAC9CE,EAAoB,sBAAsB,CACxC,GAAGP,EACH,KAAM,CACJ,GAAGA,EAAW,KACd,UAAW,EACb,CACF,CAAC,EAEDE,EACGM,GAAqB,CACpBP,EACG,QAAQ,CACP,SAAUO,EAAiB,GAC3B,aAAc,KAAK,GAAG,CACxB,CAAC,EACA,KAAMM,GAAoB,CACzBA,EACG,QAASD,GAAW,CACnB,OAAOA,CAAM,EAAE,QACb,OAAO,iBAAiB,CAAE,GAAIL,EAAiB,EAAG,CAAC,CACrD,EACAH,EAAK,CACP,CAAC,EACA,OAAO,IAAM,CACZA,EAAKS,CAAe,CACtB,CAAC,CACL,CAAC,EACA,MAAOR,GAAU,CAChBD,EAAKC,CAAK,CACZ,CAAC,CACL,EACCA,GAAU,CACTD,EAAKC,CAAK,CACZ,CACF,CACF,CAAC,EAED,GAAG,sCAAwCD,GAAS,CAClDE,EAAoB,sBAAsBP,CAAU,EAEpDE,EACGM,GAAqB,CACpBP,EACG,QAAQ,CACP,SAAUO,EAAiB,GAC3B,aAAc,KAAK,GAAG,CACxB,CAAC,EACA,KAAMM,GAAoB,CACzBA,EACG,QAASD,GAAW,CACnB,OAAOA,CAAM,EAAE,QACb,OAAO,iBAAiB,CAAE,GAAIL,EAAiB,EAAG,CAAC,CACrD,EACAH,EAAK,CACP,CAAC,EACA,OAAO,IAAM,CACZA,EAAKS,CAAe,CACtB,CAAC,CACL,CAAC,EACA,MAAOR,GAAU,CAChBD,EAAKC,CAAK,CACZ,CAAC,CACL,EACCA,GAAU,CACTD,EAAKC,CAAK,CACZ,CACF,CACF,CAAC,CACH,CAAC,EAED,SAAS,aAAc,IAAM,CAC3B,GAAG,+BAAiCD,GAAS,CAC3CE,EAAoB,sBAAsBP,CAAU,EAEpD,MAAMe,EAAe,KAAK,GAAG,EAE7Bb,EACGM,GAAqB,CACpBP,EACG,QAAQ,CACP,SAAUO,EAAiB,GAC3B,aAAAO,CACF,CAAC,EACA,KAAMD,GAAoB,CACzBA,EAAgB,QAASD,GAAW,CAClCZ,EACG,WAAW,CAAE,gBAAiBY,CAAO,CAAC,EACtC,KAAMG,GAAU,CACf,OAAOA,CAAK,EAAE,cAAc9B,EAAM,MAAM,CAAC,EACzCmB,EAAK,CACP,CAAC,EACA,MAAOC,GAAU,CAChBD,EAAKC,CAAK,CACZ,CAAC,CACL,CAAC,CACH,CAAC,CACL,EACCA,GAAU,CACTD,EAAKC,CAAK,CACZ,CACF,CACF,CAAC,EACD,GAAG,oEAAsED,GAAS,CAChF,MAAMU,EAAe,KAAK,GAAG,EACvBE,EAAgB,KAAK,MAAMhB,EAAW,YAAY,EACxDM,EAAoB,sBAAsBP,CAAU,EAEpDE,EACGM,GAAqB,CACpBP,EACG,QAAQ,CACP,SAAUO,EAAiB,GAC3B,aAAAO,CACF,CAAC,EACA,KAAK,IAAM,CACVf,EAAW,yBAAyB,IAAI,MAAM,EAAE,CAAC,EACjD,KAAK,oBAAoBJ,CAAwB,EACjD,OAAOqB,CAAa,EAAE,iBAAiB,EACvCZ,EAAK,CACP,CAAC,CACL,EACCC,GAAU,CACTD,EAAKC,CAAK,CACZ,CACF,CACF,CAAC,CACH,CAAC,EAED,SAAS,YAAa,IAAM,CAC1B,GAAG,uDAAyDD,GAAS,CAEnE,MAAMU,EAAe,KAAK,GAAG,EACvBE,EAAgB,KAAK,MAAMhB,EAAW,YAAY,EACxDM,EAAoB,sBAAsBP,CAAU,EAGpDE,EAAgBM,GAAqB,CACnCP,EACG,QAAQ,CACP,SAAUO,EAAiB,GAC3B,aAAAO,CACF,CAAC,EACA,KAAK,IAAM,CACVf,EAAW,yBAAyB,IAAI,MAAM,EAAE,CAAC,EAEjD,KAAK,oBAAoBJ,EAA2B,CAAC,EAGrD,OAAOqB,CAAa,EAAE,sBAAsB,CAAC,EAC7CZ,EAAK,CACP,CAAC,EACA,MAAOC,GAAU,CAChBD,EAAKC,CAAK,CACZ,CAAC,CACL,CAAC,CACH,CAAC,CACH,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["Left", "Right", "StaticDeviceModelDataSource", "DefaultLoggerPublisherService", "bleDeviceStubBuilder", "bleDeviceConnectionFactoryStubBuilder", "BleDeviceGattServerError", "BleTransportNotSupportedError", "NoAccessibleDeviceError", "OpeningConnectionError", "UnknownDeviceError", "RECONNECT_DEVICE_TIMEOUT", "WebBleTransport", "bleDeviceModelDataSource", "logger", "stubDevice", "transport", "discoverDevice", "onSuccess", "onError", "done", "error", "mockedRequestDevice", "discoveredDevice", "expectError", "message", "connectParams", "connect", "device", "connectedDevice", "onDisconnect", "value", "disconnectSpy"]
-}

package/lib/esm/src/internal/transport/ble/transport/__mocks__/WebBleTransport.js

@@ -1,2 +0,0 @@
-class t{listenToKnownDevices(){throw new Error("Method not implemented.")}isSupported=jest.fn();getIdentifier=jest.fn();connect=jest.fn();startDiscovering=jest.fn();stopDiscovering=jest.fn();disconnect=jest.fn()}function n(e={}){return{isSupported:jest.fn(),getIdentifier:jest.fn(),startDiscovering:jest.fn(),stopDiscovering:jest.fn(),connect:jest.fn(),disconnect:jest.fn(),listenToKnownDevices:jest.fn(),...e}}export{t as WebBleTransport,n as usbHidTransportMockBuilder};
-//# sourceMappingURL=WebBleTransport.js.map

package/lib/esm/src/internal/transport/ble/transport/__mocks__/WebBleTransport.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../../src/internal/transport/ble/transport/__mocks__/WebBleTransport.ts"],
-  "sourcesContent": ["import { type Observable } from \"rxjs\";\n\nimport { type Transport } from \"@api/transport/model/Transport\";\nimport { type InternalDiscoveredDevice } from \"@internal/transport/model/InternalDiscoveredDevice\";\n\nexport class WebBleTransport implements Transport {\n  listenToKnownDevices(): Observable<InternalDiscoveredDevice[]> {\n    throw new Error(\"Method not implemented.\");\n  }\n  isSupported = jest.fn();\n  getIdentifier = jest.fn();\n  connect = jest.fn();\n  startDiscovering = jest.fn();\n  stopDiscovering = jest.fn();\n\n  disconnect = jest.fn();\n}\n\nexport function usbHidTransportMockBuilder(\n  props: Partial<Transport> = {},\n): Transport {\n  return {\n    isSupported: jest.fn(),\n    getIdentifier: jest.fn(),\n    startDiscovering: jest.fn(),\n    stopDiscovering: jest.fn(),\n    connect: jest.fn(),\n    disconnect: jest.fn(),\n    listenToKnownDevices: jest.fn(),\n    ...props,\n  };\n}\n"],
-  "mappings": "AAKO,MAAMA,CAAqC,CAChD,sBAA+D,CAC7D,MAAM,IAAI,MAAM,yBAAyB,CAC3C,CACA,YAAc,KAAK,GAAG,EACtB,cAAgB,KAAK,GAAG,EACxB,QAAU,KAAK,GAAG,EAClB,iBAAmB,KAAK,GAAG,EAC3B,gBAAkB,KAAK,GAAG,EAE1B,WAAa,KAAK,GAAG,CACvB,CAEO,SAASC,EACdC,EAA4B,CAAC,EAClB,CACX,MAAO,CACL,YAAa,KAAK,GAAG,EACrB,cAAe,KAAK,GAAG,EACvB,iBAAkB,KAAK,GAAG,EAC1B,gBAAiB,KAAK,GAAG,EACzB,QAAS,KAAK,GAAG,EACjB,WAAY,KAAK,GAAG,EACpB,qBAAsB,KAAK,GAAG,EAC9B,GAAGA,CACL,CACF",
-  "names": ["WebBleTransport", "usbHidTransportMockBuilder", "props"]
-}

package/lib/esm/src/internal/transport/data/TransportDataSource.js

@@ -1,2 +0,0 @@
-import{BuiltinTransports as r}from"../../../api/transport/model/TransportIdentifier";import{WebBleTransport as s}from"../../transport/ble/transport/WebBleTransport";import{MockTransport as p}from"../../transport/mockserver/MockserverTransport";import{WebUsbHidTransport as a}from"../../transport/usb/transport/WebUsbHidTransport";class t{static transports={[r.USB]:a,[r.MOCK_SERVER]:p,[r.BLE]:s};static get(o){return t.transports[o]}}export{t as TransportDataSource};
-//# sourceMappingURL=TransportDataSource.js.map

package/lib/esm/src/internal/transport/data/TransportDataSource.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/transport/data/TransportDataSource.ts"],
-  "sourcesContent": ["import { type interfaces } from \"inversify\";\n\nimport { type Transport } from \"@api/transport/model/Transport\";\nimport { BuiltinTransports } from \"@api/transport/model/TransportIdentifier\";\nimport { WebBleTransport } from \"@internal/transport/ble/transport/WebBleTransport\";\nimport { MockTransport } from \"@internal/transport/mockserver/MockserverTransport\";\nimport { WebUsbHidTransport } from \"@internal/transport/usb/transport/WebUsbHidTransport\";\n\nexport class TransportDataSource {\n  private static transports: {\n    [transport in BuiltinTransports]: interfaces.Newable<Transport>;\n  } = {\n    [BuiltinTransports.USB]: WebUsbHidTransport,\n    [BuiltinTransports.MOCK_SERVER]: MockTransport,\n    [BuiltinTransports.BLE]: WebBleTransport,\n  };\n\n  static get(transport: BuiltinTransports): interfaces.Newable<Transport> {\n    return TransportDataSource.transports[transport];\n  }\n}\n"],
-  "mappings": "AAGA,OAAS,qBAAAA,MAAyB,2CAClC,OAAS,mBAAAC,MAAuB,oDAChC,OAAS,iBAAAC,MAAqB,qDAC9B,OAAS,sBAAAC,MAA0B,uDAE5B,MAAMC,CAAoB,CAC/B,OAAe,WAEX,CACF,CAACJ,EAAkB,GAAG,EAAGG,EACzB,CAACH,EAAkB,WAAW,EAAGE,EACjC,CAACF,EAAkB,GAAG,EAAGC,CAC3B,EAEA,OAAO,IAAII,EAA6D,CACtE,OAAOD,EAAoB,WAAWC,CAAS,CACjD,CACF",
-  "names": ["BuiltinTransports", "WebBleTransport", "MockTransport", "WebUsbHidTransport", "TransportDataSource", "transport"]
-}

package/lib/esm/src/internal/transport/mockserver/MockserverTransport.js

@@ -1,2 +0,0 @@
-var v=Object.defineProperty;var D=Object.getOwnPropertyDescriptor;var p=(i,e,r,t)=>{for(var o=t>1?void 0:t?D(e,r):e,n=i.length-1,d;n>=0;n--)(d=i[n])&&(o=(t?d(e,r,o):d(o))||o);return t&&o&&v(e,r,o),o},m=(i,e)=>(r,t)=>e(r,t,i);import{MockClient as f}from"@ledgerhq/device-transport-kit-mock-client";import{inject as l,injectable as h}from"inversify";import{Left as s,Right as a}from"purify-ts";import{from as g,mergeMap as b}from"rxjs";import{BuiltinTransports as I}from"../../../api/transport/model/TransportIdentifier";import{loggerTypes as C}from"../../logger-publisher/di/loggerTypes";import{transportDiTypes as y}from"../../transport/di/transportDiTypes";import{DisconnectError as u,NoAccessibleDeviceError as k,OpeningConnectionError as E}from"../../transport/model/Errors";let c=class{logger;mockClient;identifier=I.MOCK_SERVER;constructor(e,r){this.logger=e("MockTransport"),this.mockClient=new f(r.mockUrl)}isSupported(){return!0}getIdentifier(){return this.identifier}listenToKnownDevices(){return g([])}startDiscovering(){return this.logger.debug("startDiscovering"),g(this.mockClient.scan().then(e=>e.map(r=>({id:r.id,deviceModel:{id:r.device_type,productName:r.name,usbProductId:16,legacyUsbProductId:1,bootloaderUsbProductId:16,getBlockSize(){return 32},usbOnly:!0,memorySize:320*1024,masks:[823132160]},transport:this.identifier})))).pipe(b(e=>e))}stopDiscovering(){this.logger.debug("stopDiscovering")}async connect(e){this.logger.debug("connect");const r=e.deviceId;try{const t=await this.mockClient.connect(r),o={sendApdu:n=>this.sendApdu(r,e.deviceId,e.onDisconnect,n),deviceModel:{id:t.device.device_type,productName:t.device.name,usbProductId:16,legacyUsbProductId:1,bootloaderUsbProductId:16,getBlockSize(){return 32},usbOnly:!0,memorySize:320*1024,masks:[823132160]},id:e.deviceId,type:t.device.connectivity_type,transport:this.identifier};return a(o)}catch(t){return s(new E(t))}}async disconnect(e){this.logger.debug("disconnect");const r=e.connectedDevice.id;try{return await this.mockClient.disconnect(r)?a(void 0):s(new u(new Error(`Failed to disconnect ${r}`)))}catch(t){return s(new u(t))}}async sendApdu(e,r,t,o){this.logger.debug("send");try{const n=await this.mockClient.send(e,o);return a({statusCode:this.mockClient.fromHexString(n.response.substring(n.response.length-4,n.response.length)),data:this.mockClient.fromHexString(n.response.substring(0,n.response.length-4))})}catch(n){return t(r),s(new k(n))}}};c=p([h(),m(0,l(C.LoggerPublisherServiceFactory)),m(1,l(y.DmkConfig))],c);export{c as MockTransport};
-//# sourceMappingURL=MockserverTransport.js.map

package/lib/esm/src/internal/transport/mockserver/MockserverTransport.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/transport/mockserver/MockserverTransport.ts"],
-  "sourcesContent": ["/* istanbul ignore file */\n// pragma to ignore this file from coverage\nimport {\n  CommandResponse,\n  Device,\n  MockClient,\n  Session,\n} from \"@ledgerhq/device-transport-kit-mock-client\";\nimport { inject, injectable } from \"inversify\";\nimport { Either, Left, Right } from \"purify-ts\";\nimport { from, mergeMap, Observable } from \"rxjs\";\n\nimport { DeviceId } from \"@api/device/DeviceModel\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\nimport type { DmkConfig } from \"@api/DmkConfig\";\nimport { DmkError } from \"@api/Error\";\nimport { Transport } from \"@api/transport/model/Transport\";\nimport {\n  BuiltinTransports,\n  TransportIdentifier,\n} from \"@api/transport/model/TransportIdentifier\";\nimport { loggerTypes } from \"@internal/logger-publisher/di/loggerTypes\";\nimport { LoggerPublisherService } from \"@internal/logger-publisher/service/LoggerPublisherService\";\nimport { transportDiTypes } from \"@internal/transport/di/transportDiTypes\";\nimport { DisconnectHandler } from \"@internal/transport/model/DeviceConnection\";\nimport {\n  ConnectError,\n  DisconnectError,\n  NoAccessibleDeviceError,\n  OpeningConnectionError,\n} from \"@internal/transport/model/Errors\";\nimport { InternalConnectedDevice } from \"@internal/transport/model/InternalConnectedDevice\";\nimport { InternalDiscoveredDevice } from \"@internal/transport/model/InternalDiscoveredDevice\";\n\n@injectable()\nexport class MockTransport implements Transport {\n  private logger: LoggerPublisherService;\n  private mockClient: MockClient;\n  private readonly identifier: TransportIdentifier =\n    BuiltinTransports.MOCK_SERVER;\n\n  constructor(\n    @inject(loggerTypes.LoggerPublisherServiceFactory)\n    loggerServiceFactory: (tag: string) => LoggerPublisherService,\n    @inject(transportDiTypes.DmkConfig) config: DmkConfig,\n  ) {\n    this.logger = loggerServiceFactory(\"MockTransport\");\n    this.mockClient = new MockClient(config.mockUrl);\n  }\n\n  isSupported(): boolean {\n    return true;\n  }\n\n  getIdentifier(): TransportIdentifier {\n    return this.identifier;\n  }\n\n  listenToKnownDevices(): Observable<InternalDiscoveredDevice[]> {\n    return from([]);\n  }\n\n  startDiscovering(): Observable<InternalDiscoveredDevice> {\n    this.logger.debug(\"startDiscovering\");\n    return from(\n      this.mockClient.scan().then((devices: Device[]) => {\n        return devices.map((device: Device) => {\n          return {\n            id: device.id,\n            deviceModel: {\n              id: device.device_type,\n              productName: device.name,\n              usbProductId: 0x10,\n              legacyUsbProductId: 0x0001,\n              bootloaderUsbProductId: 0x10,\n              getBlockSize() {\n                return 32;\n              },\n              usbOnly: true,\n              memorySize: 320 * 1024,\n              masks: [0x31100000],\n            },\n            transport: this.identifier,\n          } as InternalDiscoveredDevice;\n        });\n      }),\n    ).pipe(mergeMap((device) => device));\n  }\n\n  stopDiscovering(): void {\n    //DO NOTHING HERE\n    this.logger.debug(\"stopDiscovering\");\n  }\n\n  async connect(params: {\n    deviceId: DeviceId;\n    onDisconnect: DisconnectHandler;\n  }): Promise<Either<ConnectError, InternalConnectedDevice>> {\n    this.logger.debug(\"connect\");\n    const sessionId: string = params.deviceId;\n    try {\n      const session: Session = await this.mockClient.connect(sessionId);\n      const connectedDevice = {\n        sendApdu: (apdu) => {\n          return this.sendApdu(\n            sessionId,\n            params.deviceId,\n            params.onDisconnect,\n            apdu,\n          );\n        },\n        deviceModel: {\n          id: session.device.device_type,\n          productName: session.device.name,\n          usbProductId: 0x10,\n          legacyUsbProductId: 0x0001,\n          bootloaderUsbProductId: 0x10,\n          getBlockSize() {\n            return 32;\n          },\n          usbOnly: true,\n          memorySize: 320 * 1024,\n          masks: [0x31100000],\n        },\n        id: params.deviceId,\n        type: session.device.connectivity_type,\n        transport: this.identifier,\n      } as InternalConnectedDevice;\n      return Right(connectedDevice);\n    } catch (error) {\n      return Left(new OpeningConnectionError(error as Error));\n    }\n  }\n\n  async disconnect(params: {\n    connectedDevice: InternalConnectedDevice;\n  }): Promise<Either<DmkError, void>> {\n    this.logger.debug(\"disconnect\");\n    const sessionId: string = params.connectedDevice.id;\n    try {\n      const success: boolean = await this.mockClient.disconnect(sessionId);\n      if (!success) {\n        return Left(\n          new DisconnectError(new Error(`Failed to disconnect ${sessionId}`)),\n        );\n      }\n      return Right(void 0);\n    } catch (error) {\n      return Left(new DisconnectError(error as Error));\n    }\n  }\n\n  async sendApdu(\n    sessionId: string,\n    deviceId: DeviceId,\n    onDisconnect: DisconnectHandler,\n    apdu: Uint8Array,\n  ): Promise<Either<DmkError, ApduResponse>> {\n    this.logger.debug(\"send\");\n    try {\n      const response: CommandResponse = await this.mockClient.send(\n        sessionId,\n        apdu,\n      );\n      return Right({\n        statusCode: this.mockClient.fromHexString(\n          response.response.substring(\n            response.response.length - 4,\n            response.response.length,\n          ),\n        ),\n        data: this.mockClient.fromHexString(\n          response.response.substring(0, response.response.length - 4),\n        ),\n      } as ApduResponse);\n    } catch (error) {\n      onDisconnect(deviceId);\n      return Left(new NoAccessibleDeviceError(error as Error));\n    }\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["MockClient", "inject", "injectable", "Left", "Right", "from", "mergeMap", "BuiltinTransports", "loggerTypes", "transportDiTypes", "DisconnectError", "NoAccessibleDeviceError", "OpeningConnectionError", "MockTransport", "BuiltinTransports", "loggerServiceFactory", "config", "MockClient", "from", "devices", "device", "mergeMap", "params", "sessionId", "session", "connectedDevice", "apdu", "Right", "error", "Left", "OpeningConnectionError", "DisconnectError", "deviceId", "onDisconnect", "response", "NoAccessibleDeviceError", "__decorateClass", "injectable", "__decorateParam", "inject", "loggerTypes", "transportDiTypes"]
-}

package/lib/esm/src/internal/transport/model/Errors.js

@@ -1,2 +0,0 @@
-class n{_tag="GeneralDmkError";originalError;constructor(e){e instanceof Error?this.originalError=e:e!==void 0&&(this.originalError=new Error(String(e)))}}class t extends n{constructor(r){super(r);this.err=r}_tag="DeviceNotRecognizedError"}class s extends n{constructor(r){super(r);this.err=r}_tag="NoAccessibleDeviceError"}class c extends n{constructor(r){super(r);this.err=r}_tag="ConnectionOpeningError"}class d extends n{constructor(r){super(r);this.err=r}_tag="UnknownDeviceError"}class a extends n{constructor(r){super(r);this.err=r}_tag="TransportNotSupportedError"}class i extends n{constructor(r){super(r);this.err=r}_tag="BleTransportNotSupportedError"}class p extends n{constructor(r){super(r);this.err=r}_tag="UsbHidTransportNotSupportedError"}class l extends n{constructor(r){super(r);this.err=r}_tag="SendApduConcurrencyError"}class u extends n{constructor(r){super(r);this.err=r}_tag="DisconnectError"}class E extends n{constructor(r){super(r);this.err=r}_tag="ReconnectionFailedError"}class y extends n{constructor(r){super(r);this.err=r}_tag="HidSendReportError"}class v extends n{constructor(r){super(r);this.err=r}_tag="DeviceNotInitializedError"}class x extends n{constructor(r){super(r);this.err=r}_tag="BleDeviceGattServerError"}class g extends n{constructor(r){super(r);this.err=r}_tag="DeviceAlreadyDiscoveredError"}export{x as BleDeviceGattServerError,i as BleTransportNotSupportedError,g as DeviceAlreadyConnectedError,v as DeviceNotInitializedError,t as DeviceNotRecognizedError,u as DisconnectError,y as HidSendReportError,s as NoAccessibleDeviceError,c as OpeningConnectionError,E as ReconnectionFailedError,l as SendApduConcurrencyError,a as TransportNotSupportedError,d as UnknownDeviceError,p as UsbHidTransportNotSupportedError};
-//# sourceMappingURL=Errors.js.map

package/lib/esm/src/internal/transport/model/Errors.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/transport/model/Errors.ts"],
-  "sourcesContent": ["import { type DmkError } from \"@api/Error\";\n\nexport type PromptDeviceAccessError =\n  | UsbHidTransportNotSupportedError\n  | BleTransportNotSupportedError\n  | NoAccessibleDeviceError;\n\nexport type ConnectError =\n  | UnknownDeviceError\n  | OpeningConnectionError\n  | DeviceAlreadyConnectedError;\n\nclass GeneralDmkError implements DmkError {\n  _tag = \"GeneralDmkError\";\n  originalError?: unknown;\n  constructor(err?: unknown) {\n    if (err instanceof Error) {\n      this.originalError = err;\n    } else if (err !== undefined) {\n      this.originalError = new Error(String(err));\n    }\n  }\n}\n\nexport class DeviceNotRecognizedError extends GeneralDmkError {\n  override readonly _tag = \"DeviceNotRecognizedError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class NoAccessibleDeviceError extends GeneralDmkError {\n  override readonly _tag = \"NoAccessibleDeviceError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class OpeningConnectionError extends GeneralDmkError {\n  override readonly _tag = \"ConnectionOpeningError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class UnknownDeviceError extends GeneralDmkError {\n  override readonly _tag = \"UnknownDeviceError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class TransportNotSupportedError extends GeneralDmkError {\n  override readonly _tag = \"TransportNotSupportedError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class BleTransportNotSupportedError extends GeneralDmkError {\n  override readonly _tag = \"BleTransportNotSupportedError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class UsbHidTransportNotSupportedError extends GeneralDmkError {\n  override readonly _tag = \"UsbHidTransportNotSupportedError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class SendApduConcurrencyError extends GeneralDmkError {\n  override readonly _tag = \"SendApduConcurrencyError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class DisconnectError extends GeneralDmkError {\n  override readonly _tag = \"DisconnectError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class ReconnectionFailedError extends GeneralDmkError {\n  override readonly _tag = \"ReconnectionFailedError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class HidSendReportError extends GeneralDmkError {\n  override readonly _tag = \"HidSendReportError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class DeviceNotInitializedError extends GeneralDmkError {\n  override readonly _tag = \"DeviceNotInitializedError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class BleDeviceGattServerError extends GeneralDmkError {\n  override readonly _tag = \"BleDeviceGattServerError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class DeviceAlreadyConnectedError extends GeneralDmkError {\n  override readonly _tag = \"DeviceAlreadyDiscoveredError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n"],
-  "mappings": "AAYA,MAAMA,CAAoC,CACxC,KAAO,kBACP,cACA,YAAYC,EAAe,CACrBA,aAAe,MACjB,KAAK,cAAgBA,EACZA,IAAQ,SACjB,KAAK,cAAgB,IAAI,MAAM,OAAOA,CAAG,CAAC,EAE9C,CACF,CAEO,MAAMC,UAAiCF,CAAgB,CAE5D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,0BAI3B,CAEO,MAAME,UAAgCH,CAAgB,CAE3D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,yBAI3B,CAEO,MAAMG,UAA+BJ,CAAgB,CAE1D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,wBAI3B,CAEO,MAAMI,UAA2BL,CAAgB,CAEtD,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,oBAI3B,CAEO,MAAMK,UAAmCN,CAAgB,CAE9D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMM,UAAsCP,CAAgB,CAEjE,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,+BAI3B,CAEO,MAAMO,UAAyCR,CAAgB,CAEpE,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,kCAI3B,CAEO,MAAMQ,UAAiCT,CAAgB,CAE5D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,0BAI3B,CAEO,MAAMS,UAAwBV,CAAgB,CAEnD,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,iBAI3B,CAEO,MAAMU,UAAgCX,CAAgB,CAE3D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,yBAI3B,CAEO,MAAMW,UAA2BZ,CAAgB,CAEtD,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,oBAI3B,CAEO,MAAMY,UAAkCb,CAAgB,CAE7D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,2BAI3B,CAEO,MAAMa,UAAiCd,CAAgB,CAE5D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,0BAI3B,CAEO,MAAMc,UAAoCf,CAAgB,CAE/D,YAAqBC,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,8BAI3B",
-  "names": ["GeneralDmkError", "err", "DeviceNotRecognizedError", "NoAccessibleDeviceError", "OpeningConnectionError", "UnknownDeviceError", "TransportNotSupportedError", "BleTransportNotSupportedError", "UsbHidTransportNotSupportedError", "SendApduConcurrencyError", "DisconnectError", "ReconnectionFailedError", "HidSendReportError", "DeviceNotInitializedError", "BleDeviceGattServerError", "DeviceAlreadyConnectedError"]
-}

package/lib/esm/src/internal/transport/model/InternalConnectedDevice.js

@@ -1,2 +0,0 @@
-class p{id;deviceModel;sendApdu;type;transport;constructor({id:e,deviceModel:n,type:t,transport:o,sendApdu:r}){this.id=e,this.deviceModel=n,this.sendApdu=r,this.type=t,this.transport=o}}export{p as InternalConnectedDevice};
-//# sourceMappingURL=InternalConnectedDevice.js.map

package/lib/esm/src/internal/transport/model/InternalConnectedDevice.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/transport/model/InternalConnectedDevice.ts"],
-  "sourcesContent": ["import { type DeviceId } from \"@api/device/DeviceModel\";\nimport { type ConnectionType } from \"@api/discovery/ConnectionType\";\nimport { type TransportIdentifier } from \"@api/transport/model/TransportIdentifier\";\nimport { type InternalDeviceModel } from \"@internal/device-model/model/DeviceModel\";\nimport { type SendApduFnType } from \"@internal/transport/model/DeviceConnection\";\n\n/**\n * The internal connected device.\n */\nexport type ConnectedDeviceConstructorArgs = {\n  id: DeviceId;\n  deviceModel: InternalDeviceModel;\n  type: ConnectionType;\n  transport: TransportIdentifier;\n  sendApdu: SendApduFnType;\n};\n\nexport class InternalConnectedDevice {\n  public readonly id: DeviceId;\n  public readonly deviceModel: InternalDeviceModel;\n  public readonly sendApdu: SendApduFnType;\n  public readonly type: ConnectionType;\n  public readonly transport: TransportIdentifier;\n\n  constructor({\n    id,\n    deviceModel,\n    type,\n    transport,\n    sendApdu,\n  }: ConnectedDeviceConstructorArgs) {\n    this.id = id;\n    this.deviceModel = deviceModel;\n    this.sendApdu = sendApdu;\n    this.type = type;\n    this.transport = transport;\n  }\n}\n"],
-  "mappings": "AAiBO,MAAMA,CAAwB,CACnB,GACA,YACA,SACA,KACA,UAEhB,YAAY,CACV,GAAAC,EACA,YAAAC,EACA,KAAAC,EACA,UAAAC,EACA,SAAAC,CACF,EAAmC,CACjC,KAAK,GAAKJ,EACV,KAAK,YAAcC,EACnB,KAAK,SAAWG,EAChB,KAAK,KAAOF,EACZ,KAAK,UAAYC,CACnB,CACF",
-  "names": ["InternalConnectedDevice", "id", "deviceModel", "type", "transport", "sendApdu"]
-}

package/lib/esm/src/internal/transport/model/InternalConnectedDevice.stub.js

@@ -1,2 +0,0 @@
-import{Right as r}from"purify-ts";import{defaultApduResponseStubBuilder as n}from"../../../api/device-session/ApduResponse.stub";import{deviceModelStubBuilder as o}from"../../device-model/model/DeviceModel.stub";import{InternalConnectedDevice as i}from"../../transport/model/InternalConnectedDevice";function p(e={}){const t=o();return new i({deviceModel:t,id:"42",type:"MOCK",transport:"USB",sendApdu:jest.fn(async()=>Promise.resolve(r(n()))),...e})}export{p as connectedDeviceStubBuilder};
-//# sourceMappingURL=InternalConnectedDevice.stub.js.map

package/lib/esm/src/internal/transport/model/InternalConnectedDevice.stub.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/transport/model/InternalConnectedDevice.stub.ts"],
-  "sourcesContent": ["import { Right } from \"purify-ts\";\n\nimport { defaultApduResponseStubBuilder } from \"@api/device-session/ApduResponse.stub\";\nimport { deviceModelStubBuilder } from \"@internal/device-model/model/DeviceModel.stub\";\nimport {\n  type ConnectedDeviceConstructorArgs,\n  InternalConnectedDevice,\n} from \"@internal/transport/model/InternalConnectedDevice\";\n\nexport function connectedDeviceStubBuilder(\n  props: Partial<ConnectedDeviceConstructorArgs> = {},\n): InternalConnectedDevice {\n  const deviceModel = deviceModelStubBuilder();\n  return new InternalConnectedDevice({\n    deviceModel,\n    id: \"42\",\n    type: \"MOCK\",\n    transport: \"USB\",\n    sendApdu: jest.fn(async () =>\n      Promise.resolve(Right(defaultApduResponseStubBuilder())),\n    ),\n    ...props,\n  });\n}\n"],
-  "mappings": "AAAA,OAAS,SAAAA,MAAa,YAEtB,OAAS,kCAAAC,MAAsC,wCAC/C,OAAS,0BAAAC,MAA8B,gDACvC,OAEE,2BAAAC,MACK,oDAEA,SAASC,EACdC,EAAiD,CAAC,EACzB,CACzB,MAAMC,EAAcJ,EAAuB,EAC3C,OAAO,IAAIC,EAAwB,CACjC,YAAAG,EACA,GAAI,KACJ,KAAM,OACN,UAAW,MACX,SAAU,KAAK,GAAG,SAChB,QAAQ,QAAQN,EAAMC,EAA+B,CAAC,CAAC,CACzD,EACA,GAAGI,CACL,CAAC,CACH",
-  "names": ["Right", "defaultApduResponseStubBuilder", "deviceModelStubBuilder", "InternalConnectedDevice", "connectedDeviceStubBuilder", "props", "deviceModel"]
-}

package/lib/esm/src/internal/transport/model/InternalConnectedDevice.test.js

@@ -1,2 +0,0 @@
-import{Right as t}from"purify-ts";import{defaultApduResponseStubBuilder as r}from"../../../api/device-session/ApduResponse.stub";import{deviceModelStubBuilder as o}from"../../device-model/model/DeviceModel.stub";import{InternalConnectedDevice as c}from"../../transport/model/InternalConnectedDevice";import{connectedDeviceStubBuilder as n}from"../../transport/model/InternalConnectedDevice.stub";describe("InternalConnectedDevice",()=>{let e;beforeEach(()=>{e=n()}),it("should create an instance",()=>{expect(e).toBeDefined(),expect(e).toBeInstanceOf(c)}),it("should return the correct id",()=>{expect(e.id).toEqual("42")}),it("should return the correct device model",()=>{expect(JSON.stringify(e.deviceModel)).toEqual(JSON.stringify(o()))}),it("should return the correct type",()=>{expect(e.type).toEqual("MOCK")}),it("should return the correct send apdu response",()=>{expect(e.sendApdu(new Uint8Array)).resolves.toMatchObject(t(r()))})});
-//# sourceMappingURL=InternalConnectedDevice.test.js.map

package/lib/esm/src/internal/transport/model/InternalConnectedDevice.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/transport/model/InternalConnectedDevice.test.ts"],
-  "sourcesContent": ["import { Right } from \"purify-ts\";\n\nimport { defaultApduResponseStubBuilder } from \"@api/device-session/ApduResponse.stub\";\nimport { deviceModelStubBuilder } from \"@internal/device-model/model/DeviceModel.stub\";\nimport { InternalConnectedDevice } from \"@internal/transport/model/InternalConnectedDevice\";\nimport { connectedDeviceStubBuilder } from \"@internal/transport/model/InternalConnectedDevice.stub\";\n\ndescribe(\"InternalConnectedDevice\", () => {\n  let connectedDevice: InternalConnectedDevice;\n\n  beforeEach(() => {\n    connectedDevice = connectedDeviceStubBuilder();\n  });\n\n  it(\"should create an instance\", () => {\n    expect(connectedDevice).toBeDefined();\n    expect(connectedDevice).toBeInstanceOf(InternalConnectedDevice);\n  });\n\n  it(\"should return the correct id\", () => {\n    expect(connectedDevice.id).toEqual(\"42\");\n  });\n\n  it(\"should return the correct device model\", () => {\n    expect(JSON.stringify(connectedDevice.deviceModel)).toEqual(\n      JSON.stringify(deviceModelStubBuilder()),\n    );\n  });\n\n  it(\"should return the correct type\", () => {\n    expect(connectedDevice.type).toEqual(\"MOCK\");\n  });\n\n  it(\"should return the correct send apdu response\", () => {\n    expect(connectedDevice.sendApdu(new Uint8Array())).resolves.toMatchObject(\n      Right(defaultApduResponseStubBuilder()),\n    );\n  });\n});\n"],
-  "mappings": "AAAA,OAAS,SAAAA,MAAa,YAEtB,OAAS,kCAAAC,MAAsC,wCAC/C,OAAS,0BAAAC,MAA8B,gDACvC,OAAS,2BAAAC,MAA+B,oDACxC,OAAS,8BAAAC,MAAkC,yDAE3C,SAAS,0BAA2B,IAAM,CACxC,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAkBD,EAA2B,CAC/C,CAAC,EAED,GAAG,4BAA6B,IAAM,CACpC,OAAOC,CAAe,EAAE,YAAY,EACpC,OAAOA,CAAe,EAAE,eAAeF,CAAuB,CAChE,CAAC,EAED,GAAG,+BAAgC,IAAM,CACvC,OAAOE,EAAgB,EAAE,EAAE,QAAQ,IAAI,CACzC,CAAC,EAED,GAAG,yCAA0C,IAAM,CACjD,OAAO,KAAK,UAAUA,EAAgB,WAAW,CAAC,EAAE,QAClD,KAAK,UAAUH,EAAuB,CAAC,CACzC,CACF,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzC,OAAOG,EAAgB,IAAI,EAAE,QAAQ,MAAM,CAC7C,CAAC,EAED,GAAG,+CAAgD,IAAM,CACvD,OAAOA,EAAgB,SAAS,IAAI,UAAY,CAAC,EAAE,SAAS,cAC1DL,EAAMC,EAA+B,CAAC,CACxC,CACF,CAAC,CACH,CAAC",
-  "names": ["Right", "defaultApduResponseStubBuilder", "deviceModelStubBuilder", "InternalConnectedDevice", "connectedDeviceStubBuilder", "connectedDevice"]
-}

package/lib/esm/src/internal/transport/model/InternalDiscoveredDevice.js

@@ -1 +0,0 @@
-//# sourceMappingURL=InternalDiscoveredDevice.js.map

package/lib/esm/src/internal/transport/usb/data/UsbHidConfig.js

@@ -1,2 +0,0 @@
-const E=11415,o=64,t=6e3;export{o as FRAME_SIZE,E as LEDGER_VENDOR_ID,t as RECONNECT_DEVICE_TIMEOUT};
-//# sourceMappingURL=UsbHidConfig.js.map

package/lib/esm/src/internal/transport/usb/data/UsbHidConfig.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/data/UsbHidConfig.ts"],
-  "sourcesContent": ["// [SHOULD] Move it to device-model module\nexport const LEDGER_VENDOR_ID = 0x2c97;\nexport const FRAME_SIZE = 64;\nexport const RECONNECT_DEVICE_TIMEOUT = 6000; // in some cases, when opening/closing an app, it takes up to 6s between the HID \"disconnect\" and \"connect\" events\n"],
-  "mappings": "AACO,MAAMA,EAAmB,MACnBC,EAAa,GACbC,EAA2B",
-  "names": ["LEDGER_VENDOR_ID", "FRAME_SIZE", "RECONNECT_DEVICE_TIMEOUT"]
-}

package/lib/esm/src/internal/transport/usb/di/usbDiTypes.js

@@ -1,2 +0,0 @@
-const o={UsbHidDeviceConnectionFactory:Symbol.for("UsbHidDeviceConnectionFactory")};export{o as usbDiTypes};
-//# sourceMappingURL=usbDiTypes.js.map

package/lib/esm/src/internal/transport/usb/di/usbDiTypes.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/di/usbDiTypes.ts"],
-  "sourcesContent": ["export const usbDiTypes = {\n  UsbHidDeviceConnectionFactory: Symbol.for(\"UsbHidDeviceConnectionFactory\"),\n};\n"],
-  "mappings": "AAAO,MAAMA,EAAa,CACxB,8BAA+B,OAAO,IAAI,+BAA+B,CAC3E",
-  "names": ["usbDiTypes"]
-}

package/lib/esm/src/internal/transport/usb/di/usbModule.js

@@ -1,2 +0,0 @@
-import{ContainerModule as t}from"inversify";import{UsbHidDeviceConnectionFactory as e}from"../../../transport/usb/service/UsbHidDeviceConnectionFactory";import{usbDiTypes as i}from"./usbDiTypes";const d=({stub:o=!1}={})=>new t((r,n,s,a)=>{r(i.UsbHidDeviceConnectionFactory).to(e)});export{d as usbModuleFactory};
-//# sourceMappingURL=usbModule.js.map

package/lib/esm/src/internal/transport/usb/di/usbModule.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/di/usbModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { UsbHidDeviceConnectionFactory } from \"@internal/transport/usb/service/UsbHidDeviceConnectionFactory\";\n\nimport { usbDiTypes } from \"./usbDiTypes\";\n\ntype FactoryProps = {\n  stub: boolean;\n};\n\nexport const usbModuleFactory = ({\n  stub = false,\n}: Partial<FactoryProps> = {}) =>\n  new ContainerModule((bind, _unbind, _isBound, _rebind) => {\n    // UsbHidDeviceConnectionFactory\n    bind(usbDiTypes.UsbHidDeviceConnectionFactory).to(\n      UsbHidDeviceConnectionFactory,\n    );\n\n    if (stub) {\n      // Add stubs here\n    }\n  });\n"],
-  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,iCAAAC,MAAqC,gEAE9C,OAAS,cAAAC,MAAkB,eAMpB,MAAMC,EAAmB,CAAC,CAC/B,KAAAC,EAAO,EACT,EAA2B,CAAC,IAC1B,IAAIJ,EAAgB,CAACK,EAAMC,EAASC,EAAUC,IAAY,CAExDH,EAAKH,EAAW,6BAA6B,EAAE,GAC7CD,CACF,CAKF,CAAC",
-  "names": ["ContainerModule", "UsbHidDeviceConnectionFactory", "usbDiTypes", "usbModuleFactory", "stub", "bind", "_unbind", "_isBound", "_rebind"]
-}

package/lib/esm/src/internal/transport/usb/di/usbModule.test.js

@@ -1,2 +0,0 @@
-import{Container as r}from"inversify";import{deviceModelModuleFactory as t}from"../../../device-model/di/deviceModelModule";import{deviceSessionModuleFactory as d}from"../../../device-session/di/deviceSessionModule";import{loggerModuleFactory as l}from"../../../logger-publisher/di/loggerModule";import{usbModuleFactory as u}from"./usbModule";describe("usbModuleFactory",()=>{let e,o;beforeEach(()=>{o=u({stub:!1}),e=new r,e.load(l()),e.load(o,t({stub:!1}),d())}),it("should return the usb module",()=>{expect(o).toBeDefined()})});
-//# sourceMappingURL=usbModule.test.js.map

package/lib/esm/src/internal/transport/usb/di/usbModule.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/di/usbModule.test.ts"],
-  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { deviceModelModuleFactory } from \"@internal/device-model/di/deviceModelModule\";\nimport { deviceSessionModuleFactory } from \"@internal/device-session/di/deviceSessionModule\";\nimport { loggerModuleFactory } from \"@internal/logger-publisher/di/loggerModule\";\n\nimport { usbModuleFactory } from \"./usbModule\";\n\ndescribe(\"usbModuleFactory\", () => {\n  let container: Container;\n  let mod: ReturnType<typeof usbModuleFactory>;\n  beforeEach(() => {\n    mod = usbModuleFactory({ stub: false });\n    container = new Container();\n    container.load(loggerModuleFactory());\n    container.load(\n      mod,\n      deviceModelModuleFactory({ stub: false }),\n      deviceSessionModuleFactory(),\n    );\n  });\n\n  it(\"should return the usb module\", () => {\n    expect(mod).toBeDefined();\n  });\n});\n"],
-  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,4BAAAC,MAAgC,8CACzC,OAAS,8BAAAC,MAAkC,kDAC3C,OAAS,uBAAAC,MAA2B,6CAEpC,OAAS,oBAAAC,MAAwB,cAEjC,SAAS,mBAAoB,IAAM,CACjC,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMF,EAAiB,CAAE,KAAM,EAAM,CAAC,EACtCC,EAAY,IAAIL,EAChBK,EAAU,KAAKF,EAAoB,CAAC,EACpCE,EAAU,KACRC,EACAL,EAAyB,CAAE,KAAM,EAAM,CAAC,EACxCC,EAA2B,CAC7B,CACF,CAAC,EAED,GAAG,+BAAgC,IAAM,CACvC,OAAOI,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC",
-  "names": ["Container", "deviceModelModuleFactory", "deviceSessionModuleFactory", "loggerModuleFactory", "usbModuleFactory", "container", "mod"]
-}

package/lib/esm/src/internal/transport/usb/model/HIDDevice.stub.js

@@ -1,2 +0,0 @@
-const e=jest.fn().mockResolvedValue(void 0),n=(t={})=>({opened:!1,productId:16401,vendorId:11415,productName:"Ledger Nano X",collections:[],open:jest.fn().mockResolvedValue(void 0),oninputreport:e,close:jest.fn().mockResolvedValue(void 0),sendReport:jest.fn().mockResolvedValue(e()),sendFeatureReport:jest.fn(),forget:jest.fn(),receiveFeatureReport:jest.fn(),addEventListener:jest.fn(),removeEventListener:jest.fn(),dispatchEvent:jest.fn(),...t});export{n as hidDeviceStubBuilder};
-//# sourceMappingURL=HIDDevice.stub.js.map

package/lib/esm/src/internal/transport/usb/model/HIDDevice.stub.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/model/HIDDevice.stub.ts"],
-  "sourcesContent": ["const oninputreport = jest.fn().mockResolvedValue(void 0);\n\nexport const hidDeviceStubBuilder = (\n  props: Partial<HIDDevice> = {},\n): HIDDevice => ({\n  opened: false,\n  productId: 0x4011,\n  vendorId: 0x2c97,\n  productName: \"Ledger Nano X\",\n  collections: [],\n  open: jest.fn().mockResolvedValue(undefined),\n  oninputreport,\n  close: jest.fn().mockResolvedValue(undefined),\n  sendReport: jest.fn().mockResolvedValue(oninputreport()),\n  sendFeatureReport: jest.fn(),\n  forget: jest.fn(),\n  receiveFeatureReport: jest.fn(),\n  addEventListener: jest.fn(),\n  removeEventListener: jest.fn(),\n  dispatchEvent: jest.fn(),\n  ...props,\n});\n"],
-  "mappings": "AAAA,MAAMA,EAAgB,KAAK,GAAG,EAAE,kBAAkB,MAAM,EAE3CC,EAAuB,CAClCC,EAA4B,CAAC,KACd,CACf,OAAQ,GACR,UAAW,MACX,SAAU,MACV,YAAa,gBACb,YAAa,CAAC,EACd,KAAM,KAAK,GAAG,EAAE,kBAAkB,MAAS,EAC3C,cAAAF,EACA,MAAO,KAAK,GAAG,EAAE,kBAAkB,MAAS,EAC5C,WAAY,KAAK,GAAG,EAAE,kBAAkBA,EAAc,CAAC,EACvD,kBAAmB,KAAK,GAAG,EAC3B,OAAQ,KAAK,GAAG,EAChB,qBAAsB,KAAK,GAAG,EAC9B,iBAAkB,KAAK,GAAG,EAC1B,oBAAqB,KAAK,GAAG,EAC7B,cAAe,KAAK,GAAG,EACvB,GAAGE,CACL",
-  "names": ["oninputreport", "hidDeviceStubBuilder", "props"]
-}

package/lib/esm/src/internal/transport/usb/service/UsbHidDeviceConnectionFactory.js

@@ -1,2 +0,0 @@
-var v=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var p=(t,r,o,e)=>{for(var i=e>1?void 0:e?f(r,o):r,n=t.length-1,a;n>=0;n--)(a=t[n])&&(i=(e?a(r,o,i):a(i))||i);return e&&i&&v(r,o,i),i},d=(t,r)=>(o,e)=>r(o,e,t);import{inject as m,injectable as s}from"inversify";import{Maybe as S}from"purify-ts";import{CHANNEL_LENGTH as g}from"../../../device-session/data/FramerConst";import{deviceSessionTypes as u}from"../../../device-session/di/deviceSessionTypes";import{FramerUtils as l}from"../../../device-session/utils/FramerUtils";import{loggerTypes as A}from"../../../logger-publisher/di/loggerTypes";import{FRAME_SIZE as y}from"../../../transport/usb/data/UsbHidConfig";import{UsbHidDeviceConnection as h}from"../../../transport/usb/transport/UsbHidDeviceConnection";let c=class{constructor(r,o,e){this.apduSenderFactory=r;this.apduReceiverFactory=o;this.loggerFactory=e}randomChannel=Math.floor(Math.random()*65535);create(r,o,e=S.of(l.numberToByteArray(this.randomChannel,g))){return new h({device:r,deviceId:o.deviceId,apduSender:this.apduSenderFactory({frameSize:y,channel:e,padding:!0}),apduReceiver:this.apduReceiverFactory({channel:e}),onConnectionTerminated:o.onConnectionTerminated},this.loggerFactory)}};c=p([s(),d(0,m(u.ApduSenderServiceFactory)),d(1,m(u.ApduReceiverServiceFactory)),d(2,m(A.LoggerPublisherServiceFactory))],c);export{c as UsbHidDeviceConnectionFactory};
-//# sourceMappingURL=UsbHidDeviceConnectionFactory.js.map

package/lib/esm/src/internal/transport/usb/service/UsbHidDeviceConnectionFactory.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/service/UsbHidDeviceConnectionFactory.ts"],
-  "sourcesContent": ["import { inject, injectable } from \"inversify\";\nimport { Maybe } from \"purify-ts\";\n\nimport { DeviceId } from \"@api/types\";\nimport { CHANNEL_LENGTH } from \"@internal/device-session/data/FramerConst\";\nimport { deviceSessionTypes } from \"@internal/device-session/di/deviceSessionTypes\";\nimport { ApduReceiverService } from \"@internal/device-session/service/ApduReceiverService\";\nimport { ApduSenderService } from \"@internal/device-session/service/ApduSenderService\";\nimport { DefaultApduReceiverConstructorArgs } from \"@internal/device-session/service/DefaultApduReceiverService\";\nimport { DefaultApduSenderServiceConstructorArgs } from \"@internal/device-session/service/DefaultApduSenderService\";\nimport { FramerUtils } from \"@internal/device-session/utils/FramerUtils\";\nimport { loggerTypes } from \"@internal/logger-publisher/di/loggerTypes\";\nimport { LoggerPublisherService } from \"@internal/logger-publisher/service/LoggerPublisherService\";\nimport { FRAME_SIZE } from \"@internal/transport/usb/data/UsbHidConfig\";\nimport { UsbHidDeviceConnection } from \"@internal/transport/usb/transport/UsbHidDeviceConnection\";\n\n@injectable()\nexport class UsbHidDeviceConnectionFactory {\n  randomChannel = Math.floor(Math.random() * 0xffff);\n\n  constructor(\n    @inject(deviceSessionTypes.ApduSenderServiceFactory)\n    private readonly apduSenderFactory: (\n      args: DefaultApduSenderServiceConstructorArgs,\n    ) => ApduSenderService,\n    @inject(deviceSessionTypes.ApduReceiverServiceFactory)\n    private readonly apduReceiverFactory: (\n      args: DefaultApduReceiverConstructorArgs,\n    ) => ApduReceiverService,\n    @inject(loggerTypes.LoggerPublisherServiceFactory)\n    private readonly loggerFactory: (name: string) => LoggerPublisherService,\n  ) {}\n\n  public create(\n    device: HIDDevice,\n    params: { onConnectionTerminated: () => void; deviceId: DeviceId },\n    channel = Maybe.of(\n      FramerUtils.numberToByteArray(this.randomChannel, CHANNEL_LENGTH),\n    ),\n  ): UsbHidDeviceConnection {\n    return new UsbHidDeviceConnection(\n      {\n        device,\n        deviceId: params.deviceId,\n        apduSender: this.apduSenderFactory({\n          frameSize: FRAME_SIZE,\n          channel,\n          padding: true,\n        }),\n        apduReceiver: this.apduReceiverFactory({ channel }),\n        onConnectionTerminated: params.onConnectionTerminated,\n      },\n      this.loggerFactory,\n    );\n  }\n}\n"],
-  "mappings": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YACnC,OAAS,SAAAC,MAAa,YAGtB,OAAS,kBAAAC,MAAsB,4CAC/B,OAAS,sBAAAC,MAA0B,iDAKnC,OAAS,eAAAC,MAAmB,6CAC5B,OAAS,eAAAC,MAAmB,4CAE5B,OAAS,cAAAC,MAAkB,4CAC3B,OAAS,0BAAAC,MAA8B,2DAGhC,IAAMC,EAAN,KAAoC,CAGzC,YAEmBC,EAIAC,EAIAC,EACjB,CATiB,uBAAAF,EAIA,yBAAAC,EAIA,mBAAAC,CAChB,CAbH,cAAgB,KAAK,MAAM,KAAK,OAAO,EAAI,KAAM,EAe1C,OACLC,EACAC,EACAC,EAAUC,EAAM,GACdC,EAAY,kBAAkB,KAAK,cAAeC,CAAc,CAClE,EACwB,CACxB,OAAO,IAAIC,EACT,CACE,OAAAN,EACA,SAAUC,EAAO,SACjB,WAAY,KAAK,kBAAkB,CACjC,UAAWM,EACX,QAAAL,EACA,QAAS,EACX,CAAC,EACD,aAAc,KAAK,oBAAoB,CAAE,QAAAA,CAAQ,CAAC,EAClD,uBAAwBD,EAAO,sBACjC,EACA,KAAK,aACP,CACF,CACF,EAtCaL,EAANY,EAAA,CADNC,EAAW,EAKPC,EAAA,EAAAC,EAAOC,EAAmB,wBAAwB,GAIlDF,EAAA,EAAAC,EAAOC,EAAmB,0BAA0B,GAIpDF,EAAA,EAAAC,EAAOE,EAAY,6BAA6B,IAZxCjB",
-  "names": ["inject", "injectable", "Maybe", "CHANNEL_LENGTH", "deviceSessionTypes", "FramerUtils", "loggerTypes", "FRAME_SIZE", "UsbHidDeviceConnection", "UsbHidDeviceConnectionFactory", "apduSenderFactory", "apduReceiverFactory", "loggerFactory", "device", "params", "channel", "Maybe", "FramerUtils", "CHANNEL_LENGTH", "UsbHidDeviceConnection", "FRAME_SIZE", "__decorateClass", "injectable", "__decorateParam", "inject", "deviceSessionTypes", "loggerTypes"]
-}

package/lib/esm/src/internal/transport/usb/service/UsbHidDeviceConnectionFactory.stub.js

@@ -1,2 +0,0 @@
-import{defaultApduReceiverServiceStubBuilder as r}from"../../../device-session/service/DefaultApduReceiverService.stub";import{defaultApduSenderServiceStubBuilder as o}from"../../../device-session/service/DefaultApduSenderService.stub";import{DefaultLoggerPublisherService as i}from"../../../logger-publisher/service/__mocks__/DefaultLoggerService";import{UsbHidDeviceConnectionFactory as t}from"../../../transport/usb/service/UsbHidDeviceConnectionFactory";const e=()=>new i,l=()=>new t(()=>o({},e),()=>r({},e),e);export{l as usbHidDeviceConnectionFactoryStubBuilder};
-//# sourceMappingURL=UsbHidDeviceConnectionFactory.stub.js.map

package/lib/esm/src/internal/transport/usb/service/UsbHidDeviceConnectionFactory.stub.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/service/UsbHidDeviceConnectionFactory.stub.ts"],
-  "sourcesContent": ["import { defaultApduReceiverServiceStubBuilder } from \"@internal/device-session/service/DefaultApduReceiverService.stub\";\nimport { defaultApduSenderServiceStubBuilder } from \"@internal/device-session/service/DefaultApduSenderService.stub\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/__mocks__/DefaultLoggerService\";\nimport { UsbHidDeviceConnectionFactory } from \"@internal/transport/usb/service/UsbHidDeviceConnectionFactory\";\n\nconst loggerFactory = () => new DefaultLoggerPublisherService();\n\nexport const usbHidDeviceConnectionFactoryStubBuilder = () =>\n  new UsbHidDeviceConnectionFactory(\n    () => defaultApduSenderServiceStubBuilder({}, loggerFactory),\n    () => defaultApduReceiverServiceStubBuilder({}, loggerFactory),\n    loggerFactory,\n  );\n"],
-  "mappings": "AAAA,OAAS,yCAAAA,MAA6C,mEACtD,OAAS,uCAAAC,MAA2C,iEACpD,OAAS,iCAAAC,MAAqC,oEAC9C,OAAS,iCAAAC,MAAqC,gEAE9C,MAAMC,EAAgB,IAAM,IAAIF,EAEnBG,EAA2C,IACtD,IAAIF,EACF,IAAMF,EAAoC,CAAC,EAAGG,CAAa,EAC3D,IAAMJ,EAAsC,CAAC,EAAGI,CAAa,EAC7DA,CACF",
-  "names": ["defaultApduReceiverServiceStubBuilder", "defaultApduSenderServiceStubBuilder", "DefaultLoggerPublisherService", "UsbHidDeviceConnectionFactory", "loggerFactory", "usbHidDeviceConnectionFactoryStubBuilder"]
-}

package/lib/esm/src/internal/transport/usb/transport/UsbHidDeviceConnection.js

@@ -1,2 +0,0 @@
-var l=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var m=(c,e,t,n)=>{for(var r=n>1?void 0:n?f(e,t):e,i=c.length-1,o;i>=0;i--)(o=c[i])&&(r=(n?o(e,t,r):o(r))||r);return n&&r&&l(e,t,r),r},v=(c,e)=>(t,n)=>e(t,n,c);import{inject as _}from"inversify";import{Left as s,Right as a}from"purify-ts";import{Subject as u}from"rxjs";import{CommandUtils as b}from"../../../../api/command/utils/CommandUtils";import{loggerTypes as R}from"../../../logger-publisher/di/loggerTypes";import{ReconnectionFailedError as g}from"../../../transport/model/Errors";import{HidSendReportError as S}from"../../../transport/model/Errors";import{RECONNECT_DEVICE_TIMEOUT as D}from"../../../transport/usb/data/UsbHidConfig";let d=class{_device;_deviceId;_apduSender;_apduReceiver;_sendApduSubject=new u;_logger;_onConnectionTerminated;reconnectionSubject=new u;waitingForReconnection=!1;lostConnectionTimeout=null;terminated=!1;constructor({device:e,deviceId:t,apduSender:n,apduReceiver:r,onConnectionTerminated:i},o){this._apduSender=n,this._apduReceiver=r,this._onConnectionTerminated=i,this._logger=o("UsbHidDeviceConnection"),this._device=e,this._device.oninputreport=p=>this.receiveHidInputReport(p),this._deviceId=t,this._logger.info("\u{1F50C} Connected to device")}get device(){return this._device}get deviceId(){return this._deviceId}async sendApdu(e,t){this._sendApduSubject=new u,this._logger.debug("Sending APDU",{data:{apdu:e},tag:"apdu-sender"});const n=new Promise(i=>{this._sendApduSubject.subscribe({next:async o=>{t&&b.isSuccessResponse(o)?(await this.waitForReconnection()).caseOf({Left:h=>i(s(h)),Right:()=>i(a(o))}):i(a(o))},error:o=>{i(s(o))}})});if(this.waitingForReconnection||!this.device.opened){const i=await this.waitForReconnection();if(i.isLeft())return i}const r=this._apduSender.getFrames(e);for(const i of r){this._logger.debug("Sending Frame",{data:{frame:i.getRawData()}});try{await this._device.sendReport(0,i.getRawData())}catch(o){return this._logger.error("Error sending frame",{data:{error:o}}),Promise.resolve(s(new S(o)))}}return n}receiveHidInputReport(e){const t=new Uint8Array(e.data.buffer);this._logger.debug("Received Frame",{data:{frame:t},tag:"apdu-receiver"}),this._apduReceiver.handleFrame(t).caseOf({Right:r=>{r.map(i=>{this._logger.debug("Received APDU Response",{data:{response:i}}),this._sendApduSubject.next(i),this._sendApduSubject.complete()})},Left:r=>{this._sendApduSubject.error(r)}})}waitForReconnection(){return this.terminated?Promise.resolve(s(new g)):new Promise(e=>{const t=this.reconnectionSubject.subscribe({next:n=>{e(n==="success"?a(void 0):s(n)),t.unsubscribe()}})})}lostConnection(){this._logger.info("\u23F1\uFE0F Lost connection, starting timer"),this.waitingForReconnection=!0,this.lostConnectionTimeout=setTimeout(()=>{this._logger.info("\u274C Disconnection timeout, terminating connection"),this.disconnect()},D)}async reconnectHidDevice(e){this._device=e,this._device.oninputreport=t=>this.receiveHidInputReport(t),this.lostConnectionTimeout&&(this._logger.info("\u23F1\uFE0F\u{1F50C} Device reconnected"),clearTimeout(this.lostConnectionTimeout)),await e.open(),this.waitingForReconnection=!1,this.reconnectionSubject.next("success")}disconnect(){this._logger.info("\u{1F51A} Disconnect"),this.lostConnectionTimeout&&clearTimeout(this.lostConnectionTimeout),this.terminated=!0,this._onConnectionTerminated(),this.reconnectionSubject.next(new g)}};d=m([v(1,_(R.LoggerPublisherServiceFactory))],d);export{d as UsbHidDeviceConnection};
-//# sourceMappingURL=UsbHidDeviceConnection.js.map

package/lib/esm/src/internal/transport/usb/transport/UsbHidDeviceConnection.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../src/internal/transport/usb/transport/UsbHidDeviceConnection.ts"],
-  "sourcesContent": ["import { inject } from \"inversify\";\nimport { Either, Left, Right } from \"purify-ts\";\nimport { Subject } from \"rxjs\";\n\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { DmkError } from \"@api/Error\";\nimport { DeviceId } from \"@api/types\";\nimport { ApduReceiverService } from \"@internal/device-session/service/ApduReceiverService\";\nimport { ApduSenderService } from \"@internal/device-session/service/ApduSenderService\";\nimport { loggerTypes } from \"@internal/logger-publisher/di/loggerTypes\";\nimport type { LoggerPublisherService } from \"@internal/logger-publisher/service/LoggerPublisherService\";\nimport { DeviceConnection } from \"@internal/transport/model/DeviceConnection\";\nimport { ReconnectionFailedError } from \"@internal/transport/model/Errors\";\nimport { HidSendReportError } from \"@internal/transport/model/Errors\";\nimport { RECONNECT_DEVICE_TIMEOUT } from \"@internal/transport/usb/data/UsbHidConfig\";\n\ntype UsbHidDeviceConnectionConstructorArgs = {\n  device: HIDDevice;\n  deviceId: DeviceId;\n  apduSender: ApduSenderService;\n  apduReceiver: ApduReceiverService;\n  onConnectionTerminated: () => void;\n};\n\n/**\n * Class to manage the connection with a USB HID device.\n * It sends APDU commands to the device and receives the responses.\n * It handles temporary disconnections and reconnections.\n */\nexport class UsbHidDeviceConnection implements DeviceConnection {\n  private _device: HIDDevice;\n  private _deviceId: DeviceId;\n  private readonly _apduSender: ApduSenderService;\n  private readonly _apduReceiver: ApduReceiverService;\n  private _sendApduSubject: Subject<ApduResponse> = new Subject();\n  private readonly _logger: LoggerPublisherService;\n\n  /** Callback to notify the connection termination */\n  private _onConnectionTerminated: () => void;\n  /** Subject to notify the reconnection status */\n  private reconnectionSubject: Subject<\"success\" | DmkError> = new Subject();\n  /** Flag to indicate if the connection is waiting for a reconnection */\n  private waitingForReconnection = false;\n  /** Timeout to wait for the device to reconnect */\n  private lostConnectionTimeout: NodeJS.Timeout | null = null;\n  /** Flag to indicate if the connection is terminated */\n  private terminated = false;\n\n  constructor(\n    {\n      device,\n      deviceId,\n      apduSender,\n      apduReceiver,\n      onConnectionTerminated,\n    }: UsbHidDeviceConnectionConstructorArgs,\n    @inject(loggerTypes.LoggerPublisherServiceFactory)\n    loggerServiceFactory: (tag: string) => LoggerPublisherService,\n  ) {\n    this._apduSender = apduSender;\n    this._apduReceiver = apduReceiver;\n    this._onConnectionTerminated = onConnectionTerminated;\n    this._logger = loggerServiceFactory(\"UsbHidDeviceConnection\");\n    this._device = device;\n    this._device.oninputreport = (event) => this.receiveHidInputReport(event);\n    this._deviceId = deviceId;\n    this._logger.info(\"\uD83D\uDD0C Connected to device\");\n  }\n\n  public get device() {\n    return this._device;\n  }\n\n  public get deviceId() {\n    return this._deviceId;\n  }\n\n  async sendApdu(\n    apdu: Uint8Array,\n    triggersDisconnection?: boolean,\n  ): Promise<Either<DmkError, ApduResponse>> {\n    this._sendApduSubject = new Subject();\n\n    this._logger.debug(\"Sending APDU\", {\n      data: { apdu },\n      tag: \"apdu-sender\",\n    });\n\n    const resultPromise = new Promise<Either<DmkError, ApduResponse>>(\n      (resolve) => {\n        this._sendApduSubject.subscribe({\n          next: async (r) => {\n            if (triggersDisconnection && CommandUtils.isSuccessResponse(r)) {\n              // Anticipate the disconnection and wait for the reconnection before resolving\n              const reconnectionRes = await this.waitForReconnection();\n              reconnectionRes.caseOf({\n                Left: (err) => resolve(Left(err)),\n                Right: () => resolve(Right(r)),\n              });\n            } else {\n              resolve(Right(r));\n            }\n          },\n          error: (err) => {\n            resolve(Left(err));\n          },\n        });\n      },\n    );\n\n    if (this.waitingForReconnection || !this.device.opened) {\n      const reconnectionRes = await this.waitForReconnection();\n      if (reconnectionRes.isLeft()) {\n        return reconnectionRes;\n      }\n    }\n\n    const frames = this._apduSender.getFrames(apdu);\n    for (const frame of frames) {\n      this._logger.debug(\"Sending Frame\", {\n        data: { frame: frame.getRawData() },\n      });\n      try {\n        await this._device.sendReport(0, frame.getRawData());\n      } catch (error) {\n        this._logger.error(\"Error sending frame\", { data: { error } });\n        return Promise.resolve(Left(new HidSendReportError(error)));\n      }\n    }\n\n    return resultPromise;\n  }\n\n  private receiveHidInputReport(event: HIDInputReportEvent) {\n    const data = new Uint8Array(event.data.buffer);\n    this._logger.debug(\"Received Frame\", {\n      data: { frame: data },\n      tag: \"apdu-receiver\",\n    });\n    const response = this._apduReceiver.handleFrame(data);\n    response.caseOf({\n      Right: (maybeApduResponse) => {\n        maybeApduResponse.map((apduResponse) => {\n          this._logger.debug(\"Received APDU Response\", {\n            data: { response: apduResponse },\n          });\n          this._sendApduSubject.next(apduResponse);\n          this._sendApduSubject.complete();\n        });\n      },\n      Left: (err) => {\n        this._sendApduSubject.error(err);\n      },\n    });\n  }\n\n  private waitForReconnection(): Promise<Either<DmkError, void>> {\n    if (this.terminated)\n      return Promise.resolve(Left(new ReconnectionFailedError()));\n    return new Promise<Either<DmkError, void>>((resolve) => {\n      const sub = this.reconnectionSubject.subscribe({\n        next: (res) => {\n          if (res === \"success\") {\n            resolve(Right(undefined));\n          } else {\n            resolve(Left(res));\n          }\n          sub.unsubscribe();\n        },\n      });\n    });\n  }\n\n  /**\n   * Method called when the HIDDevice gets disconnected.\n   * It starts a timeout to wait for the device to reconnect.\n   * */\n  public lostConnection() {\n    this._logger.info(\"\u23F1\uFE0F Lost connection, starting timer\");\n    this.waitingForReconnection = true;\n    this.lostConnectionTimeout = setTimeout(() => {\n      this._logger.info(\"\u274C Disconnection timeout, terminating connection\");\n      this.disconnect();\n    }, RECONNECT_DEVICE_TIMEOUT);\n  }\n\n  /** Reconnect the device after a disconnection */\n  public async reconnectHidDevice(device: HIDDevice) {\n    this._device = device;\n    this._device.oninputreport = (event) => this.receiveHidInputReport(event);\n\n    if (this.lostConnectionTimeout) {\n      this._logger.info(\"\u23F1\uFE0F\uD83D\uDD0C Device reconnected\");\n      clearTimeout(this.lostConnectionTimeout);\n    }\n    await device.open();\n    this.waitingForReconnection = false;\n    this.reconnectionSubject.next(\"success\");\n  }\n\n  public disconnect() {\n    this._logger.info(\"\uD83D\uDD1A Disconnect\");\n    if (this.lostConnectionTimeout) clearTimeout(this.lostConnectionTimeout);\n    this.terminated = true;\n    this._onConnectionTerminated();\n    this.reconnectionSubject.next(new ReconnectionFailedError());\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["inject", "Left", "Right", "Subject", "CommandUtils", "loggerTypes", "ReconnectionFailedError", "HidSendReportError", "RECONNECT_DEVICE_TIMEOUT", "UsbHidDeviceConnection", "Subject", "device", "deviceId", "apduSender", "apduReceiver", "onConnectionTerminated", "loggerServiceFactory", "event", "apdu", "triggersDisconnection", "resultPromise", "resolve", "r", "CommandUtils", "err", "Left", "Right", "reconnectionRes", "frames", "frame", "error", "HidSendReportError", "data", "maybeApduResponse", "apduResponse", "ReconnectionFailedError", "sub", "res", "RECONNECT_DEVICE_TIMEOUT", "__decorateClass", "__decorateParam", "inject", "loggerTypes"]
-}

package/lib/esm/src/internal/transport/usb/transport/UsbHidDeviceConnection.test.js

@@ -1,2 +0,0 @@
-import{Left as w,Right as u}from"purify-ts";import{defaultApduReceiverServiceStubBuilder as A}from"../../../device-session/service/DefaultApduReceiverService.stub";import{defaultApduSenderServiceStubBuilder as y}from"../../../device-session/service/DefaultApduSenderService.stub";import{DefaultLoggerPublisherService as h}from"../../../logger-publisher/service/DefaultLoggerPublisherService";import{ReconnectionFailedError as m}from"../../../transport/model/Errors";import{RECONNECT_DEVICE_TIMEOUT as v}from"../../../transport/usb/data/UsbHidConfig";import{hidDeviceStubBuilder as U}from"../../../transport/usb/model/HIDDevice.stub";import{UsbHidDeviceConnection as x}from"../../../transport/usb/transport/UsbHidDeviceConnection";jest.useFakeTimers();const D=new Uint8Array([170,170,5,0,0,0,2,85,21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),p=new Uint8Array([170,170,5,0,0,0,2,144,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),c=()=>new Promise(jest.requireActual("timers").setImmediate);jest.useFakeTimers();describe("UsbHidDeviceConnection",()=>{let e,o,i;const s=()=>{},a="test-device-id",r=t=>new h([],t);beforeEach(()=>{e=U({opened:!0}),o=y(void 0,r),i=A(void 0,r)}),it("should get device",()=>{const n=new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r).device;expect(n).toStrictEqual(e)}),it("should send APDU through hid report",()=>{new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r).sendApdu(new Uint8Array(0)),expect(e.sendReport).toHaveBeenCalled()}),it("should receive APDU through hid report",async()=>{e.sendReport=jest.fn(()=>Promise.resolve(e.oninputreport({type:"inputreport",data:new DataView(Uint8Array.from(p).buffer)})));const n=await new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r).sendApdu(Uint8Array.from([]));expect(n).toEqual(u({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}))}),describe("anticipating loss of connection after sending an APDU",()=>{test("sendApdu(whatever, true) should wait for reconnection before resolving if the response is a success",async()=>{e.sendReport=jest.fn(()=>Promise.resolve(e.oninputreport({type:"inputreport",data:new DataView(Uint8Array.from(p).buffer)})));const t=new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r);let n=!1;const d=t.sendApdu(Uint8Array.from([]),!0).then(l=>(n=!0,l));t.lostConnection(),await c(),expect(n).toBe(!1),t.reconnectHidDevice(e),await c(),expect(n).toBe(!0);const f=await d;expect(f).toEqual(u({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}))}),test("sendApdu(whatever, true) should not wait for reconnection if the response is not a success",async()=>{e.sendReport=jest.fn(()=>Promise.resolve(e.oninputreport({type:"inputreport",data:new DataView(Uint8Array.from(D).buffer)})));const n=await new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r).sendApdu(Uint8Array.from([]),!0);expect(n).toEqual(u({statusCode:new Uint8Array([85,21]),data:new Uint8Array([])}))}),test("sendApdu(whatever, true) should return an error if the device gets disconnected while waiting for reconnection",async()=>{e.sendReport=jest.fn(()=>Promise.resolve(e.oninputreport({type:"inputreport",data:new DataView(Uint8Array.from(p).buffer)})));const t=new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r),n=t.sendApdu(Uint8Array.from([]),!0);t.lostConnection(),jest.advanceTimersByTime(v),await c();const d=await n;expect(d).toEqual(w(new m))})}),describe("connection lost before sending an APDU",()=>{test("sendApdu(whatever, false) should return an error if the device connection has been lost and times out",async()=>{e.sendReport=jest.fn(()=>Promise.resolve(e.oninputreport({type:"inputreport",data:new DataView(Uint8Array.from(p).buffer)})));const t=new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r);t.lostConnection(),jest.advanceTimersByTime(v),await c();const n=await t.sendApdu(Uint8Array.from([]),!1);await c(),expect(n).toEqual(w(new m))}),test("sendApdu(whatever, false) should wait for reconnection to resolve",async()=>{e.sendReport=jest.fn(()=>Promise.resolve(e.oninputreport({type:"inputreport",data:new DataView(Uint8Array.from(p).buffer)})));const t=new x({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:s,deviceId:a},r);t.lostConnection();let n=!1;const d=t.sendApdu(Uint8Array.from([]),!1).then(l=>(n=!0,l));await c(),expect(n).toBe(!1),t.reconnectHidDevice(e),await c(),expect(n).toBe(!0);const f=await d;expect(f).toEqual(u({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}))})})});
-//# sourceMappingURL=UsbHidDeviceConnection.test.js.map