@ledgerhq/device-management-kit 0.4.0 → 0.5.0

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

@@ -0,0 +1,7 @@
+{
+  "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": ["UsbHidDeviceConnection_exports", "__export", "UsbHidDeviceConnection", "__toCommonJS", "import_inversify", "import_purify_ts", "import_rxjs", "import_CommandUtils", "import_loggerTypes", "import_Errors", "import_UsbHidConfig", "UsbHidDeviceConnection", "device", "deviceId", "apduSender", "apduReceiver", "onConnectionTerminated", "loggerServiceFactory", "event", "apdu", "triggersDisconnection", "resultPromise", "resolve", "r", "err", "reconnectionRes", "frames", "frame", "error", "data", "maybeApduResponse", "apduResponse", "sub", "res", "__decorateClass", "__decorateParam"]
+}

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

@@ -0,0 +1,2 @@
+"use strict";var c=require("purify-ts"),v=require("../../../device-session/service/DefaultApduReceiverService.stub"),A=require("../../../device-session/service/DefaultApduSenderService.stub"),y=require("../../../logger-publisher/service/DefaultLoggerPublisherService"),w=require("../../../transport/model/Errors"),m=require("../../../transport/usb/data/UsbHidConfig"),h=require("../../../transport/usb/model/HIDDevice.stub"),s=require("../../../transport/usb/transport/UsbHidDeviceConnection");jest.useFakeTimers();const U=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]),u=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]),d=()=>new Promise(jest.requireActual("timers").setImmediate);jest.useFakeTimers();describe("UsbHidDeviceConnection",()=>{let e,o,i;const a=()=>{},x="test-device-id",r=t=>new y.DefaultLoggerPublisherService([],t);beforeEach(()=>{e=(0,h.hidDeviceStubBuilder)({opened:!0}),o=(0,A.defaultApduSenderServiceStubBuilder)(void 0,r),i=(0,v.defaultApduReceiverServiceStubBuilder)(void 0,r)}),it("should get device",()=>{const n=new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r).device;expect(n).toStrictEqual(e)}),it("should send APDU through hid report",()=>{new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},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(u).buffer)})));const n=await new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r).sendApdu(Uint8Array.from([]));expect(n).toEqual((0,c.Right)({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(u).buffer)})));const t=new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r);let n=!1;const p=t.sendApdu(Uint8Array.from([]),!0).then(l=>(n=!0,l));t.lostConnection(),await d(),expect(n).toBe(!1),t.reconnectHidDevice(e),await d(),expect(n).toBe(!0);const f=await p;expect(f).toEqual((0,c.Right)({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(U).buffer)})));const n=await new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r).sendApdu(Uint8Array.from([]),!0);expect(n).toEqual((0,c.Right)({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(u).buffer)})));const t=new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r),n=t.sendApdu(Uint8Array.from([]),!0);t.lostConnection(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT),await d();const p=await n;expect(p).toEqual((0,c.Left)(new w.ReconnectionFailedError))})}),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(u).buffer)})));const t=new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r);t.lostConnection(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT),await d();const n=await t.sendApdu(Uint8Array.from([]),!1);await d(),expect(n).toEqual((0,c.Left)(new w.ReconnectionFailedError))}),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(u).buffer)})));const t=new s.UsbHidDeviceConnection({device:e,apduSender:o,apduReceiver:i,onConnectionTerminated:a,deviceId:x},r);t.lostConnection();let n=!1;const p=t.sendApdu(Uint8Array.from([]),!1).then(l=>(n=!0,l));await d(),expect(n).toBe(!1),t.reconnectHidDevice(e),await d(),expect(n).toBe(!0);const f=await p;expect(f).toEqual((0,c.Right)({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}))})})});
+//# sourceMappingURL=UsbHidDeviceConnection.test.js.map

package/lib/cjs/src/internal/transport/usb/transport/UsbHidDeviceConnection.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/internal/transport/usb/transport/UsbHidDeviceConnection.test.ts"],
+  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { type DeviceId } from \"@api/types\";\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 { ReconnectionFailedError } from \"@internal/transport/model/Errors\";\nimport { RECONNECT_DEVICE_TIMEOUT } from \"@internal/transport/usb/data/UsbHidConfig\";\nimport { hidDeviceStubBuilder } from \"@internal/transport/usb/model/HIDDevice.stub\";\nimport { UsbHidDeviceConnection } from \"@internal/transport/usb/transport/UsbHidDeviceConnection\";\n\njest.useFakeTimers();\n\nconst RESPONSE_LOCKED_DEVICE = new Uint8Array([\n  0xaa, 0xaa, 0x05, 0x00, 0x00, 0x00, 0x02, 0x55, 0x15, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\nconst RESPONSE_SUCCESS = new Uint8Array([\n  0xaa, 0xaa, 0x05, 0x00, 0x00, 0x00, 0x02, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\n/**\n * Flushes all pending promises\n */\nconst flushPromises = () =>\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  new Promise(jest.requireActual(\"timers\").setImmediate);\n\njest.useFakeTimers();\n\ndescribe(\"UsbHidDeviceConnection\", () => {\n  let device: HIDDevice;\n  let apduSender: ApduSenderService;\n  let apduReceiver: ApduReceiverService;\n  const onConnectionTerminated = () => {};\n  const deviceId: DeviceId = \"test-device-id\";\n  const logger = (tag: string) => new DefaultLoggerPublisherService([], tag);\n\n  beforeEach(() => {\n    device = hidDeviceStubBuilder({ opened: true });\n    apduSender = defaultApduSenderServiceStubBuilder(undefined, logger);\n    apduReceiver = defaultApduReceiverServiceStubBuilder(undefined, logger);\n  });\n\n  it(\"should get device\", () => {\n    // given\n    const connection = new UsbHidDeviceConnection(\n      { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n      logger,\n    );\n    // when\n    const cDevice = connection.device;\n    // then\n    expect(cDevice).toStrictEqual(device);\n  });\n\n  it(\"should send APDU through hid report\", () => {\n    // given\n    const connection = new UsbHidDeviceConnection(\n      { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n      logger,\n    );\n    // when\n    connection.sendApdu(new Uint8Array(0));\n    // then\n    expect(device.sendReport).toHaveBeenCalled();\n  });\n\n  it(\"should receive APDU through hid report\", async () => {\n    // given\n    device.sendReport = jest.fn(() =>\n      Promise.resolve(\n        device.oninputreport!({\n          type: \"inputreport\",\n          data: new DataView(Uint8Array.from(RESPONSE_SUCCESS).buffer),\n        } as HIDInputReportEvent),\n      ),\n    );\n    const connection = new UsbHidDeviceConnection(\n      { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n      logger,\n    );\n    // when\n    const response = await connection.sendApdu(Uint8Array.from([]));\n    // then\n    expect(response).toEqual(\n      Right({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: new Uint8Array([]),\n      }),\n    );\n  });\n\n  describe(\"anticipating loss of connection after sending an APDU\", () => {\n    test(\"sendApdu(whatever, true) should wait for reconnection before resolving if the response is a success\", async () => {\n      // given\n      device.sendReport = jest.fn(() =>\n        Promise.resolve(\n          device.oninputreport!({\n            type: \"inputreport\",\n            data: new DataView(Uint8Array.from(RESPONSE_SUCCESS).buffer),\n          } as HIDInputReportEvent),\n        ),\n      );\n      const connection = new UsbHidDeviceConnection(\n        { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n        logger,\n      );\n\n      let hasResolved = false;\n      const responsePromise = connection\n        .sendApdu(Uint8Array.from([]), true)\n        .then((response) => {\n          hasResolved = true;\n          return response;\n        });\n\n      connection.lostConnection();\n\n      // before reconnecting\n      await flushPromises();\n      expect(hasResolved).toBe(false);\n\n      // when reconnecting\n      connection.reconnectHidDevice(device);\n      await flushPromises();\n      expect(hasResolved).toBe(true);\n\n      const response = await responsePromise;\n\n      expect(response).toEqual(\n        Right({\n          statusCode: new Uint8Array([0x90, 0x00]),\n          data: new Uint8Array([]),\n        }),\n      );\n    });\n\n    test(\"sendApdu(whatever, true) should not wait for reconnection if the response is not a success\", async () => {\n      // given\n      device.sendReport = jest.fn(() =>\n        Promise.resolve(\n          device.oninputreport!({\n            type: \"inputreport\",\n            data: new DataView(Uint8Array.from(RESPONSE_LOCKED_DEVICE).buffer),\n          } as HIDInputReportEvent),\n        ),\n      );\n      const connection = new UsbHidDeviceConnection(\n        { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n        logger,\n      );\n\n      // when\n      const response = await connection.sendApdu(Uint8Array.from([]), true);\n\n      // then\n      expect(response).toEqual(\n        Right({\n          statusCode: new Uint8Array([0x55, 0x15]),\n          data: new Uint8Array([]),\n        }),\n      );\n    });\n\n    test(\"sendApdu(whatever, true) should return an error if the device gets disconnected while waiting for reconnection\", async () => {\n      // given\n      device.sendReport = jest.fn(() =>\n        Promise.resolve(\n          device.oninputreport!({\n            type: \"inputreport\",\n            data: new DataView(Uint8Array.from(RESPONSE_SUCCESS).buffer),\n          } as HIDInputReportEvent),\n        ),\n      );\n      const connection = new UsbHidDeviceConnection(\n        { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n        logger,\n      );\n\n      const responsePromise = connection.sendApdu(Uint8Array.from([]), true);\n\n      // when disconnecting\n      connection.lostConnection();\n      jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);\n      await flushPromises();\n\n      // then\n      const response = await responsePromise;\n      expect(response).toEqual(Left(new ReconnectionFailedError()));\n    });\n  });\n\n  describe(\"connection lost before sending an APDU\", () => {\n    test(\"sendApdu(whatever, false) should return an error if the device connection has been lost and times out\", async () => {\n      // given\n      device.sendReport = jest.fn(() =>\n        Promise.resolve(\n          device.oninputreport!({\n            type: \"inputreport\",\n            data: new DataView(Uint8Array.from(RESPONSE_SUCCESS).buffer),\n          } as HIDInputReportEvent),\n        ),\n      );\n      const connection = new UsbHidDeviceConnection(\n        { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n        logger,\n      );\n\n      // when losing connection\n      connection.lostConnection();\n      jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);\n      await flushPromises();\n\n      // then\n      const response = await connection.sendApdu(Uint8Array.from([]), false);\n      await flushPromises();\n      expect(response).toEqual(Left(new ReconnectionFailedError()));\n    });\n\n    test(\"sendApdu(whatever, false) should wait for reconnection to resolve\", async () => {\n      // given\n      device.sendReport = jest.fn(() =>\n        Promise.resolve(\n          device.oninputreport!({\n            type: \"inputreport\",\n            data: new DataView(Uint8Array.from(RESPONSE_SUCCESS).buffer),\n          } as HIDInputReportEvent),\n        ),\n      );\n      const connection = new UsbHidDeviceConnection(\n        { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },\n        logger,\n      );\n\n      // when losing connection\n      connection.lostConnection();\n\n      let hasResolved = false;\n      const responsePromise = connection\n        .sendApdu(Uint8Array.from([]), false)\n        .then((response) => {\n          hasResolved = true;\n          return response;\n        });\n\n      // before reconnecting\n      await flushPromises();\n      expect(hasResolved).toBe(false);\n\n      // when reconnecting\n      connection.reconnectHidDevice(device);\n      await flushPromises();\n      expect(hasResolved).toBe(true);\n\n      const response = await responsePromise;\n\n      expect(response).toEqual(\n        Right({\n          statusCode: new Uint8Array([0x90, 0x00]),\n          data: new Uint8Array([]),\n        }),\n      );\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["import_purify_ts", "import_DefaultApduReceiverService", "import_DefaultApduSenderService", "import_DefaultLoggerPublisherService", "import_Errors", "import_UsbHidConfig", "import_HIDDevice", "import_UsbHidDeviceConnection", "RESPONSE_LOCKED_DEVICE", "RESPONSE_SUCCESS", "flushPromises", "device", "apduSender", "apduReceiver", "onConnectionTerminated", "deviceId", "logger", "tag", "cDevice", "response", "connection", "hasResolved", "responsePromise"]
+}

package/lib/cjs/src/internal/transport/usb/transport/WebUsbHidTransport.js

@@ -0,0 +1,2 @@
+"use strict";var S=Object.create;var l=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var A=Object.getPrototypeOf,T=Object.prototype.hasOwnProperty;var M=(r,e)=>{for(var i in e)l(r,i,{get:e[i],enumerable:!0})},b=(r,e,i,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of P(e))!T.call(r,n)&&n!==i&&l(r,n,{get:()=>e[n],enumerable:!(t=f(e,n))||t.enumerable});return r};var U=(r,e,i)=>(i=r!=null?S(A(r)):{},b(e||!r||!r.__esModule?l(i,"default",{value:r,enumerable:!0}):i,r)),L=r=>b(l({},"__esModule",{value:!0}),r),E=(r,e,i,t)=>{for(var n=t>1?void 0:t?f(e,i):e,o=r.length-1,a;o>=0;o--)(a=r[o])&&(n=(t?a(e,i,n):a(n))||n);return t&&n&&l(e,i,n),n},u=(r,e)=>(i,t)=>e(i,t,r);var B={};M(B,{WebUsbHidTransport:()=>p});module.exports=L(B);var g=U(require("@sentry/minimal")),D=require("inversify"),c=require("purify-ts"),v=require("rxjs"),I=require("uuid"),y=require("../../../../api/transport/model/TransportIdentifier"),_=require("../../../device-model/di/deviceModelTypes"),C=require("../../../logger-publisher/di/loggerTypes"),s=require("../../../transport/model/Errors"),H=require("../../../transport/model/InternalConnectedDevice"),m=require("../../../transport/usb/data/UsbHidConfig"),w=require("../../../transport/usb/di/usbDiTypes");let p=class{constructor(e,i,t){this.deviceModelDataSource=e;this._logger=i("WebUsbHidTransport"),this._usbHidDeviceConnectionFactory=t,this.startListeningToConnectionEvents()}_internalDiscoveredDevices=new v.BehaviorSubject([]);_deviceConnectionsByHidDevice=new Map;_deviceConnectionsPendingReconnection=new Set;_connectionListenersAbortController=new AbortController;_logger;_usbHidDeviceConnectionFactory;connectionType="USB";identifier=y.BuiltinTransports.USB;get hidApi(){return this.isSupported()?(0,c.Right)(navigator.hid):(0,c.Left)(new s.UsbHidTransportNotSupportedError("WebHID not supported"))}isSupported(){try{const e=!!navigator?.hid;return this._logger.debug(`isSupported: ${e}`),e}catch(e){return this._logger.error("isSupported: error",{data:{error:e}}),!1}}getIdentifier(){return this.identifier}async getDevices(){return c.EitherAsync.liftEither(this.hidApi).map(async e=>{try{return(await e.getDevices()).filter(t=>t.vendorId===m.LEDGER_VENDOR_ID)}catch(i){const t=new s.NoAccessibleDeviceError(i);throw this._logger.error("getDevices: error getting devices",{data:{error:i}}),g.captureException(t),t}}).run()}mapHIDDeviceToInternalDiscoveredDevice(e){const i=this._internalDiscoveredDevices.getValue().find(o=>o.hidDevice===e);if(i)return i;const t=this._deviceConnectionsByHidDevice.get(e);return this.getDeviceModel(e).caseOf({Just:o=>{const a=t?.deviceId??(0,I.v4)(),d={id:a,deviceModel:o,hidDevice:e,transport:this.identifier};return this._logger.debug(`Discovered device ${a} ${d.deviceModel.productName}`),d},Nothing:()=>{throw this._logger.warn(`Device not recognized: hidDevice.productId: 0x${e.productId.toString(16)}`),new s.DeviceNotRecognizedError(`Device not recognized: hidDevice.productId: 0x${e.productId.toString(16)}`)}})}listenToKnownDevices(){return this.updateInternalDiscoveredDevices(),this._internalDiscoveredDevices.pipe((0,v.map)(e=>e.map(({hidDevice:i,...t})=>t)))}async updateInternalDiscoveredDevices(){(await this.getDevices()).caseOf({Left:i=>{this._logger.error("Error while getting accessible device",{data:{error:i}}),g.captureException(i)},Right:i=>{this._internalDiscoveredDevices.next(i.map(t=>this.mapHIDDeviceToInternalDiscoveredDevice(t)))}})}async promptDeviceAccess(){return c.EitherAsync.liftEither(this.hidApi).map(async e=>{let i=[];try{i=await e.requestDevice({filters:[{vendorId:m.LEDGER_VENDOR_ID}]}),await this.updateInternalDiscoveredDevices()}catch(n){const o=new s.NoAccessibleDeviceError(n);throw this._logger.error("promptDeviceAccess: error requesting device",{data:{error:n}}),g.captureException(o),o}if(this._logger.debug(`promptDeviceAccess: hidDevices len ${i.length}`),i.length===0)throw this._logger.warn("No device was selected"),new s.NoAccessibleDeviceError("No selected device");const t=[];for(const n of i)t.push(n),this._logger.debug("promptDeviceAccess: selected device",{data:{hidDevice:n}});return t}).run()}startDiscovering(){return this._logger.debug("startDiscovering"),(0,v.from)(this.promptDeviceAccess()).pipe((0,v.switchMap)(e=>e.caseOf({Left:i=>{throw this._logger.error("Error while getting accessible device",{data:{error:i}}),g.captureException(i),i},Right:i=>{this._logger.info(`Got access to ${i.length} HID devices`);const t=i.map(n=>this.mapHIDDeviceToInternalDiscoveredDevice(n));return(0,v.from)(t)}})))}stopDiscovering(){}startListeningToConnectionEvents(){this._logger.debug("startListeningToConnectionEvents"),this.hidApi.map(e=>{e.addEventListener("connect",i=>this.handleDeviceConnectionEvent(i),{signal:this._connectionListenersAbortController.signal}),e.addEventListener("disconnect",i=>{this.handleDeviceDisconnectionEvent(i)},{signal:this._connectionListenersAbortController.signal})})}stopListeningToConnectionEvents(){this._logger.debug("stopListeningToConnectionEvents"),this._connectionListenersAbortController.abort()}async connect({deviceId:e,onDisconnect:i}){this._logger.debug("connect",{data:{deviceId:e}});const t=this._internalDiscoveredDevices.getValue().find(d=>d.id===e);if(!t)return this._logger.error(`Unknown device ${e}`),(0,c.Left)(new s.UnknownDeviceError(`Unknown device ${e}`));try{if(this._deviceConnectionsByHidDevice.get(t.hidDevice))throw new Error("Device already opened");await t.hidDevice.open()}catch(d){if(d instanceof DOMException&&d.name==="InvalidStateError")this._logger.debug(`Device ${e} is already opened`);else{const h=new s.OpeningConnectionError(d);return this._logger.debug(`Error while opening device: ${e}`,{data:{error:d}}),g.captureException(h),(0,c.Left)(h)}}const{deviceModel:n}=t,o=this._usbHidDeviceConnectionFactory.create(t.hidDevice,{onConnectionTerminated:()=>{i(e),this._deviceConnectionsPendingReconnection.delete(o),this._deviceConnectionsByHidDevice.delete(t.hidDevice),o.device.close()},deviceId:e});this._deviceConnectionsByHidDevice.set(t.hidDevice,o);const a=new H.InternalConnectedDevice({sendApdu:(d,h)=>o.sendApdu(d,h),deviceModel:n,id:e,type:this.connectionType,transport:this.identifier});return(0,c.Right)(a)}getDeviceModel(e){const{productId:i}=e,t=this.deviceModelDataSource.getAllDeviceModels().find(n=>n.usbProductId===i>>8||n.bootloaderUsbProductId===i);return t?c.Maybe.of(t):c.Maybe.zero()}getHidUsbProductId(e){return this.getDeviceModel(e).caseOf({Just:i=>i.usbProductId,Nothing:()=>e.productId>>8})}async disconnect(e){this._logger.debug("disconnect",{data:{connectedDevice:e}});const i=Array.from(this._deviceConnectionsByHidDevice.values()).find(t=>t.deviceId===e.connectedDevice.id);return i?(i.disconnect(),Promise.resolve((0,c.Right)(void 0))):(this._logger.error("No matching device connection found",{data:{connectedDevice:e}}),Promise.resolve((0,c.Left)(new s.UnknownDeviceError(`Unknown device ${e.connectedDevice.id}`))))}isHIDConnectionEvent(e){return"device"in e&&typeof e.device=="object"&&e.device!==null&&"productId"in e.device&&typeof e.device.productId=="number"}async handleDeviceDisconnectionEvent(e){if(!this.isHIDConnectionEvent(e)){this._logger.error("Invalid event",{data:{event:e}});return}this._logger.info("[handleDeviceDisconnectionEvent] Device disconnected",{data:{event:e}}),this.updateInternalDiscoveredDevices();try{await e.device.close()}catch(t){this._logger.error("Error while closing device ",{data:{event:e,error:t}})}const i=this._deviceConnectionsByHidDevice.get(e.device);i&&(i.lostConnection(),this._deviceConnectionsPendingReconnection.add(i),this._deviceConnectionsByHidDevice.delete(e.device))}handleDeviceReconnection(e,i){this._deviceConnectionsPendingReconnection.delete(e),this._deviceConnectionsByHidDevice.set(i,e);try{e.reconnectHidDevice(i)}catch(t){this._logger.error("Error while reconnecting to device",{data:{event,error:t}}),e.disconnect()}}handleDeviceConnectionEvent(e){if(!this.isHIDConnectionEvent(e)){this._logger.error("Invalid event",{data:{event:e}});return}this._logger.info("[handleDeviceConnectionEvent] Device connected",{data:{event:e}});const i=Array.from(this._deviceConnectionsPendingReconnection).find(t=>this.getHidUsbProductId(t.device)===this.getHidUsbProductId(e.device));i&&this.handleDeviceReconnection(i,e.device),this.updateInternalDiscoveredDevices()}destroy(){this.stopListeningToConnectionEvents(),this._deviceConnectionsByHidDevice.forEach(e=>{e.disconnect()}),this._deviceConnectionsPendingReconnection.clear()}};p=E([(0,D.injectable)(),u(0,(0,D.inject)(_.deviceModelTypes.DeviceModelDataSource)),u(1,(0,D.inject)(C.loggerTypes.LoggerPublisherServiceFactory)),u(2,(0,D.inject)(w.usbDiTypes.UsbHidDeviceConnectionFactory))],p);0&&(module.exports={WebUsbHidTransport});
+//# sourceMappingURL=WebUsbHidTransport.js.map

package/lib/cjs/src/internal/transport/usb/transport/WebUsbHidTransport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/internal/transport/usb/transport/WebUsbHidTransport.ts"],
+  "sourcesContent": ["import * as Sentry from \"@sentry/minimal\";\nimport { inject, injectable } from \"inversify\";\nimport { Either, EitherAsync, Left, Maybe, Right } from \"purify-ts\";\nimport { BehaviorSubject, from, map, Observable, switchMap } 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 { InternalDeviceModel } from \"@internal/device-model/model/DeviceModel\";\nimport { loggerTypes } from \"@internal/logger-publisher/di/loggerTypes\";\nimport type { LoggerPublisherService } from \"@internal/logger-publisher/service/LoggerPublisherService\";\nimport { DisconnectHandler } from \"@internal/transport/model/DeviceConnection\";\nimport {\n  ConnectError,\n  DeviceNotRecognizedError,\n  NoAccessibleDeviceError,\n  OpeningConnectionError,\n  type PromptDeviceAccessError,\n  UnknownDeviceError,\n  UsbHidTransportNotSupportedError,\n} from \"@internal/transport/model/Errors\";\nimport { InternalConnectedDevice } from \"@internal/transport/model/InternalConnectedDevice\";\nimport { InternalDiscoveredDevice } from \"@internal/transport/model/InternalDiscoveredDevice\";\nimport { LEDGER_VENDOR_ID } from \"@internal/transport/usb/data/UsbHidConfig\";\nimport { usbDiTypes } from \"@internal/transport/usb/di/usbDiTypes\";\nimport { UsbHidDeviceConnectionFactory } from \"@internal/transport/usb/service/UsbHidDeviceConnectionFactory\";\nimport { UsbHidDeviceConnection } from \"@internal/transport/usb/transport/UsbHidDeviceConnection\";\n\ntype WebUsbHidInternalDiscoveredDevice = InternalDiscoveredDevice & {\n  hidDevice: HIDDevice;\n};\n\n@injectable()\nexport class WebUsbHidTransport implements Transport {\n  /** List of HID devices that have been discovered */\n  private _internalDiscoveredDevices: BehaviorSubject<\n    Array<WebUsbHidInternalDiscoveredDevice>\n  > = new BehaviorSubject<Array<WebUsbHidInternalDiscoveredDevice>>([]);\n\n  /** Map of *connected* HIDDevice to their UsbHidDeviceConnection */\n  private _deviceConnectionsByHidDevice: Map<\n    HIDDevice,\n    UsbHidDeviceConnection\n  > = new Map();\n\n  /**\n   * Set of UsbHidDeviceConnection for which the HIDDevice has been\n   * disconnected, so they are waiting for a reconnection\n   */\n  private _deviceConnectionsPendingReconnection: Set<UsbHidDeviceConnection> =\n    new Set();\n\n  /** AbortController to stop listening to HID connection events */\n  private _connectionListenersAbortController: AbortController =\n    new AbortController();\n  private _logger: LoggerPublisherService;\n  private _usbHidDeviceConnectionFactory: UsbHidDeviceConnectionFactory;\n  private readonly connectionType: ConnectionType = \"USB\";\n  private readonly identifier: TransportIdentifier = BuiltinTransports.USB;\n\n  constructor(\n    @inject(deviceModelTypes.DeviceModelDataSource)\n    private deviceModelDataSource: DeviceModelDataSource,\n    @inject(loggerTypes.LoggerPublisherServiceFactory)\n    loggerServiceFactory: (tag: string) => LoggerPublisherService,\n    @inject(usbDiTypes.UsbHidDeviceConnectionFactory)\n    usbHidDeviceConnectionFactory: UsbHidDeviceConnectionFactory,\n  ) {\n    this._logger = loggerServiceFactory(\"WebUsbHidTransport\");\n    this._usbHidDeviceConnectionFactory = usbHidDeviceConnectionFactory;\n\n    this.startListeningToConnectionEvents();\n  }\n\n  /**\n   * Get the WebHID API if supported or error\n   * @returns `Either<UsbHidTransportNotSupportedError, HID>`\n   */\n  private get hidApi(): Either<UsbHidTransportNotSupportedError, HID> {\n    if (this.isSupported()) {\n      return Right(navigator.hid);\n    }\n\n    return Left(new UsbHidTransportNotSupportedError(\"WebHID not supported\"));\n  }\n\n  isSupported() {\n    try {\n      const result = !!navigator?.hid;\n      this._logger.debug(`isSupported: ${result}`);\n      return result;\n    } catch (error) {\n      this._logger.error(`isSupported: error`, { data: { error } });\n      return false;\n    }\n  }\n\n  getIdentifier(): TransportIdentifier {\n    return this.identifier;\n  }\n\n  /**\n   * Wrapper around `navigator.hid.getDevices()`.\n   * It will return the list of plugged in HID devices to which the user has\n   * previously granted access through `navigator.hid.requestDevice()`.\n   */\n  private async getDevices(): Promise<Either<DmkError, HIDDevice[]>> {\n    return EitherAsync.liftEither(this.hidApi)\n      .map(async (hidApi) => {\n        try {\n          const allDevices = await hidApi.getDevices();\n          return allDevices.filter(\n            (hidDevice) => hidDevice.vendorId === LEDGER_VENDOR_ID,\n          );\n        } catch (error) {\n          const deviceError = new NoAccessibleDeviceError(error);\n          this._logger.error(`getDevices: error getting devices`, {\n            data: { error },\n          });\n          Sentry.captureException(deviceError);\n          throw deviceError;\n        }\n      })\n      .run();\n  }\n\n  /**\n   * Map a HIDDevice to an InternalDiscoveredDevice, either by creating a new one or returning an existing one\n   */\n  private mapHIDDeviceToInternalDiscoveredDevice(\n    hidDevice: HIDDevice,\n  ): WebUsbHidInternalDiscoveredDevice {\n    const existingDiscoveredDevice = this._internalDiscoveredDevices\n      .getValue()\n      .find((internalDevice) => internalDevice.hidDevice === hidDevice);\n\n    if (existingDiscoveredDevice) {\n      return existingDiscoveredDevice;\n    }\n\n    const existingDeviceConnection =\n      this._deviceConnectionsByHidDevice.get(hidDevice);\n\n    const maybeDeviceModel = this.getDeviceModel(hidDevice);\n    return maybeDeviceModel.caseOf({\n      Just: (deviceModel) => {\n        const id = existingDeviceConnection?.deviceId ?? uuid();\n\n        const discoveredDevice = {\n          id,\n          deviceModel,\n          hidDevice,\n          transport: this.identifier,\n        };\n\n        this._logger.debug(\n          `Discovered device ${id} ${discoveredDevice.deviceModel.productName}`,\n        );\n\n        return discoveredDevice;\n      },\n      Nothing: () => {\n        // [ASK] Or we just ignore the not recognized device ? And log them\n        this._logger.warn(\n          `Device not recognized: hidDevice.productId: 0x${hidDevice.productId.toString(16)}`,\n        );\n        throw new DeviceNotRecognizedError(\n          `Device not recognized: hidDevice.productId: 0x${hidDevice.productId.toString(16)}`,\n        );\n      },\n    });\n  }\n\n  /**\n   * Listen to known devices (devices to which the user has granted access)\n   */\n  public listenToKnownDevices(): Observable<InternalDiscoveredDevice[]> {\n    this.updateInternalDiscoveredDevices();\n    return this._internalDiscoveredDevices.pipe(\n      map((devices) => devices.map(({ hidDevice, ...device }) => device)),\n    );\n  }\n\n  private async updateInternalDiscoveredDevices(): Promise<void> {\n    const eitherDevices = await this.getDevices();\n    eitherDevices.caseOf({\n      Left: (error) => {\n        this._logger.error(\"Error while getting accessible device\", {\n          data: { error },\n        });\n        Sentry.captureException(error);\n      },\n      Right: (hidDevices) => {\n        this._internalDiscoveredDevices.next(\n          hidDevices.map((hidDevice) =>\n            this.mapHIDDeviceToInternalDiscoveredDevice(hidDevice),\n          ),\n        );\n      },\n    });\n  }\n\n  /**\n   * Wrapper around navigator.hid.requestDevice()\n   * In a browser, it will show a native dialog to select a HID device.\n   */\n  private async promptDeviceAccess(): Promise<\n    Either<PromptDeviceAccessError, HIDDevice[]>\n  > {\n    return EitherAsync.liftEither(this.hidApi)\n      .map(async (hidApi) => {\n        // `requestDevice` returns an array. but normally the user can select only one device at a time.\n        let hidDevices: HIDDevice[] = [];\n\n        try {\n          hidDevices = await hidApi.requestDevice({\n            filters: [{ vendorId: LEDGER_VENDOR_ID }],\n          });\n          await this.updateInternalDiscoveredDevices();\n        } catch (error) {\n          const deviceError = new NoAccessibleDeviceError(error);\n          this._logger.error(`promptDeviceAccess: error requesting device`, {\n            data: { error },\n          });\n          Sentry.captureException(deviceError);\n          throw deviceError;\n        }\n\n        this._logger.debug(\n          `promptDeviceAccess: hidDevices len ${hidDevices.length}`,\n        );\n\n        // Granted access to 0 device (by clicking on cancel for ex) results in an error\n        if (hidDevices.length === 0) {\n          this._logger.warn(\"No device was selected\");\n          throw new NoAccessibleDeviceError(\"No selected device\");\n        }\n\n        const discoveredHidDevices: HIDDevice[] = [];\n\n        for (const hidDevice of hidDevices) {\n          discoveredHidDevices.push(hidDevice);\n\n          this._logger.debug(`promptDeviceAccess: selected device`, {\n            data: { hidDevice },\n          });\n        }\n\n        return discoveredHidDevices;\n      })\n      .run();\n  }\n\n  startDiscovering(): Observable<InternalDiscoveredDevice> {\n    this._logger.debug(\"startDiscovering\");\n\n    return from(this.promptDeviceAccess()).pipe(\n      switchMap((either) => {\n        return either.caseOf({\n          Left: (error) => {\n            this._logger.error(\"Error while getting accessible device\", {\n              data: { error },\n            });\n            Sentry.captureException(error);\n            throw error;\n          },\n          Right: (hidDevices) => {\n            this._logger.info(`Got access to ${hidDevices.length} HID devices`);\n\n            const discoveredDevices = hidDevices.map((hidDevice) => {\n              return this.mapHIDDeviceToInternalDiscoveredDevice(hidDevice);\n            });\n            return from(discoveredDevices);\n          },\n        });\n      }),\n    );\n  }\n\n  stopDiscovering(): void {\n    /**\n     * This does nothing because the startDiscovering method is just a\n     * promise wrapped into an observable. So there is no need to stop it.\n     */\n  }\n\n  private startListeningToConnectionEvents(): void {\n    this._logger.debug(\"startListeningToConnectionEvents\");\n\n    this.hidApi.map((hidApi) => {\n      hidApi.addEventListener(\n        \"connect\",\n        (event) => this.handleDeviceConnectionEvent(event),\n        { signal: this._connectionListenersAbortController.signal },\n      );\n\n      hidApi.addEventListener(\n        \"disconnect\",\n        (event) => {\n          this.handleDeviceDisconnectionEvent(event);\n        },\n        { signal: this._connectionListenersAbortController.signal },\n      );\n    });\n  }\n\n  private stopListeningToConnectionEvents(): void {\n    this._logger.debug(\"stopListeningToConnectionEvents\");\n    this._connectionListenersAbortController.abort();\n  }\n\n  /**\n   * Connect to a HID USB device and update the internal state of the associated device\n   */\n  async connect({\n    deviceId,\n    onDisconnect,\n  }: {\n    deviceId: DeviceId;\n    onDisconnect: DisconnectHandler;\n  }): Promise<Either<ConnectError, InternalConnectedDevice>> {\n    this._logger.debug(\"connect\", { data: { deviceId } });\n\n    const matchingInternalDevice = this._internalDiscoveredDevices\n      .getValue()\n      .find((internalDevice) => internalDevice.id === deviceId);\n\n    if (!matchingInternalDevice) {\n      this._logger.error(`Unknown device ${deviceId}`);\n      return Left(new UnknownDeviceError(`Unknown device ${deviceId}`));\n    }\n\n    try {\n      if (\n        this._deviceConnectionsByHidDevice.get(matchingInternalDevice.hidDevice)\n      ) {\n        throw new Error(\"Device already opened\");\n      }\n      await matchingInternalDevice.hidDevice.open();\n    } catch (error) {\n      if (error instanceof DOMException && error.name === \"InvalidStateError\") {\n        this._logger.debug(`Device ${deviceId} is already opened`);\n      } else {\n        const connectionError = new OpeningConnectionError(error);\n        this._logger.debug(`Error while opening device: ${deviceId}`, {\n          data: { error },\n        });\n        Sentry.captureException(connectionError);\n        return Left(connectionError);\n      }\n    }\n\n    const { deviceModel } = matchingInternalDevice;\n\n    const deviceConnection = this._usbHidDeviceConnectionFactory.create(\n      matchingInternalDevice.hidDevice,\n      {\n        onConnectionTerminated: () => {\n          onDisconnect(deviceId);\n          this._deviceConnectionsPendingReconnection.delete(deviceConnection);\n          this._deviceConnectionsByHidDevice.delete(\n            matchingInternalDevice.hidDevice,\n          );\n          deviceConnection.device.close();\n        },\n        deviceId,\n      },\n    );\n\n    this._deviceConnectionsByHidDevice.set(\n      matchingInternalDevice.hidDevice,\n      deviceConnection,\n    );\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    return Right(connectedDevice);\n  }\n\n  private getDeviceModel(hidDevice: HIDDevice): Maybe<InternalDeviceModel> {\n    const { productId } = hidDevice;\n    const matchingModel = this.deviceModelDataSource.getAllDeviceModels().find(\n      (deviceModel) =>\n        // outside of bootloader mode, the value that we need to identify a device model is the first byte of the actual hidDevice.productId\n        deviceModel.usbProductId === productId >> 8 ||\n        deviceModel.bootloaderUsbProductId === productId,\n    );\n    return matchingModel ? Maybe.of(matchingModel) : Maybe.zero();\n  }\n\n  private getHidUsbProductId(hidDevice: HIDDevice): number {\n    return this.getDeviceModel(hidDevice).caseOf({\n      Just: (deviceModel) => deviceModel.usbProductId,\n      Nothing: () => hidDevice.productId >> 8,\n    });\n  }\n\n  /**\n   * Disconnect from a HID USB device\n   */\n  async disconnect(params: {\n    connectedDevice: InternalConnectedDevice;\n  }): Promise<Either<DmkError, void>> {\n    this._logger.debug(\"disconnect\", { data: { connectedDevice: params } });\n\n    const matchingDeviceConnection = Array.from(\n      this._deviceConnectionsByHidDevice.values(),\n    ).find(\n      (deviceConnection) =>\n        deviceConnection.deviceId === params.connectedDevice.id,\n    );\n\n    if (!matchingDeviceConnection) {\n      this._logger.error(\"No matching device connection found\", {\n        data: { connectedDevice: params },\n      });\n      return Promise.resolve(\n        Left(\n          new UnknownDeviceError(`Unknown device ${params.connectedDevice.id}`),\n        ),\n      );\n    }\n\n    matchingDeviceConnection.disconnect();\n    return Promise.resolve(Right(undefined));\n  }\n\n  /**\n   * Type guard to check if the event is a HID connection event\n   * @param event\n   * @private\n   */\n  private isHIDConnectionEvent(event: Event): event is HIDConnectionEvent {\n    return (\n      \"device\" in event &&\n      typeof event.device === \"object\" &&\n      event.device !== null &&\n      \"productId\" in event.device &&\n      typeof event.device.productId === \"number\"\n    );\n  }\n\n  /**\n   * Handle the disconnection event of a HID device\n   * @param event\n   */\n  private async handleDeviceDisconnectionEvent(event: Event) {\n    if (!this.isHIDConnectionEvent(event)) {\n      this._logger.error(\"Invalid event\", { data: { event } });\n      return;\n    }\n\n    this._logger.info(\"[handleDeviceDisconnectionEvent] Device disconnected\", {\n      data: { event },\n    });\n\n    this.updateInternalDiscoveredDevices();\n\n    try {\n      await event.device.close();\n    } catch (error) {\n      this._logger.error(\"Error while closing device \", {\n        data: { event, error },\n      });\n    }\n\n    const matchingDeviceConnection = this._deviceConnectionsByHidDevice.get(\n      event.device,\n    );\n\n    if (matchingDeviceConnection) {\n      matchingDeviceConnection.lostConnection();\n      this._deviceConnectionsPendingReconnection.add(matchingDeviceConnection);\n      this._deviceConnectionsByHidDevice.delete(event.device);\n    }\n  }\n\n  private handleDeviceReconnection(\n    deviceConnection: UsbHidDeviceConnection,\n    hidDevice: HIDDevice,\n  ) {\n    this._deviceConnectionsPendingReconnection.delete(deviceConnection);\n    this._deviceConnectionsByHidDevice.set(hidDevice, deviceConnection);\n\n    try {\n      deviceConnection.reconnectHidDevice(hidDevice);\n    } catch (error) {\n      this._logger.error(\"Error while reconnecting to device\", {\n        data: { event, error },\n      });\n      deviceConnection.disconnect();\n    }\n  }\n\n  /**\n   * Handle the connection event of a HID device\n   * @param event\n   */\n  private handleDeviceConnectionEvent(event: Event) {\n    if (!this.isHIDConnectionEvent(event)) {\n      this._logger.error(\"Invalid event\", { data: { event } });\n      return;\n    }\n\n    this._logger.info(\"[handleDeviceConnectionEvent] Device connected\", {\n      data: { event },\n    });\n\n    const matchingDeviceConnection = Array.from(\n      this._deviceConnectionsPendingReconnection,\n    ).find(\n      (deviceConnection) =>\n        this.getHidUsbProductId(deviceConnection.device) ===\n        this.getHidUsbProductId(event.device),\n    );\n\n    if (matchingDeviceConnection) {\n      this.handleDeviceReconnection(matchingDeviceConnection, event.device);\n    }\n\n    /**\n     * Note: we do this after handling the reconnection to allow the newly\n     * discovered device to keep the same DeviceId as the previous one in case\n     * of a reconnection.\n     */\n    this.updateInternalDiscoveredDevices();\n  }\n\n  public destroy() {\n    this.stopListeningToConnectionEvents();\n    this._deviceConnectionsByHidDevice.forEach((connection) => {\n      connection.disconnect();\n    });\n    this._deviceConnectionsPendingReconnection.clear();\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["WebUsbHidTransport_exports", "__export", "WebUsbHidTransport", "__toCommonJS", "Sentry", "import_inversify", "import_purify_ts", "import_rxjs", "import_uuid", "import_TransportIdentifier", "import_deviceModelTypes", "import_loggerTypes", "import_Errors", "import_InternalConnectedDevice", "import_UsbHidConfig", "import_usbDiTypes", "WebUsbHidTransport", "deviceModelDataSource", "loggerServiceFactory", "usbHidDeviceConnectionFactory", "result", "error", "hidApi", "hidDevice", "deviceError", "Sentry", "existingDiscoveredDevice", "internalDevice", "existingDeviceConnection", "deviceModel", "id", "uuid", "discoveredDevice", "devices", "device", "hidDevices", "discoveredHidDevices", "either", "discoveredDevices", "event", "deviceId", "onDisconnect", "matchingInternalDevice", "connectionError", "deviceConnection", "connectedDevice", "apdu", "triggersDisconnection", "productId", "matchingModel", "params", "matchingDeviceConnection", "connection", "__decorateClass", "__decorateParam"]
+}

package/lib/cjs/src/internal/transport/usb/transport/WebUsbHidTransport.test.js

@@ -0,0 +1,2 @@
+"use strict";var D=require("purify-ts"),w=require("rxjs"),u=require("../../../../api/device/DeviceModel"),C=require("../../../device-model/data/StaticDeviceModelDataSource"),j=require("../../../logger-publisher/service/DefaultLoggerPublisherService"),l=require("../../../transport/model/Errors"),k=require("../../../transport/model/InternalConnectedDevice.stub"),m=require("../../../transport/usb/data/UsbHidConfig"),v=require("../../../transport/usb/model/HIDDevice.stub"),y=require("../../../transport/usb/service/UsbHidDeviceConnectionFactory.stub"),B=require("./WebUsbHidTransport");jest.mock("@internal/logger-publisher/service/LoggerPublisherService");const x=new C.StaticDeviceModelDataSource,T=new j.DefaultLoggerPublisherService([],"web-usb-hid"),d=(0,v.hidDeviceStubBuilder)(),h=()=>new Promise(jest.requireActual("timers").setImmediate);describe("WebUsbHidTransport",()=>{let i;function g(){i=new B.WebUsbHidTransport(x,()=>T,(0,y.usbHidDeviceConnectionFactoryStubBuilder)())}beforeEach(()=>{g(),jest.useFakeTimers()}),afterEach(()=>{jest.restoreAllMocks()});const a=(s,r)=>{i.startDiscovering().subscribe({next:s,error:r})};describe("When WebHID API is not supported",()=>{it("should not support the transport",()=>{expect(i.isSupported()).toBe(!1)}),it("should emit a startDiscovering error",s=>{a(()=>{s("Should not emit any value")},r=>{expect(r).toBeInstanceOf(l.UsbHidTransportNotSupportedError),s()})})}),describe("When WebHID API is supported",()=>{const s=jest.fn(),r=jest.fn(),I=new w.Subject,E=new w.Subject;function f(t){I.next({device:t})}function b(t){E.next({device:t})}beforeEach(()=>{global.navigator={hid:{getDevices:s,requestDevice:r,addEventListener:(t,e)=>{t==="disconnect"?E.subscribe(e):t==="connect"&&I.subscribe(e)}}},g()}),afterEach(()=>{jest.restoreAllMocks(),global.navigator=void 0}),it("should support the transport",()=>{expect(i.isSupported()).toBe(!0)}),describe("startDiscovering",()=>{x.getAllDeviceModels().flatMap(e=>[{testTitle:`should emit device if user grants access through hid.requestDevice (${e.productName})`,hidDevice:(0,v.hidDeviceStubBuilder)({productId:e.usbProductId<<8,productName:e.productName}),expectedDeviceModel:e},{testTitle:`should emit device if user grants access through hid.requestDevice (${e.productName}, bootloader)`,hidDevice:(0,v.hidDeviceStubBuilder)({productId:e.bootloaderUsbProductId,productName:e.productName}),expectedDeviceModel:e}]).forEach(e=>{it(e.testTitle,c=>{r.mockResolvedValueOnce([e.hidDevice]),a(o=>{try{expect(o).toEqual(expect.objectContaining({deviceModel:e.expectedDeviceModel})),c()}catch(n){c(n)}},o=>{c(o)})})}),it("should emit devices if new grant accesses",e=>{r.mockResolvedValueOnce([d,{...d,productId:20497,productName:"Ledger Nano S Plus"}]);let c=0;a(o=>{try{switch(c){case 0:expect(o).toEqual(expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.NANO_X,productName:"Ledger Nano X",usbProductId:64})}));break;case 1:expect(o).toEqual(expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.NANO_SP,productName:"Ledger Nano S Plus",usbProductId:80})})),e();break}c++}catch(n){e(n)}},o=>{e(o)})}),it("should throw DeviceNotRecognizedError if the device is not recognized",e=>{r.mockResolvedValueOnce([{...d,productId:16962}]),a(()=>{e("should not return a device")},c=>{expect(c).toBeInstanceOf(l.DeviceNotRecognizedError),e()})}),it("should emit an error if the request device is in error",e=>{const c="request device error";r.mockImplementationOnce(()=>{throw new Error(c)}),a(()=>{e("should not return a device")},o=>{expect(o).toBeInstanceOf(l.NoAccessibleDeviceError),expect(o).toStrictEqual(new l.NoAccessibleDeviceError(new Error(c))),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=>{r.mockResolvedValueOnce([]),a(c=>{e(`Should not emit any value, but emitted ${JSON.stringify(c)}`)},c=>{try{expect(c).toBeInstanceOf(l.NoAccessibleDeviceError),e()}catch(o){e(o)}})}),it("should emit the same discoveredDevice object if its discovered twice in a row",async()=>{r.mockResolvedValue([d]),s.mockResolvedValue([d]);const e=await new Promise((o,n)=>{a(o,p=>n(p))}),c=await new Promise((o,n)=>{a(o,p=>n(p))});expect(c).toBe(e)})}),describe("destroy",()=>{it("should stop monitoring connections if the discovery process is halted",()=>{const t=jest.spyOn(AbortController.prototype,"abort");i.destroy(),expect(t).toHaveBeenCalled()})}),describe("connect",()=>{it("should throw UnknownDeviceError if no internal device",async()=>{const t={deviceId:"fake",onDisconnect:jest.fn()},e=await i.connect(t);expect(e).toStrictEqual((0,D.Left)(new l.UnknownDeviceError("Unknown device fake")))}),it("should throw OpeningConnectionError if the device is already opened",async()=>{const t={deviceId:"fake",onDisconnect:jest.fn()},e=await i.connect(t);expect(e).toStrictEqual((0,D.Left)(new l.UnknownDeviceError("Unknown device fake")))}),it("should throw OpeningConnectionError if the device cannot be opened",t=>{const e="cannot be opened",c={...d,open:()=>{throw new Error(e)}};r.mockResolvedValueOnce([c]),s.mockResolvedValue([c]),a(o=>{i.connect({deviceId:o.id,onDisconnect:jest.fn()}).then(n=>{expect(n).toStrictEqual((0,D.Left)(new l.OpeningConnectionError(new Error(e)))),t()}).catch(n=>{t(n)})},o=>{t(o)})}),it("should return the opened device",t=>{const e={...d,opened:!1,open:()=>(e.opened=!0,Promise.resolve())};r.mockResolvedValue([e]),s.mockResolvedValue([e]),a(c=>{i.connect({deviceId:c.id,onDisconnect:jest.fn()}).then(o=>{o.ifRight(n=>{expect(n).toEqual(expect.objectContaining({id:c.id})),t()}).ifLeft(()=>{t(o)})}).catch(o=>{t(o)})},c=>{t(c)})}),it("should return a device if available",t=>{r.mockResolvedValueOnce([d]),s.mockResolvedValue([d]),a(e=>{i.connect({deviceId:e.id,onDisconnect:jest.fn()}).then(c=>{c.ifRight(o=>{expect(o).toEqual(expect.objectContaining({id:e.id})),t()}).ifLeft(()=>{t(c)})}).catch(c=>{t(c)})},e=>{t(e)})})}),describe("disconnect",()=>{it("should throw an error if the device is not connected",async()=>{const t=(0,k.connectedDeviceStubBuilder)(),e=await i.disconnect({connectedDevice:t});expect(e).toStrictEqual((0,D.Left)(new l.UnknownDeviceError(`Unknown device ${t.id}`)))}),it("should disconnect if the device is connected",t=>{r.mockResolvedValueOnce([d]),a(e=>{i.connect({deviceId:e.id,onDisconnect:jest.fn()}).then(c=>{c.ifRight(o=>{i.disconnect({connectedDevice:o}).then(n=>{expect(n).toStrictEqual((0,D.Right)(void 0)),t()}).catch(n=>{t(n)})}).ifLeft(()=>{t(c)})}).catch(c=>{t(c)})},e=>{t(e)})}),it("should call disconnect handler if a connected device is unplugged",t=>{const e=jest.fn();r.mockResolvedValueOnce([d]),i.startDiscovering().subscribe({next:c=>{i.connect({deviceId:c.id,onDisconnect:e}).then(async()=>{b(d),expect(d.close).toHaveBeenCalled(),await Promise.resolve(),expect(e).not.toHaveBeenCalled(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT/2),expect(e).not.toHaveBeenCalled(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT/2),expect(e).toHaveBeenCalled(),t()}).catch(o=>{t(o)})}})})}),describe("reconnect",()=>{it("should stop disconnection if reconnection happen",t=>{const e=jest.fn(),c=(0,v.hidDeviceStubBuilder)(),o=(0,v.hidDeviceStubBuilder)();r.mockResolvedValueOnce([c]),s.mockResolvedValue([c,o]),a(async n=>{try{await i.connect({deviceId:n.id,onDisconnect:e}),b(c),expect(c.close).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT/3),f(o),expect(o.open).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT),expect(e).not.toHaveBeenCalled(),t()}catch(p){t(p)}})}),it("should be able to reconnect twice in a row if the device is unplugged and replugged twice",t=>{const e=jest.fn(),c=(0,v.hidDeviceStubBuilder)(),o=(0,v.hidDeviceStubBuilder)(),n=(0,v.hidDeviceStubBuilder)();r.mockResolvedValueOnce([c]),s.mockResolvedValue([c,o,n]),a(async p=>{await i.connect({deviceId:p.id,onDisconnect:e});try{b(c),expect(c.close).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT/3),f(o),expect(o.open).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT),expect(e).not.toHaveBeenCalled(),b(o),expect(o.close).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT/3),f(n),expect(n.open).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(m.RECONNECT_DEVICE_TIMEOUT),expect(e).not.toHaveBeenCalled(),t()}catch(H){t(H)}})})}),describe("Connection event typeguard",()=>{it("should validate type of an HIDConnectionEvent",()=>{const t={device:d},e=i.isHIDConnectionEvent(t);expect(e).toBe(!0)}),it("should not validate type of another event",()=>{const t=new Event("disconnect",{}),e=i.isHIDConnectionEvent(t);expect(e).toBe(!1)})}),describe("listenToKnownDevices",()=>{it("should emit the devices already connected before listening",async()=>{const t=(0,v.hidDeviceStubBuilder)();s.mockResolvedValue([t]);const e=jest.fn(),c=jest.fn();let o=[];i.listenToKnownDevices().subscribe({next:n=>{o=n},complete:e,error:c}),await h(),expect(o).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.NANO_X})})]),expect(e).not.toHaveBeenCalled(),expect(c).not.toHaveBeenCalled()}),it("should emit the new list of devices after connection and disconnection events",async()=>{g();const t=(0,v.hidDeviceStubBuilder)({productId:x.getDeviceModel({id:u.DeviceModelId.NANO_X}).usbProductId<<8}),e=(0,v.hidDeviceStubBuilder)({productId:x.getDeviceModel({id:u.DeviceModelId.STAX}).usbProductId<<8});s.mockResolvedValue([t]);const c=jest.fn(),o=jest.fn();let n=[];i.listenToKnownDevices().subscribe({next:p=>{n=p},complete:c,error:o}),await h(),expect(n).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.NANO_X})})]),s.mockResolvedValue([t,e]),f(e),await h(),expect(n).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.NANO_X})}),expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.STAX})})]),s.mockResolvedValue([e]),b(t),await h(),expect(n).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.STAX})})]),expect(c).not.toHaveBeenCalled(),expect(o).not.toHaveBeenCalled()}),it("should preserve DeviceId in case the device has been disconnected and reconnected before the timeout",async()=>{const t=(0,v.hidDeviceStubBuilder)();s.mockResolvedValue([t]);const e=jest.fn(),c=jest.fn();let o=[];i.listenToKnownDevices().subscribe({next:p=>{o=p},complete:e,error:c}),await h();const n=o[0]?.id;expect(n).toBeTruthy(),expect(o[0]?.deviceModel?.id).toBe(u.DeviceModelId.NANO_X),await i.connect({deviceId:o[0].id,onDisconnect:jest.fn()}),await h(),s.mockResolvedValue([]),b(t),await h(),expect(o).toEqual([]),s.mockResolvedValue([t]),f(t),await h(),expect(o).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.DeviceModelId.NANO_X})})]),expect(o[0]?.id).toBeTruthy(),expect(o[0]?.id).toBe(n)})})})});
+//# sourceMappingURL=WebUsbHidTransport.test.js.map

package/lib/cjs/src/internal/transport/usb/transport/WebUsbHidTransport.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/internal/transport/usb/transport/WebUsbHidTransport.test.ts"],
+  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\nimport { Subject } from \"rxjs\";\n\nimport { type DeviceModel, DeviceModelId } from \"@api/device/DeviceModel\";\nimport { StaticDeviceModelDataSource } from \"@internal/device-model/data/StaticDeviceModelDataSource\";\nimport { type InternalDeviceModel } from \"@internal/device-model/model/DeviceModel\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/DefaultLoggerPublisherService\";\nimport {\n  DeviceNotRecognizedError,\n  NoAccessibleDeviceError,\n  OpeningConnectionError,\n  UnknownDeviceError,\n  UsbHidTransportNotSupportedError,\n} from \"@internal/transport/model/Errors\";\nimport { connectedDeviceStubBuilder } from \"@internal/transport/model/InternalConnectedDevice.stub\";\nimport { type InternalDiscoveredDevice } from \"@internal/transport/model/InternalDiscoveredDevice\";\nimport { RECONNECT_DEVICE_TIMEOUT } from \"@internal/transport/usb/data/UsbHidConfig\";\nimport { hidDeviceStubBuilder } from \"@internal/transport/usb/model/HIDDevice.stub\";\nimport { usbHidDeviceConnectionFactoryStubBuilder } from \"@internal/transport/usb/service/UsbHidDeviceConnectionFactory.stub\";\n\nimport { WebUsbHidTransport } from \"./WebUsbHidTransport\";\n\njest.mock(\"@internal/logger-publisher/service/LoggerPublisherService\");\n\n// Our StaticDeviceModelDataSource can directly be used in our unit tests\nconst usbDeviceModelDataSource = new StaticDeviceModelDataSource();\nconst logger = new DefaultLoggerPublisherService([], \"web-usb-hid\");\n\nconst stubDevice: HIDDevice = hidDeviceStubBuilder();\n\n/**\n * Flushes all pending promises\n */\nconst flushPromises = () =>\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  new Promise(jest.requireActual(\"timers\").setImmediate);\n\ndescribe(\"WebUsbHidTransport\", () => {\n  let transport: WebUsbHidTransport;\n\n  function initializeTransport() {\n    transport = new WebUsbHidTransport(\n      usbDeviceModelDataSource,\n      () => logger,\n      usbHidDeviceConnectionFactoryStubBuilder(),\n    );\n  }\n\n  beforeEach(() => {\n    initializeTransport();\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 WebHID 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(UsbHidTransportNotSupportedError);\n          done();\n        },\n      );\n    });\n  });\n\n  describe(\"When WebHID API is supported\", () => {\n    const mockedGetDevices = jest.fn();\n    const mockedRequestDevice = jest.fn();\n\n    const connectionEventsSubject = new Subject<HIDConnectionEvent>();\n    const disconnectionEventsSubject = new Subject<HIDConnectionEvent>();\n\n    function emitHIDConnectionEvent(device: HIDDevice) {\n      connectionEventsSubject.next({\n        device,\n      } as HIDConnectionEvent);\n    }\n\n    function emitHIDDisconnectionEvent(device: HIDDevice) {\n      disconnectionEventsSubject.next({\n        device,\n      } as HIDConnectionEvent);\n    }\n\n    beforeEach(() => {\n      global.navigator = {\n        hid: {\n          getDevices: mockedGetDevices,\n          requestDevice: mockedRequestDevice,\n          addEventListener: (\n            eventName: string,\n            callback: (event: HIDConnectionEvent) => void,\n          ) => {\n            if (eventName === \"disconnect\") {\n              disconnectionEventsSubject.subscribe(callback);\n            } else if (eventName === \"connect\") {\n              connectionEventsSubject.subscribe(callback);\n            }\n          },\n        },\n      } as unknown as Navigator;\n      initializeTransport();\n    });\n\n    afterEach(() => {\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      const testCases = usbDeviceModelDataSource\n        .getAllDeviceModels()\n        .flatMap((deviceModel) => {\n          return [\n            {\n              testTitle: `should emit device if user grants access through hid.requestDevice (${deviceModel.productName})`,\n              hidDevice: hidDeviceStubBuilder({\n                productId: deviceModel.usbProductId << 8,\n                productName: deviceModel.productName,\n              }),\n              expectedDeviceModel: deviceModel,\n            },\n            {\n              testTitle: `should emit device if user grants access through hid.requestDevice (${deviceModel.productName}, bootloader)`,\n              hidDevice: hidDeviceStubBuilder({\n                productId: deviceModel.bootloaderUsbProductId,\n                productName: deviceModel.productName,\n              }),\n              expectedDeviceModel: deviceModel,\n            },\n          ];\n        });\n      testCases.forEach((testCase) => {\n        it(testCase.testTitle, (done) => {\n          mockedRequestDevice.mockResolvedValueOnce([testCase.hidDevice]);\n\n          discoverDevice(\n            (discoveredDevice) => {\n              try {\n                expect(discoveredDevice).toEqual(\n                  expect.objectContaining({\n                    deviceModel: testCase.expectedDeviceModel,\n                  }),\n                );\n\n                done();\n              } catch (expectError) {\n                done(expectError);\n              }\n            },\n            (error) => {\n              done(error);\n            },\n          );\n        });\n      });\n\n      // It does not seem possible for a user to select several devices on the browser popup.\n      // But if it was possible, we should emit them\n      it(\"should emit devices if new grant accesses\", (done) => {\n        mockedRequestDevice.mockResolvedValueOnce([\n          stubDevice,\n          {\n            ...stubDevice,\n            productId: 0x5011,\n            productName: \"Ledger Nano S Plus\",\n          },\n        ]);\n\n        let count = 0;\n        discoverDevice(\n          (discoveredDevice) => {\n            try {\n              switch (count) {\n                case 0:\n                  expect(discoveredDevice).toEqual(\n                    expect.objectContaining({\n                      deviceModel: expect.objectContaining({\n                        id: DeviceModelId.NANO_X,\n                        productName: \"Ledger Nano X\",\n                        usbProductId: 0x40,\n                      }) as DeviceModel,\n                    }),\n                  );\n                  break;\n                case 1:\n                  expect(discoveredDevice).toEqual(\n                    expect.objectContaining({\n                      deviceModel: expect.objectContaining({\n                        id: DeviceModelId.NANO_SP,\n                        productName: \"Ledger Nano S Plus\",\n                        usbProductId: 0x50,\n                      }) as DeviceModel,\n                    }),\n                  );\n\n                  done();\n                  break;\n              }\n\n              count++;\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          {\n            ...stubDevice,\n            productId: 0x4242,\n          },\n        ]);\n\n        discoverDevice(\n          () => {\n            done(\"should not return a device\");\n          },\n          (error) => {\n            expect(error).toBeInstanceOf(DeviceNotRecognizedError);\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      // [ASK] Is this the behavior we want when the user does not select any device ?\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        // When the user does not select any device, the `requestDevice` will return an empty array\n        mockedRequestDevice.mockResolvedValueOnce([]);\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(NoAccessibleDeviceError);\n              done();\n            } catch (expectError) {\n              done(expectError);\n            }\n          },\n        );\n      });\n\n      it(\"should emit the same discoveredDevice object if its discovered twice in a row\", async () => {\n        mockedRequestDevice.mockResolvedValue([stubDevice]);\n        mockedGetDevices.mockResolvedValue([stubDevice]);\n\n        const firstDiscoveredDevice = await new Promise((resolve, reject) => {\n          discoverDevice(resolve, (err) => reject(err));\n        });\n        const secondDiscoveredDevice = await new Promise((resolve, reject) => {\n          discoverDevice(resolve, (err) => reject(err));\n        });\n        expect(secondDiscoveredDevice).toBe(firstDiscoveredDevice);\n      });\n    });\n\n    describe(\"destroy\", () => {\n      it(\"should stop monitoring connections if the discovery process is halted\", () => {\n        const abortSpy = jest.spyOn(AbortController.prototype, \"abort\");\n\n        transport.destroy();\n\n        expect(abortSpy).toHaveBeenCalled();\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        const mockedDevice = {\n          ...stubDevice,\n          open: () => {\n            throw new Error(message);\n          },\n        };\n        mockedRequestDevice.mockResolvedValueOnce([mockedDevice]);\n        mockedGetDevices.mockResolvedValue([mockedDevice]);\n\n        discoverDevice(\n          (discoveredDevice) => {\n            transport\n              .connect({\n                deviceId: discoveredDevice.id,\n                onDisconnect: jest.fn(),\n              })\n              .then((value) => {\n                expect(value).toStrictEqual(\n                  Left(new OpeningConnectionError(new Error(message))),\n                );\n                done();\n              })\n              .catch((error) => {\n                done(error);\n              });\n          },\n          (error) => {\n            done(error);\n          },\n        );\n      });\n\n      it(\"should return the opened device\", (done) => {\n        const mockedDevice = {\n          ...stubDevice,\n          opened: false,\n          open: () => {\n            mockedDevice.opened = true;\n            return Promise.resolve();\n          },\n        };\n\n        mockedRequestDevice.mockResolvedValue([mockedDevice]);\n        mockedGetDevices.mockResolvedValue([mockedDevice]);\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        mockedGetDevices.mockResolvedValue([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 throw an error if the device is not connected\", async () => {\n        // given\n        const connectedDevice = connectedDeviceStubBuilder();\n\n        // when\n        const disconnect = await transport.disconnect({\n          connectedDevice,\n        });\n\n        expect(disconnect).toStrictEqual(\n          Left(new UnknownDeviceError(`Unknown device ${connectedDevice.id}`)),\n        );\n      });\n\n      it(\"should disconnect if the device is connected\", (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                    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                  .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 call disconnect handler if a connected device is unplugged\", (done) => {\n        // given\n        const onDisconnect = jest.fn();\n        mockedRequestDevice.mockResolvedValueOnce([stubDevice]);\n\n        // when\n        transport.startDiscovering().subscribe({\n          next: (discoveredDevice) => {\n            transport\n              .connect({\n                deviceId: discoveredDevice.id,\n                onDisconnect,\n              })\n              .then(async () => {\n                emitHIDDisconnectionEvent(stubDevice);\n\n                expect(stubDevice.close).toHaveBeenCalled();\n                await Promise.resolve(); // wait for the next tick so the stubDevice.close promise is resolved\n                expect(onDisconnect).not.toHaveBeenCalled();\n                jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT / 2);\n                expect(onDisconnect).not.toHaveBeenCalled();\n                jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT / 2);\n                expect(onDisconnect).toHaveBeenCalled();\n                done();\n              })\n              .catch((error) => {\n                done(error);\n              });\n          },\n        });\n      });\n    });\n\n    describe(\"reconnect\", () => {\n      it(\"should stop disconnection if reconnection happen\", (done) => {\n        // given\n        const onDisconnect = jest.fn();\n\n        const hidDevice1 = hidDeviceStubBuilder();\n        const hidDevice2 = hidDeviceStubBuilder();\n\n        mockedRequestDevice.mockResolvedValueOnce([hidDevice1]);\n        mockedGetDevices.mockResolvedValue([hidDevice1, hidDevice2]);\n\n        discoverDevice(async (discoveredDevice) => {\n          try {\n            await transport.connect({\n              deviceId: discoveredDevice.id,\n              onDisconnect,\n            });\n\n            /* Disconnection */\n            emitHIDDisconnectionEvent(hidDevice1);\n            expect(hidDevice1.close).toHaveBeenCalled();\n            await Promise.resolve(); // wait for the next tick so the hidDevice1.close promise is resolved\n\n            jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT / 3);\n\n            /* Reconnection */\n            emitHIDConnectionEvent(hidDevice2);\n\n            expect(hidDevice2.open).toHaveBeenCalled();\n            await Promise.resolve(); // wait for the next tick so the hidDevice2.open promise is resolved\n            jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);\n            expect(onDisconnect).not.toHaveBeenCalled();\n            done();\n          } catch (error) {\n            done(error);\n          }\n        });\n      });\n\n      it(\"should be able to reconnect twice in a row if the device is unplugged and replugged twice\", (done) => {\n        // given\n        const onDisconnect = jest.fn();\n\n        const hidDevice1 = hidDeviceStubBuilder();\n        const hidDevice2 = hidDeviceStubBuilder();\n        const hidDevice3 = hidDeviceStubBuilder();\n\n        mockedRequestDevice.mockResolvedValueOnce([hidDevice1]);\n        mockedGetDevices.mockResolvedValue([\n          hidDevice1,\n          hidDevice2,\n          hidDevice3,\n        ]);\n\n        // when\n        discoverDevice(async (discoveredDevice) => {\n          await transport.connect({\n            deviceId: discoveredDevice.id,\n            onDisconnect,\n          });\n          try {\n            /* First disconnection */\n            emitHIDDisconnectionEvent(hidDevice1);\n            expect(hidDevice1.close).toHaveBeenCalled();\n            await Promise.resolve(); // wait for the next tick so the hidDevice1.close promise is resolved\n            jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT / 3);\n\n            /* First reconnection */\n            emitHIDConnectionEvent(hidDevice2);\n\n            expect(hidDevice2.open).toHaveBeenCalled();\n            await Promise.resolve(); // wait for the next tick so the hidDevice2.open promise is resolved\n            jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);\n            expect(onDisconnect).not.toHaveBeenCalled();\n\n            /* Second disconnection */\n            emitHIDDisconnectionEvent(hidDevice2);\n            expect(hidDevice2.close).toHaveBeenCalled();\n            await Promise.resolve(); // wait for the next tick so the hidDevice2.close promise is resolved\n            jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT / 3);\n\n            /* Second reconnection */\n            emitHIDConnectionEvent(hidDevice3);\n\n            expect(hidDevice3.open).toHaveBeenCalled();\n            await Promise.resolve(); // wait for the next tick so the hidDevice3.open promise is resolved\n            jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);\n            expect(onDisconnect).not.toHaveBeenCalled();\n\n            done();\n          } catch (error) {\n            done(error);\n          }\n        });\n      });\n    });\n    describe(\"Connection event typeguard\", () => {\n      it(\"should validate type of an HIDConnectionEvent\", () => {\n        // given\n        const event = {\n          device: stubDevice,\n        } as HIDConnectionEvent;\n        // when\n        // @ts-expect-error trying to access private member\n        const result = transport.isHIDConnectionEvent(event);\n        // then\n        expect(result).toBe(true);\n      });\n      it(\"should not validate type of another event\", () => {\n        // given\n        const event = new Event(\"disconnect\", {});\n        // when\n        // @ts-expect-error trying to access private member\n        const result = transport.isHIDConnectionEvent(event);\n        // then\n        expect(result).toBe(false);\n      });\n    });\n\n    describe(\"listenToKnownDevices\", () => {\n      it(\"should emit the devices already connected before listening\", async () => {\n        // given\n        const hidDevice = hidDeviceStubBuilder();\n        mockedGetDevices.mockResolvedValue([hidDevice]);\n\n        const onComplete = jest.fn();\n        const onError = jest.fn();\n\n        let observedDevices: InternalDiscoveredDevice[] = [];\n        // when\n        transport.listenToKnownDevices().subscribe({\n          next: (knownDevices) => {\n            observedDevices = knownDevices;\n          },\n          complete: onComplete,\n          error: onError,\n        });\n\n        await flushPromises();\n\n        expect(observedDevices).toEqual([\n          expect.objectContaining({\n            deviceModel: expect.objectContaining({\n              id: DeviceModelId.NANO_X,\n            }) as InternalDeviceModel,\n          }),\n        ]);\n        expect(onComplete).not.toHaveBeenCalled();\n        expect(onError).not.toHaveBeenCalled();\n      });\n\n      it(\"should emit the new list of devices after connection and disconnection events\", async () => {\n        initializeTransport();\n        // given\n        const hidDevice1 = hidDeviceStubBuilder({\n          productId:\n            usbDeviceModelDataSource.getDeviceModel({\n              id: DeviceModelId.NANO_X,\n            }).usbProductId << 8,\n        });\n        const hidDevice2 = hidDeviceStubBuilder({\n          productId:\n            usbDeviceModelDataSource.getDeviceModel({ id: DeviceModelId.STAX })\n              .usbProductId << 8,\n        });\n        mockedGetDevices.mockResolvedValue([hidDevice1]);\n\n        const onComplete = jest.fn();\n        const onError = jest.fn();\n\n        let observedDevices: InternalDiscoveredDevice[] = [];\n        // when\n        transport.listenToKnownDevices().subscribe({\n          next: (knownDevices) => {\n            observedDevices = knownDevices;\n          },\n          complete: onComplete,\n          error: onError,\n        });\n\n        await flushPromises();\n\n        expect(observedDevices).toEqual([\n          expect.objectContaining({\n            deviceModel: expect.objectContaining({\n              id: DeviceModelId.NANO_X,\n            }) as InternalDeviceModel,\n          }),\n        ]);\n\n        // When a new device is connected\n        mockedGetDevices.mockResolvedValue([hidDevice1, hidDevice2]);\n        emitHIDConnectionEvent(hidDevice2);\n        await flushPromises();\n\n        expect(observedDevices).toEqual([\n          expect.objectContaining({\n            deviceModel: expect.objectContaining({\n              id: DeviceModelId.NANO_X,\n            }) as InternalDeviceModel,\n          }),\n          expect.objectContaining({\n            deviceModel: expect.objectContaining({\n              id: DeviceModelId.STAX,\n            }) as InternalDeviceModel,\n          }),\n        ]);\n\n        // When a device is disconnected\n        mockedGetDevices.mockResolvedValue([hidDevice2]);\n        emitHIDDisconnectionEvent(hidDevice1);\n        await flushPromises();\n\n        expect(observedDevices).toEqual([\n          expect.objectContaining({\n            deviceModel: expect.objectContaining({\n              id: DeviceModelId.STAX,\n            }) as InternalDeviceModel,\n          }),\n        ]);\n\n        expect(onComplete).not.toHaveBeenCalled();\n        expect(onError).not.toHaveBeenCalled();\n      });\n\n      it(\"should preserve DeviceId in case the device has been disconnected and reconnected before the timeout\", async () => {\n        // given\n        const hidDevice = hidDeviceStubBuilder();\n\n        mockedGetDevices.mockResolvedValue([hidDevice]);\n\n        const onComplete = jest.fn();\n        const onError = jest.fn();\n        let observedDevices: InternalDiscoveredDevice[] = [];\n        // when\n        transport.listenToKnownDevices().subscribe({\n          next: (knownDevices) => {\n            observedDevices = knownDevices;\n          },\n          complete: onComplete,\n          error: onError,\n        });\n\n        await flushPromises();\n\n        const firstObservedDeviceId = observedDevices[0]?.id;\n        expect(firstObservedDeviceId).toBeTruthy();\n        expect(observedDevices[0]?.deviceModel?.id).toBe(DeviceModelId.NANO_X);\n\n        // Start a connection with the device\n        await transport.connect({\n          deviceId: observedDevices[0]!.id,\n          onDisconnect: jest.fn(),\n        });\n        await flushPromises();\n\n        // When the device is disconnected\n        mockedGetDevices.mockResolvedValue([]);\n        emitHIDDisconnectionEvent(hidDevice);\n        await flushPromises();\n\n        expect(observedDevices).toEqual([]);\n\n        // When the device is reconnected\n        mockedGetDevices.mockResolvedValue([hidDevice]);\n        emitHIDConnectionEvent(hidDevice);\n        await flushPromises();\n\n        expect(observedDevices).toEqual([\n          expect.objectContaining({\n            deviceModel: expect.objectContaining({\n              id: DeviceModelId.NANO_X,\n            }) as InternalDeviceModel,\n          }),\n        ]);\n\n        expect(observedDevices[0]?.id).toBeTruthy();\n        expect(observedDevices[0]?.id).toBe(firstObservedDeviceId);\n      });\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["import_purify_ts", "import_rxjs", "import_DeviceModel", "import_StaticDeviceModelDataSource", "import_DefaultLoggerPublisherService", "import_Errors", "import_InternalConnectedDevice", "import_UsbHidConfig", "import_HIDDevice", "import_UsbHidDeviceConnectionFactory", "import_WebUsbHidTransport", "usbDeviceModelDataSource", "logger", "stubDevice", "flushPromises", "transport", "initializeTransport", "discoverDevice", "onSuccess", "onError", "done", "error", "mockedGetDevices", "mockedRequestDevice", "connectionEventsSubject", "disconnectionEventsSubject", "emitHIDConnectionEvent", "device", "emitHIDDisconnectionEvent", "eventName", "callback", "deviceModel", "testCase", "discoveredDevice", "expectError", "count", "message", "firstDiscoveredDevice", "resolve", "reject", "err", "secondDiscoveredDevice", "abortSpy", "connectParams", "connect", "mockedDevice", "value", "connectedDevice", "disconnect", "onDisconnect", "hidDevice1", "hidDevice2", "hidDevice3", "event", "result", "hidDevice", "onComplete", "observedDevices", "knownDevices", "firstObservedDeviceId"]
+}

package/lib/cjs/src/internal/transport/usb/transport/__mocks__/WebUsbHidTransport.js

@@ -0,0 +1,2 @@
+"use strict";var r=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var p=(t,e)=>{for(var s in e)r(t,s,{get:e[s],enumerable:!0})},j=(t,e,s,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of f(e))!c.call(t,n)&&n!==s&&r(t,n,{get:()=>e[n],enumerable:!(o=i(e,n))||o.enumerable});return t};var a=t=>j(r({},"__esModule",{value:!0}),t);var g={};p(g,{WebUsbHidTransport:()=>d,usbHidTransportMockBuilder:()=>T});module.exports=a(g);class d{isSupported=jest.fn();getIdentifier=jest.fn();connect=jest.fn();startDiscovering=jest.fn();stopDiscovering=jest.fn();disconnect=jest.fn();listenToKnownDevices=jest.fn()}function T(t={}){return{isSupported:jest.fn(),getIdentifier:jest.fn(),startDiscovering:jest.fn(),stopDiscovering:jest.fn(),connect:jest.fn(),disconnect:jest.fn(),listenToKnownDevices:jest.fn(),...t}}0&&(module.exports={WebUsbHidTransport,usbHidTransportMockBuilder});
+//# sourceMappingURL=WebUsbHidTransport.js.map

package/lib/cjs/src/internal/transport/usb/transport/__mocks__/WebUsbHidTransport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../src/internal/transport/usb/transport/__mocks__/WebUsbHidTransport.ts"],
+  "sourcesContent": ["import { type Transport } from \"@api/transport/model/Transport\";\n\nexport class WebUsbHidTransport implements Transport {\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  listenToKnownDevices = 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": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,EAAA,+BAAAC,IAAA,eAAAC,EAAAJ,GAEO,MAAME,CAAwC,CACnD,YAAc,KAAK,GAAG,EACtB,cAAgB,KAAK,GAAG,EACxB,QAAU,KAAK,GAAG,EAClB,iBAAmB,KAAK,GAAG,EAC3B,gBAAkB,KAAK,GAAG,EAE1B,WAAa,KAAK,GAAG,EACrB,qBAAuB,KAAK,GAAG,CACjC,CAEO,SAASC,EACdE,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": ["WebUsbHidTransport_exports", "__export", "WebUsbHidTransport", "usbHidTransportMockBuilder", "__toCommonJS", "props"]
+}

package/lib/esm/index.js

@@ -1,2 +1,2 @@
-export * from "./src";
-//# sourceMappingURL=index.js.map
+export*from"./src";
+//# sourceMappingURL=index.js.map

package/lib/esm/index.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../index.ts"],
+  "sourcesContent": ["export * from \"./src\";\n"],
+  "mappings": "AAAA,WAAc",
+  "names": []
+}

package/lib/esm/package.json

@@ -1,67 +1,64 @@
 {
-    "name": "@ledgerhq/device-management-kit",
-    "version": "0.4.0",
-    "license": "MIT",
-    "exports": {
-        ".": {
-            "import": "./lib/esm/index.js",
-            "require": "./lib/cjs/index.js",
-            "default": "./index.ts",
-            "types": "./lib/esm/index.d.ts"
-        },
-        "./*.js": {
-            "import": "./lib/esm/*.js",
-            "require": "./lib/cjs/*.js",
-            "default": "./*.js",
-            "types": "./lib/esm/*.d.ts"
-        },
-        "./*": {
-            "import": "./lib/esm/*",
-            "require": "./lib/cjs/*",
-            "default": "./*",
-            "types": "./lib/esm/*"
-        }
+  "name": "@ledgerhq/device-management-kit",
+  "version": "0.5.0",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
     },
-    "files": [
-        "./lib"
-    ],
-    "scripts": {
-        "build": "rimraf lib && zx scripts/build.mjs",
-        "dev": "concurrently \"pnpm dev:esm\" \"pnpm dev:cjs\"",
-        "dev:esm": "concurrently \"tsc --watch -p tsconfig.esm.json\" \"tsc-alias --watch -p tsconfig.esm.json\"",
-        "dev:cjs": "concurrently \"tsc --watch -p tsconfig.cjs.json\" \"tsc-alias --watch -p tsconfig.cjs.json\"",
-        "lint": "eslint",
-        "lint:fix": "pnpm lint --fix",
-        "postpack": "find . -name '*.tgz' -exec cp {} ../../dist/ \\; ",
-        "prettier": "prettier . --check",
-        "prettier:fix": "prettier . --write",
-        "test": "jest",
-        "test:watch": "pnpm test -- --watch",
-        "test:coverage": "pnpm test -- --coverage",
-        "typecheck": "tsc --noEmit",
-        "module:create": "pnpm hygen core-module with-prompt"
-    },
-    "dependencies": {
-        "@sentry/minimal": "^6.19.7",
-        "@statelyai/inspect": "^0.4.0",
-        "axios": "^1.7.7",
-        "inversify": "^6.0.2",
-        "inversify-logger-middleware": "^3.1.0",
-        "purify-ts": "^2.1.0",
-        "reflect-metadata": "^0.2.2",
-        "rxjs": "^7.8.1",
-        "semver": "^7.6.3",
-        "uuid": "^10.0.0",
-        "xstate": "^5.18.2"
-    },
-    "devDependencies": {
-        "@ledgerhq/eslint-config-dsdk": "workspace:*",
-        "@ledgerhq/jest-config-dsdk": "workspace:*",
-        "@ledgerhq/prettier-config-dsdk": "workspace:*",
-        "@ledgerhq/tsconfig-dsdk": "workspace:*",
-        "@types/semver": "^7.5.8",
-        "@types/uuid": "^10.0.0",
-        "@types/w3c-web-hid": "^1.0.6",
-        "ts-node": "^10.9.2"
+    "./*": {
+      "types": "./lib/types/*",
+      "import": "./lib/esm/*",
+      "require": "./lib/cjs/*"
     }
+  },
+  "files": [
+    "./lib",
+    "package.json"
+  ],
+  "scripts": {
+    "prebuild": "rimraf lib",
+    "build": "pnpm lmdk-build --entryPoints index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
+    "dev": "concurrently \"pnpm watch:builds\" \"pnpm watch:types\"",
+    "watch:builds": "pnpm lmdk-watch --entryPoints index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
+    "watch:types": "concurrently \"tsc --watch -p tsconfig.prod.json\" \"tsc-alias --watch -p tsconfig.prod.json\"",
+    "lint": "eslint",
+    "lint:fix": "pnpm lint --fix",
+    "postpack": "find . -name '*.tgz' -exec cp {} ../../dist/ \\; ",
+    "prettier": "prettier . --check",
+    "prettier:fix": "prettier . --write",
+    "test": "jest",
+    "test:watch": "pnpm test -- --watch",
+    "test:coverage": "pnpm test -- --coverage",
+    "typecheck": "tsc --noEmit",
+    "module:create": "pnpm hygen core-module with-prompt"
+  },
+  "dependencies": {
+    "@ledgerhq/device-transport-kit-mock-client": "workspace:*",
+    "@sentry/minimal": "^6.19.7",
+    "@statelyai/inspect": "^0.4.0",
+    "axios": "^1.7.7",
+    "inversify": "^6.0.3",
+    "inversify-logger-middleware": "^3.1.0",
+    "purify-ts": "^2.1.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "semver": "^7.6.3",
+    "uuid": "^10.0.0",
+    "xstate": "^5.18.2"
+  },
+  "devDependencies": {
+    "@ledgerhq/esbuild-tools": "workspace:*",
+    "@ledgerhq/eslint-config-dsdk": "workspace:*",
+    "@ledgerhq/jest-config-dsdk": "workspace:*",
+    "@ledgerhq/prettier-config-dsdk": "workspace:*",
+    "@ledgerhq/tsconfig-dsdk": "workspace:*",
+    "@types/semver": "^7.5.8",
+    "@types/uuid": "^10.0.0",
+    "@types/w3c-web-hid": "^1.0.6",
+    "@types/web-bluetooth": "^0.0.20",
+    "ts-node": "^10.9.2"
+  }
 }

package/lib/esm/src/api/DeviceManagementKit.js

@@ -0,0 +1,2 @@
+import{commandTypes as c}from"./command/di/commandTypes";import{configTypes as a}from"../internal/config/di/configTypes";import{deviceSessionTypes as s}from"../internal/device-session/di/deviceSessionTypes";import{discoveryTypes as t}from"../internal/discovery/di/discoveryTypes";import{sendTypes as C}from"../internal/send/di/sendTypes";import{makeContainer as m}from"../../src/di";import{deviceActionTypes as p}from"./device-action/di/deviceActionTypes";class A{container;constructor({stub:e,transports:n,customTransports:o,loggers:i,config:r}={}){this.container=m({stub:e,transports:n,customTransports:o,loggers:i,config:r})}getVersion(){return this.container.get(a.GetDmkVersionUseCase).getDmkVersion()}startDiscovering(e){return this.container.get(t.StartDiscoveringUseCase).execute(e)}stopDiscovering(){return this.container.get(t.StopDiscoveringUseCase).execute()}listenToKnownDevices(){return this.container.get(t.ListenToKnownDevicesUseCase).execute()}connect(e){return this.container.get(t.ConnectUseCase).execute(e)}disconnect(e){return this.container.get(t.DisconnectUseCase).execute(e)}sendApdu(e){return this.container.get(C.SendApduUseCase).execute(e)}sendCommand(e){return this.container.get(c.SendCommandUseCase).execute(e)}executeDeviceAction(e){return this.container.get(p.ExecuteDeviceActionUseCase).execute(e)}getConnectedDevice(e){return this.container.get(t.GetConnectedDeviceUseCase).execute(e)}getDeviceSessionState(e){return this.container.get(s.GetDeviceSessionStateUseCase).execute(e)}close(){return this.container.get(s.CloseSessionsUseCase).execute()}listConnectedDevices(){return this.container.get(t.ListConnectedDevicesUseCase).execute()}listenToConnectedDevice(){return this.container.get(t.ListenToConnectedDeviceUseCase).execute()}}export{A as DeviceManagementKit};
+//# sourceMappingURL=DeviceManagementKit.js.map

package/lib/esm/src/api/DeviceManagementKit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/DeviceManagementKit.ts"],
+  "sourcesContent": ["import { type Container } from \"inversify\";\nimport { type Observable } from \"rxjs\";\n\nimport { commandTypes } from \"@api/command/di/commandTypes\";\nimport { type CommandResult } from \"@api/command/model/CommandResult\";\nimport {\n  type SendCommandUseCase,\n  type SendCommandUseCaseArgs,\n} from \"@api/command/use-case/SendCommandUseCase\";\nimport {\n  type ExecuteDeviceActionUseCase,\n  type ExecuteDeviceActionUseCaseArgs,\n} from \"@api/device-action/use-case/ExecuteDeviceActionUseCase\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { type DeviceSessionState } from \"@api/device-session/DeviceSessionState\";\nimport { type DeviceSessionId } from \"@api/device-session/types\";\nimport { type ConnectedDevice } from \"@api/transport/model/ConnectedDevice\";\nimport {\n  type ConnectUseCaseArgs,\n  type DisconnectUseCaseArgs,\n  type DiscoveredDevice,\n  type GetConnectedDeviceUseCaseArgs,\n  type SendApduUseCaseArgs,\n  type StartDiscoveringUseCaseArgs,\n} from \"@api/types\";\nimport { configTypes } from \"@internal/config/di/configTypes\";\nimport { type GetDmkVersionUseCase } from \"@internal/config/use-case/GetDmkVersionUseCase\";\nimport { deviceSessionTypes } from \"@internal/device-session/di/deviceSessionTypes\";\nimport { type CloseSessionsUseCase } from \"@internal/device-session/use-case/CloseSessionsUseCase\";\nimport { type GetDeviceSessionStateUseCase } from \"@internal/device-session/use-case/GetDeviceSessionStateUseCase\";\nimport { discoveryTypes } from \"@internal/discovery/di/discoveryTypes\";\nimport { type ConnectUseCase } from \"@internal/discovery/use-case/ConnectUseCase\";\nimport { type DisconnectUseCase } from \"@internal/discovery/use-case/DisconnectUseCase\";\nimport { type GetConnectedDeviceUseCase } from \"@internal/discovery/use-case/GetConnectedDeviceUseCase\";\nimport { type ListConnectedDevicesUseCase } from \"@internal/discovery/use-case/ListConnectedDevicesUseCase\";\nimport { type ListenToConnectedDeviceUseCase } from \"@internal/discovery/use-case/ListenToConnectedDeviceUseCase\";\nimport { type ListenToKnownDevicesUseCase } from \"@internal/discovery/use-case/ListenToKnownDevicesUseCase\";\nimport type { StartDiscoveringUseCase } from \"@internal/discovery/use-case/StartDiscoveringUseCase\";\nimport type { StopDiscoveringUseCase } from \"@internal/discovery/use-case/StopDiscoveringUseCase\";\nimport { sendTypes } from \"@internal/send/di/sendTypes\";\nimport { type SendApduUseCase } from \"@internal/send/use-case/SendApduUseCase\";\nimport { makeContainer, type MakeContainerProps } from \"@root/src/di\";\n\nimport {\n  type DeviceActionIntermediateValue,\n  type ExecuteDeviceActionReturnType,\n} from \"./device-action/DeviceAction\";\nimport { deviceActionTypes } from \"./device-action/di/deviceActionTypes\";\nimport { type DmkError } from \"./Error\";\n\n/**\n * The main class to interact with the Device Management Kit.\n *\n * NB: do not instantiate this class directly, instead, use `LedgerDMKBuilder`.\n */\nexport class DeviceManagementKit {\n  readonly container: Container;\n  /** @internal */\n  constructor({\n    stub,\n    transports,\n    customTransports,\n    loggers,\n    config,\n  }: Partial<MakeContainerProps> = {}) {\n    // NOTE: MakeContainerProps might not be the exact type here\n    // For the init of the project this is sufficient, but we might need to\n    // update the constructor arguments as we go (we might have more than just the container config)\n    this.container = makeContainer({\n      stub,\n      transports,\n      customTransports,\n      loggers,\n      config,\n    });\n  }\n\n  /**\n   * Returns a promise resolving to the version of the SDK.\n   */\n  getVersion(): Promise<string> {\n    return this.container\n      .get<GetDmkVersionUseCase>(configTypes.GetDmkVersionUseCase)\n      .getDmkVersion();\n  }\n\n  /**\n   * Starts discovering devices connected.\n   *\n   * For the WeHID implementation, this use-case needs to be called as a result\n   * of an user interaction (button \"click\" event for ex).\n   *\n   * @param {StartDiscoveringUseCaseArgs} args - The transport to use for discover, or undefined to discover from all transports.\n   * @returns {Observable<DiscoveredDevice>} An observable of discovered devices.\n   */\n  startDiscovering(\n    args: StartDiscoveringUseCaseArgs,\n  ): Observable<DiscoveredDevice> {\n    return this.container\n      .get<StartDiscoveringUseCase>(discoveryTypes.StartDiscoveringUseCase)\n      .execute(args);\n  }\n\n  /**\n   * Stops discovering devices connected.\n   */\n  stopDiscovering() {\n    return this.container\n      .get<StopDiscoveringUseCase>(discoveryTypes.StopDiscoveringUseCase)\n      .execute();\n  }\n\n  /**\n   * Listen to list of known discovered devices (and later BLE).\n   *\n   * @returns {Observable<DiscoveredDevice[]>} An observable of known discovered devices.\n   */\n  listenToKnownDevices(): Observable<DiscoveredDevice[]> {\n    return this.container\n      .get<ListenToKnownDevicesUseCase>(\n        discoveryTypes.ListenToKnownDevicesUseCase,\n      )\n      .execute();\n  }\n\n  /**\n   * Connects to a device previously discovered with `DeviceManagementKit.startDiscovering`.\n   * Creates a new device session which:\n   * - Represents the connection to the device.\n   * - Is terminated upon disconnection of the device.\n   * - Exposes the device state through an observable (see `DeviceManagementKit.getDeviceSessionState`)\n   * - Should be used for all subsequent communication with the device.\n   *\n   * @param {ConnectUseCaseArgs} args - The device ID (obtained in discovery) to connect to.\n   * @returns The session ID to use for further communication with the device.\n   */\n  connect(args: ConnectUseCaseArgs): Promise<DeviceSessionId> {\n    return this.container\n      .get<ConnectUseCase>(discoveryTypes.ConnectUseCase)\n      .execute(args);\n  }\n\n  /**\n   * Disconnects to a discovered device.\n   *\n   * @param {DisconnectUseCaseArgs} args - The session ID to disconnect.\n   */\n  disconnect(args: DisconnectUseCaseArgs): Promise<void> {\n    return this.container\n      .get<DisconnectUseCase>(discoveryTypes.DisconnectUseCase)\n      .execute(args);\n  }\n\n  /**\n   * Sends an APDU command to a device through a device session.\n   *\n   * @param {SendApduUseCaseArgs} args - The device session ID and APDU command to send.\n   */\n  sendApdu(args: SendApduUseCaseArgs): Promise<ApduResponse> {\n    return this.container\n      .get<SendApduUseCase>(sendTypes.SendApduUseCase)\n      .execute(args);\n  }\n\n  /**\n   * Sends a command to a device through a device session.\n   *\n   * @param {SendCommandUseCaseArgs<Response, Args, ErrorCodes>} args - The device session ID, command, command error codes and command parameters to send.\n   * @returns A promise resolving with the response from the command.\n   */\n  sendCommand<Response, Args, ErrorCodes>(\n    args: SendCommandUseCaseArgs<Response, Args, ErrorCodes>,\n  ): Promise<CommandResult<Response, ErrorCodes>> {\n    return this.container\n      .get<SendCommandUseCase>(commandTypes.SendCommandUseCase)\n      .execute(args);\n  }\n\n  executeDeviceAction<\n    Output,\n    Input,\n    Error extends DmkError,\n    IntermediateValue extends DeviceActionIntermediateValue,\n  >(\n    args: ExecuteDeviceActionUseCaseArgs<\n      Output,\n      Input,\n      Error,\n      IntermediateValue\n    >,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> {\n    return this.container\n      .get<ExecuteDeviceActionUseCase>(\n        deviceActionTypes.ExecuteDeviceActionUseCase,\n      )\n      .execute(args);\n  }\n\n  /**\n   * Gets the connected from its device session ID.\n   *\n   * @param {GetConnectedDeviceUseCaseArgs} args - The device session ID.\n   * @returns {ConnectedDevice} The connected device.\n   */\n  getConnectedDevice(args: GetConnectedDeviceUseCaseArgs): ConnectedDevice {\n    return this.container\n      .get<GetConnectedDeviceUseCase>(discoveryTypes.GetConnectedDeviceUseCase)\n      .execute(args);\n  }\n\n  /**\n   * Gets the device state of a session.\n   *\n   * @param {{DeviceSessionId}} args - The device session ID.\n   * @returns {Observable<DeviceSessionState>} An observable of the session device state.\n   */\n  getDeviceSessionState(args: {\n    sessionId: DeviceSessionId;\n  }): Observable<DeviceSessionState> {\n    return this.container\n      .get<GetDeviceSessionStateUseCase>(\n        deviceSessionTypes.GetDeviceSessionStateUseCase,\n      )\n      .execute(args);\n  }\n\n  /**\n   * Close the Device Management kit.\n   *\n   */\n  close() {\n    return this.container\n      .get<CloseSessionsUseCase>(deviceSessionTypes.CloseSessionsUseCase)\n      .execute();\n  }\n\n  /**\n   * Lists all connected devices.\n   *\n   * @returns {ConnectedDevice[]} The list of device sessions.\n   */\n  listConnectedDevices(): ConnectedDevice[] {\n    return this.container\n      .get<ListConnectedDevicesUseCase>(\n        discoveryTypes.ListConnectedDevicesUseCase,\n      )\n      .execute();\n  }\n\n  /**\n   * Listen to connected device.\n   *\n   * @returns {Observable<ConnectedDevice>} An observable of connected device.\n   */\n  listenToConnectedDevice(): Observable<ConnectedDevice> {\n    return this.container\n      .get<ListenToConnectedDeviceUseCase>(\n        discoveryTypes.ListenToConnectedDeviceUseCase,\n      )\n      .execute();\n  }\n}\n"],
+  "mappings": "AAGA,OAAS,gBAAAA,MAAoB,+BAsB7B,OAAS,eAAAC,MAAmB,kCAE5B,OAAS,sBAAAC,MAA0B,iDAGnC,OAAS,kBAAAC,MAAsB,wCAS/B,OAAS,aAAAC,MAAiB,8BAE1B,OAAS,iBAAAC,MAA8C,eAMvD,OAAS,qBAAAC,MAAyB,uCAQ3B,MAAMC,CAAoB,CACtB,UAET,YAAY,CACV,KAAAC,EACA,WAAAC,EACA,iBAAAC,EACA,QAAAC,EACA,OAAAC,CACF,EAAiC,CAAC,EAAG,CAInC,KAAK,UAAYP,EAAc,CAC7B,KAAAG,EACA,WAAAC,EACA,iBAAAC,EACA,QAAAC,EACA,OAAAC,CACF,CAAC,CACH,CAKA,YAA8B,CAC5B,OAAO,KAAK,UACT,IAA0BX,EAAY,oBAAoB,EAC1D,cAAc,CACnB,CAWA,iBACEY,EAC8B,CAC9B,OAAO,KAAK,UACT,IAA6BV,EAAe,uBAAuB,EACnE,QAAQU,CAAI,CACjB,CAKA,iBAAkB,CAChB,OAAO,KAAK,UACT,IAA4BV,EAAe,sBAAsB,EACjE,QAAQ,CACb,CAOA,sBAAuD,CACrD,OAAO,KAAK,UACT,IACCA,EAAe,2BACjB,EACC,QAAQ,CACb,CAaA,QAAQU,EAAoD,CAC1D,OAAO,KAAK,UACT,IAAoBV,EAAe,cAAc,EACjD,QAAQU,CAAI,CACjB,CAOA,WAAWA,EAA4C,CACrD,OAAO,KAAK,UACT,IAAuBV,EAAe,iBAAiB,EACvD,QAAQU,CAAI,CACjB,CAOA,SAASA,EAAkD,CACzD,OAAO,KAAK,UACT,IAAqBT,EAAU,eAAe,EAC9C,QAAQS,CAAI,CACjB,CAQA,YACEA,EAC8C,CAC9C,OAAO,KAAK,UACT,IAAwBb,EAAa,kBAAkB,EACvD,QAAQa,CAAI,CACjB,CAEA,oBAMEA,EAMiE,CACjE,OAAO,KAAK,UACT,IACCP,EAAkB,0BACpB,EACC,QAAQO,CAAI,CACjB,CAQA,mBAAmBA,EAAsD,CACvE,OAAO,KAAK,UACT,IAA+BV,EAAe,yBAAyB,EACvE,QAAQU,CAAI,CACjB,CAQA,sBAAsBA,EAEa,CACjC,OAAO,KAAK,UACT,IACCX,EAAmB,4BACrB,EACC,QAAQW,CAAI,CACjB,CAMA,OAAQ,CACN,OAAO,KAAK,UACT,IAA0BX,EAAmB,oBAAoB,EACjE,QAAQ,CACb,CAOA,sBAA0C,CACxC,OAAO,KAAK,UACT,IACCC,EAAe,2BACjB,EACC,QAAQ,CACb,CAOA,yBAAuD,CACrD,OAAO,KAAK,UACT,IACCA,EAAe,8BACjB,EACC,QAAQ,CACb,CACF",
+  "names": ["commandTypes", "configTypes", "deviceSessionTypes", "discoveryTypes", "sendTypes", "makeContainer", "deviceActionTypes", "DeviceManagementKit", "stub", "transports", "customTransports", "loggers", "config", "args"]
+}

package/lib/esm/src/api/DeviceManagementKit.test.js

@@ -0,0 +1,2 @@
+import{StubLocalConfigDataSource as c}from"../internal/config/data/LocalConfigDataSource.stub";import{configTypes as a}from"../internal/config/di/configTypes";import{deviceSessionTypes as r}from"../internal/device-session/di/deviceSessionTypes";import{discoveryTypes as t}from"../internal/discovery/di/discoveryTypes";import{sendTypes as d}from"../internal/send/di/sendTypes";import m from"../../package.json";import{StubUseCase as p}from"../../src/di.stub";import{commandTypes as u}from"./command/di/commandTypes";import{ConsoleLogger as f}from"./logger-subscriber/service/ConsoleLogger";import{DeviceManagementKit as o}from"./DeviceManagementKit";jest.mock("./logger-subscriber/service/ConsoleLogger");let e,n;describe("DeviceManagementKit",()=>{describe("clean",()=>{beforeEach(()=>{n=new f,e=new o({stub:!1,loggers:[n],config:{managerApiUrl:"http://fake.url",mockUrl:"http://fake-mock.url"}})}),it("should create an instance",()=>{expect(e).toBeDefined(),expect(e).toBeInstanceOf(o)}),it("should return a clean `version`",async()=>{expect(await e.getVersion()).toBe(m.version)}),it("should have startDiscovery method",()=>{expect(e.startDiscovering).toBeDefined()}),it("should have stopDiscovery method",()=>{expect(e.stopDiscovering).toBeDefined()}),it("should have connect method",()=>{expect(e.connect).toBeDefined()}),it("should have sendApdu method",()=>{expect(e.sendApdu).toBeDefined()}),it("should have getConnectedDevice method",()=>{expect(e.getConnectedDevice).toBeDefined()}),it("should have sendCommand method",()=>{expect(e.sendCommand).toBeDefined()}),it("should have listConnectedDevices method",()=>{expect(e.listConnectedDevices).toBeDefined()}),it("should have listenToConnectedDevice method",()=>{expect(e.listenToConnectedDevice).toBeDefined()})}),describe("stubbed",()=>{beforeEach(()=>{e=new o({stub:!0,loggers:[],config:{managerApiUrl:"http://fake.url",mockUrl:"http://fake-mock.url"}})}),it("should create a stubbed dmk",()=>{expect(e).toBeDefined(),expect(e).toBeInstanceOf(o)}),it("should return a stubbed config",()=>{expect(e.container.get(a.LocalConfigDataSource)).toBeInstanceOf(c)}),it("should return a stubbed version",async()=>{expect(await e.getVersion()).toBe("0.0.0-stub.1")}),it.each([[t.StartDiscoveringUseCase],[t.StopDiscoveringUseCase],[t.ConnectUseCase],[d.SendApduUseCase],[u.SendCommandUseCase],[t.GetConnectedDeviceUseCase],[t.DisconnectUseCase],[r.GetDeviceSessionStateUseCase],[t.ListConnectedDevicesUseCase],[t.ListenToConnectedDeviceUseCase]])("should have %p use case",i=>{const s=e.container.get(i);expect(s).toBeInstanceOf(p),expect(s.execute()).toBe("stub")})})});
+//# sourceMappingURL=DeviceManagementKit.test.js.map

package/lib/esm/src/api/DeviceManagementKit.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/DeviceManagementKit.test.ts"],
+  "sourcesContent": ["import { type interfaces } from \"inversify\";\n\nimport { type LocalConfigDataSource } from \"@internal/config/data/ConfigDataSource\";\nimport { StubLocalConfigDataSource } from \"@internal/config/data/LocalConfigDataSource.stub\";\nimport { configTypes } from \"@internal/config/di/configTypes\";\nimport { deviceSessionTypes } from \"@internal/device-session/di/deviceSessionTypes\";\nimport { discoveryTypes } from \"@internal/discovery/di/discoveryTypes\";\nimport { sendTypes } from \"@internal/send/di/sendTypes\";\nimport pkg from \"@root/package.json\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandTypes } from \"./command/di/commandTypes\";\nimport { ConsoleLogger } from \"./logger-subscriber/service/ConsoleLogger\";\nimport { DeviceManagementKit } from \"./DeviceManagementKit\";\n\njest.mock(\"./logger-subscriber/service/ConsoleLogger\");\n\nlet dmk: DeviceManagementKit;\nlet logger: ConsoleLogger;\ndescribe(\"DeviceManagementKit\", () => {\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      logger = new ConsoleLogger();\n      dmk = new DeviceManagementKit({\n        stub: false,\n        loggers: [logger],\n        config: {\n          managerApiUrl: \"http://fake.url\",\n          mockUrl: \"http://fake-mock.url\",\n        },\n      });\n    });\n\n    it(\"should create an instance\", () => {\n      expect(dmk).toBeDefined();\n      expect(dmk).toBeInstanceOf(DeviceManagementKit);\n    });\n\n    it(\"should return a clean `version`\", async () => {\n      expect(await dmk.getVersion()).toBe(pkg.version);\n    });\n\n    it(\"should have startDiscovery method\", () => {\n      expect(dmk.startDiscovering).toBeDefined();\n    });\n\n    it(\"should have stopDiscovery method\", () => {\n      expect(dmk.stopDiscovering).toBeDefined();\n    });\n\n    it(\"should have connect method\", () => {\n      expect(dmk.connect).toBeDefined();\n    });\n\n    it(\"should have sendApdu method\", () => {\n      expect(dmk.sendApdu).toBeDefined();\n    });\n\n    it(\"should have getConnectedDevice method\", () => {\n      expect(dmk.getConnectedDevice).toBeDefined();\n    });\n\n    it(\"should have sendCommand method\", () => {\n      expect(dmk.sendCommand).toBeDefined();\n    });\n\n    it(\"should have listConnectedDevices method\", () => {\n      expect(dmk.listConnectedDevices).toBeDefined();\n    });\n\n    it(\"should have listenToConnectedDevice method\", () => {\n      expect(dmk.listenToConnectedDevice).toBeDefined();\n    });\n  });\n\n  describe(\"stubbed\", () => {\n    beforeEach(() => {\n      dmk = new DeviceManagementKit({\n        stub: true,\n        loggers: [],\n        config: {\n          managerApiUrl: \"http://fake.url\",\n          mockUrl: \"http://fake-mock.url\",\n        },\n      });\n    });\n\n    it(\"should create a stubbed dmk\", () => {\n      expect(dmk).toBeDefined();\n      expect(dmk).toBeInstanceOf(DeviceManagementKit);\n    });\n\n    it(\"should return a stubbed config\", () => {\n      expect(\n        dmk.container.get<LocalConfigDataSource>(\n          configTypes.LocalConfigDataSource,\n        ),\n      ).toBeInstanceOf(StubLocalConfigDataSource);\n    });\n\n    it(\"should return a stubbed version\", async () => {\n      expect(await dmk.getVersion()).toBe(\"0.0.0-stub.1\");\n    });\n\n    it.each([\n      [discoveryTypes.StartDiscoveringUseCase],\n      [discoveryTypes.StopDiscoveringUseCase],\n      [discoveryTypes.ConnectUseCase],\n      [sendTypes.SendApduUseCase],\n      [commandTypes.SendCommandUseCase],\n      [discoveryTypes.GetConnectedDeviceUseCase],\n      [discoveryTypes.DisconnectUseCase],\n      [deviceSessionTypes.GetDeviceSessionStateUseCase],\n      [discoveryTypes.ListConnectedDevicesUseCase],\n      [discoveryTypes.ListenToConnectedDeviceUseCase],\n    ])(\n      \"should have %p use case\",\n      (diSymbol: interfaces.ServiceIdentifier<StubUseCase>) => {\n        const uc = dmk.container.get<StubUseCase>(diSymbol);\n        expect(uc).toBeInstanceOf(StubUseCase);\n        expect(uc.execute()).toBe(\"stub\");\n      },\n    );\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["StubLocalConfigDataSource", "configTypes", "deviceSessionTypes", "discoveryTypes", "sendTypes", "pkg", "StubUseCase", "commandTypes", "ConsoleLogger", "DeviceManagementKit", "dmk", "logger", "diSymbol", "uc"]
+}

package/lib/esm/src/api/DeviceManagementKitBuilder.js

@@ -0,0 +1,2 @@
+import{DEFAULT_MANAGER_API_BASE_URL as t,DEFAULT_MOCK_SERVER_BASE_URL as e}from"../internal/manager-api/model/Const";import{DeviceManagementKit as i}from"./DeviceManagementKit";class a{stub=!1;loggers=[];transports=[];customTransports=[];config={managerApiUrl:t,mockUrl:e};build(){return new i({stub:this.stub,transports:this.transports,customTransports:this.customTransports,loggers:this.loggers,config:this.config})}setStub(r){return this.stub=r,this}addTransport(r){return this.transports.push(r),this}addCustomTransport(r){return this.customTransports.push(r),this}addLogger(r){return this.loggers.push(r),this}addConfig(r){return this.config={...this.config,...r},this}}export{a as DeviceManagementKitBuilder};
+//# sourceMappingURL=DeviceManagementKitBuilder.js.map

package/lib/esm/src/api/DeviceManagementKitBuilder.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/DeviceManagementKitBuilder.ts"],
+  "sourcesContent": ["import {\n  DEFAULT_MANAGER_API_BASE_URL,\n  DEFAULT_MOCK_SERVER_BASE_URL,\n} from \"@internal/manager-api/model/Const\";\n\nimport { type LoggerSubscriberService } from \"./logger-subscriber/service/LoggerSubscriberService\";\nimport { type Transport } from \"./transport/model/Transport\";\nimport { type BuiltinTransports } from \"./transport/model/TransportIdentifier\";\nimport { DeviceManagementKit } from \"./DeviceManagementKit\";\nimport { type DmkConfig } from \"./DmkConfig\";\n\n/**\n * Builder for the `DeviceManagementKit` class.\n *\n * @example\n * ```\n * const dmk = new LedgerDeviceManagementKitBuilder()\n *  .setStub(false)\n *  .addTransport(BuiltinTransports.USB)\n *  .addCustomTransport(new MyTransport())\n *  .addLogger(myLogger)\n *  .build();\n * ```\n */\nexport class DeviceManagementKitBuilder {\n  private stub = false;\n  private readonly loggers: LoggerSubscriberService[] = [];\n  private readonly transports: BuiltinTransports[] = [];\n  private readonly customTransports: Transport[] = [];\n  private config: DmkConfig = {\n    managerApiUrl: DEFAULT_MANAGER_API_BASE_URL,\n    mockUrl: DEFAULT_MOCK_SERVER_BASE_URL,\n  };\n\n  build(): DeviceManagementKit {\n    return new DeviceManagementKit({\n      stub: this.stub,\n      transports: this.transports,\n      customTransports: this.customTransports,\n      loggers: this.loggers,\n      config: this.config,\n    });\n  }\n\n  setStub(stubbed: boolean): DeviceManagementKitBuilder {\n    this.stub = stubbed;\n    return this;\n  }\n\n  addTransport(transport: BuiltinTransports): DeviceManagementKitBuilder {\n    this.transports.push(transport);\n    return this;\n  }\n\n  addCustomTransport(transport: Transport): DeviceManagementKitBuilder {\n    this.customTransports.push(transport);\n    return this;\n  }\n\n  /**\n   * Add a logger to the SDK that will receive its logs\n   */\n  addLogger(logger: LoggerSubscriberService): DeviceManagementKitBuilder {\n    this.loggers.push(logger);\n    return this;\n  }\n\n  addConfig(config: Partial<DmkConfig>): DeviceManagementKitBuilder {\n    this.config = {\n      ...this.config,\n      ...config,\n    };\n    return this;\n  }\n}\n"],
+  "mappings": "AAAA,OACE,gCAAAA,EACA,gCAAAC,MACK,oCAKP,OAAS,uBAAAC,MAA2B,wBAgB7B,MAAMC,CAA2B,CAC9B,KAAO,GACE,QAAqC,CAAC,EACtC,WAAkC,CAAC,EACnC,iBAAgC,CAAC,EAC1C,OAAoB,CAC1B,cAAeH,EACf,QAASC,CACX,EAEA,OAA6B,CAC3B,OAAO,IAAIC,EAAoB,CAC7B,KAAM,KAAK,KACX,WAAY,KAAK,WACjB,iBAAkB,KAAK,iBACvB,QAAS,KAAK,QACd,OAAQ,KAAK,MACf,CAAC,CACH,CAEA,QAAQE,EAA8C,CACpD,YAAK,KAAOA,EACL,IACT,CAEA,aAAaC,EAA0D,CACrE,YAAK,WAAW,KAAKA,CAAS,EACvB,IACT,CAEA,mBAAmBA,EAAkD,CACnE,YAAK,iBAAiB,KAAKA,CAAS,EAC7B,IACT,CAKA,UAAUC,EAA6D,CACrE,YAAK,QAAQ,KAAKA,CAAM,EACjB,IACT,CAEA,UAAUC,EAAwD,CAChE,YAAK,OAAS,CACZ,GAAG,KAAK,OACR,GAAGA,CACL,EACO,IACT,CACF",
+  "names": ["DEFAULT_MANAGER_API_BASE_URL", "DEFAULT_MOCK_SERVER_BASE_URL", "DeviceManagementKit", "DeviceManagementKitBuilder", "stubbed", "transport", "logger", "config"]
+}

package/lib/esm/src/api/DeviceManagementKitBuilder.test.js

@@ -0,0 +1,2 @@
+import{ConsoleLogger as i}from"./logger-subscriber/service/ConsoleLogger";import{DeviceManagementKit as r}from"./DeviceManagementKit";import{DeviceManagementKitBuilder as g}from"./DeviceManagementKitBuilder";jest.mock("./logger-subscriber/service/ConsoleLogger");let e,t;describe("LedgerDeviceManagementKitBuilder",()=>{beforeEach(()=>{e=new g}),it("should build a DeviceManagementKit instance",()=>{const o=e.build();expect(o).toBeInstanceOf(r)}),it("should set the stub flag",()=>{e.setStub(!0),expect(e.stub).toBe(!0)}),it("should add a logger",()=>{t=new i,e.addLogger(t),expect(e.loggers).toContain(t)})});
+//# sourceMappingURL=DeviceManagementKitBuilder.test.js.map