@ledgerhq/device-management-kit 0.5.0 → 0.6.0

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

@@ -1,7 +0,0 @@
-{
-  "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": ["Left", "Right", "defaultApduReceiverServiceStubBuilder", "defaultApduSenderServiceStubBuilder", "DefaultLoggerPublisherService", "ReconnectionFailedError", "RECONNECT_DEVICE_TIMEOUT", "hidDeviceStubBuilder", "UsbHidDeviceConnection", "RESPONSE_LOCKED_DEVICE", "RESPONSE_SUCCESS", "flushPromises", "device", "apduSender", "apduReceiver", "onConnectionTerminated", "deviceId", "logger", "tag", "cDevice", "response", "connection", "hasResolved", "responsePromise"]
-}

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

@@ -1,2 +0,0 @@
-var y=Object.defineProperty;var _=Object.getOwnPropertyDescriptor;var u=(s,e,i,t)=>{for(var n=t>1?void 0:t?_(e,i):e,r=s.length-1,c;r>=0;r--)(c=s[r])&&(n=(t?c(e,i,n):c(n))||n);return t&&n&&y(e,i,n),n},a=(s,e)=>(i,t)=>e(i,t,s);import*as d from"@sentry/minimal";import{inject as g,injectable as C}from"inversify";import{EitherAsync as m,Left as D,Maybe as f,Right as p}from"purify-ts";import{BehaviorSubject as H,from as b,map as w,switchMap as S}from"rxjs";import{v4 as P}from"uuid";import{BuiltinTransports as A}from"../../../../api/transport/model/TransportIdentifier";import{deviceModelTypes as T}from"../../../device-model/di/deviceModelTypes";import{loggerTypes as M}from"../../../logger-publisher/di/loggerTypes";import{DeviceNotRecognizedError as U,NoAccessibleDeviceError as h,OpeningConnectionError as L,UnknownDeviceError as E,UsbHidTransportNotSupportedError as B}from"../../../transport/model/Errors";import{InternalConnectedDevice as R}from"../../../transport/model/InternalConnectedDevice";import{LEDGER_VENDOR_ID as I}from"../../../transport/usb/data/UsbHidConfig";import{usbDiTypes as x}from"../../../transport/usb/di/usbDiTypes";let l=class{constructor(e,i,t){this.deviceModelDataSource=e;this._logger=i("WebUsbHidTransport"),this._usbHidDeviceConnectionFactory=t,this.startListeningToConnectionEvents()}_internalDiscoveredDevices=new H([]);_deviceConnectionsByHidDevice=new Map;_deviceConnectionsPendingReconnection=new Set;_connectionListenersAbortController=new AbortController;_logger;_usbHidDeviceConnectionFactory;connectionType="USB";identifier=A.USB;get hidApi(){return this.isSupported()?p(navigator.hid):D(new B("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 m.liftEither(this.hidApi).map(async e=>{try{return(await e.getDevices()).filter(t=>t.vendorId===I)}catch(i){const t=new h(i);throw this._logger.error("getDevices: error getting devices",{data:{error:i}}),d.captureException(t),t}}).run()}mapHIDDeviceToInternalDiscoveredDevice(e){const i=this._internalDiscoveredDevices.getValue().find(r=>r.hidDevice===e);if(i)return i;const t=this._deviceConnectionsByHidDevice.get(e);return this.getDeviceModel(e).caseOf({Just:r=>{const c=t?.deviceId??P(),o={id:c,deviceModel:r,hidDevice:e,transport:this.identifier};return this._logger.debug(`Discovered device ${c} ${o.deviceModel.productName}`),o},Nothing:()=>{throw this._logger.warn(`Device not recognized: hidDevice.productId: 0x${e.productId.toString(16)}`),new U(`Device not recognized: hidDevice.productId: 0x${e.productId.toString(16)}`)}})}listenToKnownDevices(){return this.updateInternalDiscoveredDevices(),this._internalDiscoveredDevices.pipe(w(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}}),d.captureException(i)},Right:i=>{this._internalDiscoveredDevices.next(i.map(t=>this.mapHIDDeviceToInternalDiscoveredDevice(t)))}})}async promptDeviceAccess(){return m.liftEither(this.hidApi).map(async e=>{let i=[];try{i=await e.requestDevice({filters:[{vendorId:I}]}),await this.updateInternalDiscoveredDevices()}catch(n){const r=new h(n);throw this._logger.error("promptDeviceAccess: error requesting device",{data:{error:n}}),d.captureException(r),r}if(this._logger.debug(`promptDeviceAccess: hidDevices len ${i.length}`),i.length===0)throw this._logger.warn("No device was selected"),new h("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"),b(this.promptDeviceAccess()).pipe(S(e=>e.caseOf({Left:i=>{throw this._logger.error("Error while getting accessible device",{data:{error:i}}),d.captureException(i),i},Right:i=>{this._logger.info(`Got access to ${i.length} HID devices`);const t=i.map(n=>this.mapHIDDeviceToInternalDiscoveredDevice(n));return b(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(o=>o.id===e);if(!t)return this._logger.error(`Unknown device ${e}`),D(new E(`Unknown device ${e}`));try{if(this._deviceConnectionsByHidDevice.get(t.hidDevice))throw new Error("Device already opened");await t.hidDevice.open()}catch(o){if(o instanceof DOMException&&o.name==="InvalidStateError")this._logger.debug(`Device ${e} is already opened`);else{const v=new L(o);return this._logger.debug(`Error while opening device: ${e}`,{data:{error:o}}),d.captureException(v),D(v)}}const{deviceModel:n}=t,r=this._usbHidDeviceConnectionFactory.create(t.hidDevice,{onConnectionTerminated:()=>{i(e),this._deviceConnectionsPendingReconnection.delete(r),this._deviceConnectionsByHidDevice.delete(t.hidDevice),r.device.close()},deviceId:e});this._deviceConnectionsByHidDevice.set(t.hidDevice,r);const c=new R({sendApdu:(o,v)=>r.sendApdu(o,v),deviceModel:n,id:e,type:this.connectionType,transport:this.identifier});return p(c)}getDeviceModel(e){const{productId:i}=e,t=this.deviceModelDataSource.getAllDeviceModels().find(n=>n.usbProductId===i>>8||n.bootloaderUsbProductId===i);return t?f.of(t):f.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(p(void 0))):(this._logger.error("No matching device connection found",{data:{connectedDevice:e}}),Promise.resolve(D(new E(`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()}};l=u([C(),a(0,g(T.DeviceModelDataSource)),a(1,g(M.LoggerPublisherServiceFactory)),a(2,g(x.UsbHidDeviceConnectionFactory))],l);export{l as WebUsbHidTransport};
-//# sourceMappingURL=WebUsbHidTransport.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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": "iOAAA,UAAYA,MAAY,kBACxB,OAAS,UAAAC,EAAQ,cAAAC,MAAkB,YACnC,OAAiB,eAAAC,EAAa,QAAAC,EAAM,SAAAC,EAAO,SAAAC,MAAa,YACxD,OAAS,mBAAAC,EAAiB,QAAAC,EAAM,OAAAC,EAAiB,aAAAC,MAAiB,OAClE,OAAS,MAAMC,MAAY,OAM3B,OACE,qBAAAC,MAEK,2CAEP,OAAS,oBAAAC,MAAwB,6CAEjC,OAAS,eAAAC,MAAmB,4CAG5B,OAEE,4BAAAC,EACA,2BAAAC,EACA,0BAAAC,EAEA,sBAAAC,EACA,oCAAAC,MACK,mCACP,OAAS,2BAAAC,MAA+B,oDAExC,OAAS,oBAAAC,MAAwB,4CACjC,OAAS,cAAAC,MAAkB,wCASpB,IAAMC,EAAN,KAA8C,CA2BnD,YAEUC,EAERC,EAEAC,EACA,CALQ,2BAAAF,EAMR,KAAK,QAAUC,EAAqB,oBAAoB,EACxD,KAAK,+BAAiCC,EAEtC,KAAK,iCAAiC,CACxC,CArCQ,2BAEJ,IAAIC,EAA0D,CAAC,CAAC,EAG5D,8BAGJ,IAAI,IAMA,sCACN,IAAI,IAGE,oCACN,IAAI,gBACE,QACA,+BACS,eAAiC,MACjC,WAAkCC,EAAkB,IAoBrE,IAAY,QAAwD,CAClE,OAAI,KAAK,YAAY,EACZC,EAAM,UAAU,GAAG,EAGrBC,EAAK,IAAIC,EAAiC,sBAAsB,CAAC,CAC1E,CAEA,aAAc,CACZ,GAAI,CACF,MAAMC,EAAS,CAAC,CAAC,WAAW,IAC5B,YAAK,QAAQ,MAAM,gBAAgBA,CAAM,EAAE,EACpCA,CACT,OAASC,EAAO,CACd,YAAK,QAAQ,MAAM,qBAAsB,CAAE,KAAM,CAAE,MAAAA,CAAM,CAAE,CAAC,EACrD,EACT,CACF,CAEA,eAAqC,CACnC,OAAO,KAAK,UACd,CAOA,MAAc,YAAqD,CACjE,OAAOC,EAAY,WAAW,KAAK,MAAM,EACtC,IAAI,MAAOC,GAAW,CACrB,GAAI,CAEF,OADmB,MAAMA,EAAO,WAAW,GACzB,OACfC,GAAcA,EAAU,WAAaC,CACxC,CACF,OAASJ,EAAO,CACd,MAAMK,EAAc,IAAIC,EAAwBN,CAAK,EACrD,WAAK,QAAQ,MAAM,oCAAqC,CACtD,KAAM,CAAE,MAAAA,CAAM,CAChB,CAAC,EACDO,EAAO,iBAAiBF,CAAW,EAC7BA,CACR,CACF,CAAC,EACA,IAAI,CACT,CAKQ,uCACNF,EACmC,CACnC,MAAMK,EAA2B,KAAK,2BACnC,SAAS,EACT,KAAMC,GAAmBA,EAAe,YAAcN,CAAS,EAElE,GAAIK,EACF,OAAOA,EAGT,MAAME,EACJ,KAAK,8BAA8B,IAAIP,CAAS,EAGlD,OADyB,KAAK,eAAeA,CAAS,EAC9B,OAAO,CAC7B,KAAOQ,GAAgB,CACrB,MAAMC,EAAKF,GAA0B,UAAYG,EAAK,EAEhDC,EAAmB,CACvB,GAAAF,EACA,YAAAD,EACA,UAAAR,EACA,UAAW,KAAK,UAClB,EAEA,YAAK,QAAQ,MACX,qBAAqBS,CAAE,IAAIE,EAAiB,YAAY,WAAW,EACrE,EAEOA,CACT,EACA,QAAS,IAAM,CAEb,WAAK,QAAQ,KACX,iDAAiDX,EAAU,UAAU,SAAS,EAAE,CAAC,EACnF,EACM,IAAIY,EACR,iDAAiDZ,EAAU,UAAU,SAAS,EAAE,CAAC,EACnF,CACF,CACF,CAAC,CACH,CAKO,sBAA+D,CACpE,YAAK,gCAAgC,EAC9B,KAAK,2BAA2B,KACrCa,EAAKC,GAAYA,EAAQ,IAAI,CAAC,CAAE,UAAAd,EAAW,GAAGe,CAAO,IAAMA,CAAM,CAAC,CACpE,CACF,CAEA,MAAc,iCAAiD,EACvC,MAAM,KAAK,WAAW,GAC9B,OAAO,CACnB,KAAOlB,GAAU,CACf,KAAK,QAAQ,MAAM,wCAAyC,CAC1D,KAAM,CAAE,MAAAA,CAAM,CAChB,CAAC,EACDO,EAAO,iBAAiBP,CAAK,CAC/B,EACA,MAAQmB,GAAe,CACrB,KAAK,2BAA2B,KAC9BA,EAAW,IAAKhB,GACd,KAAK,uCAAuCA,CAAS,CACvD,CACF,CACF,CACF,CAAC,CACH,CAMA,MAAc,oBAEZ,CACA,OAAOF,EAAY,WAAW,KAAK,MAAM,EACtC,IAAI,MAAOC,GAAW,CAErB,IAAIiB,EAA0B,CAAC,EAE/B,GAAI,CACFA,EAAa,MAAMjB,EAAO,cAAc,CACtC,QAAS,CAAC,CAAE,SAAUE,CAAiB,CAAC,CAC1C,CAAC,EACD,MAAM,KAAK,gCAAgC,CAC7C,OAASJ,EAAO,CACd,MAAMK,EAAc,IAAIC,EAAwBN,CAAK,EACrD,WAAK,QAAQ,MAAM,8CAA+C,CAChE,KAAM,CAAE,MAAAA,CAAM,CAChB,CAAC,EACDO,EAAO,iBAAiBF,CAAW,EAC7BA,CACR,CAOA,GALA,KAAK,QAAQ,MACX,sCAAsCc,EAAW,MAAM,EACzD,EAGIA,EAAW,SAAW,EACxB,WAAK,QAAQ,KAAK,wBAAwB,EACpC,IAAIb,EAAwB,oBAAoB,EAGxD,MAAMc,EAAoC,CAAC,EAE3C,UAAWjB,KAAagB,EACtBC,EAAqB,KAAKjB,CAAS,EAEnC,KAAK,QAAQ,MAAM,sCAAuC,CACxD,KAAM,CAAE,UAAAA,CAAU,CACpB,CAAC,EAGH,OAAOiB,CACT,CAAC,EACA,IAAI,CACT,CAEA,kBAAyD,CACvD,YAAK,QAAQ,MAAM,kBAAkB,EAE9BC,EAAK,KAAK,mBAAmB,CAAC,EAAE,KACrCC,EAAWC,GACFA,EAAO,OAAO,CACnB,KAAOvB,GAAU,CACf,WAAK,QAAQ,MAAM,wCAAyC,CAC1D,KAAM,CAAE,MAAAA,CAAM,CAChB,CAAC,EACDO,EAAO,iBAAiBP,CAAK,EACvBA,CACR,EACA,MAAQmB,GAAe,CACrB,KAAK,QAAQ,KAAK,iBAAiBA,EAAW,MAAM,cAAc,EAElE,MAAMK,EAAoBL,EAAW,IAAKhB,GACjC,KAAK,uCAAuCA,CAAS,CAC7D,EACD,OAAOkB,EAAKG,CAAiB,CAC/B,CACF,CAAC,CACF,CACH,CACF,CAEA,iBAAwB,CAKxB,CAEQ,kCAAyC,CAC/C,KAAK,QAAQ,MAAM,kCAAkC,EAErD,KAAK,OAAO,IAAKtB,GAAW,CAC1BA,EAAO,iBACL,UACCuB,GAAU,KAAK,4BAA4BA,CAAK,EACjD,CAAE,OAAQ,KAAK,oCAAoC,MAAO,CAC5D,EAEAvB,EAAO,iBACL,aACCuB,GAAU,CACT,KAAK,+BAA+BA,CAAK,CAC3C,EACA,CAAE,OAAQ,KAAK,oCAAoC,MAAO,CAC5D,CACF,CAAC,CACH,CAEQ,iCAAwC,CAC9C,KAAK,QAAQ,MAAM,iCAAiC,EACpD,KAAK,oCAAoC,MAAM,CACjD,CAKA,MAAM,QAAQ,CACZ,SAAAC,EACA,aAAAC,CACF,EAG2D,CACzD,KAAK,QAAQ,MAAM,UAAW,CAAE,KAAM,CAAE,SAAAD,CAAS,CAAE,CAAC,EAEpD,MAAME,EAAyB,KAAK,2BACjC,SAAS,EACT,KAAMnB,GAAmBA,EAAe,KAAOiB,CAAQ,EAE1D,GAAI,CAACE,EACH,YAAK,QAAQ,MAAM,kBAAkBF,CAAQ,EAAE,EACxC7B,EAAK,IAAIgC,EAAmB,kBAAkBH,CAAQ,EAAE,CAAC,EAGlE,GAAI,CACF,GACE,KAAK,8BAA8B,IAAIE,EAAuB,SAAS,EAEvE,MAAM,IAAI,MAAM,uBAAuB,EAEzC,MAAMA,EAAuB,UAAU,KAAK,CAC9C,OAAS5B,EAAO,CACd,GAAIA,aAAiB,cAAgBA,EAAM,OAAS,oBAClD,KAAK,QAAQ,MAAM,UAAU0B,CAAQ,oBAAoB,MACpD,CACL,MAAMI,EAAkB,IAAIC,EAAuB/B,CAAK,EACxD,YAAK,QAAQ,MAAM,+BAA+B0B,CAAQ,GAAI,CAC5D,KAAM,CAAE,MAAA1B,CAAM,CAChB,CAAC,EACDO,EAAO,iBAAiBuB,CAAe,EAChCjC,EAAKiC,CAAe,CAC7B,CACF,CAEA,KAAM,CAAE,YAAAnB,CAAY,EAAIiB,EAElBI,EAAmB,KAAK,+BAA+B,OAC3DJ,EAAuB,UACvB,CACE,uBAAwB,IAAM,CAC5BD,EAAaD,CAAQ,EACrB,KAAK,sCAAsC,OAAOM,CAAgB,EAClE,KAAK,8BAA8B,OACjCJ,EAAuB,SACzB,EACAI,EAAiB,OAAO,MAAM,CAChC,EACA,SAAAN,CACF,CACF,EAEA,KAAK,8BAA8B,IACjCE,EAAuB,UACvBI,CACF,EACA,MAAMC,EAAkB,IAAIC,EAAwB,CAClD,SAAU,CAACC,EAAMC,IACfJ,EAAiB,SAASG,EAAMC,CAAqB,EACvD,YAAAzB,EACA,GAAIe,EACJ,KAAM,KAAK,eACX,UAAW,KAAK,UAClB,CAAC,EACD,OAAO9B,EAAMqC,CAAe,CAC9B,CAEQ,eAAe9B,EAAkD,CACvE,KAAM,CAAE,UAAAkC,CAAU,EAAIlC,EAChBmC,EAAgB,KAAK,sBAAsB,mBAAmB,EAAE,KACnE3B,GAECA,EAAY,eAAiB0B,GAAa,GAC1C1B,EAAY,yBAA2B0B,CAC3C,EACA,OAAOC,EAAgBC,EAAM,GAAGD,CAAa,EAAIC,EAAM,KAAK,CAC9D,CAEQ,mBAAmBpC,EAA8B,CACvD,OAAO,KAAK,eAAeA,CAAS,EAAE,OAAO,CAC3C,KAAOQ,GAAgBA,EAAY,aACnC,QAAS,IAAMR,EAAU,WAAa,CACxC,CAAC,CACH,CAKA,MAAM,WAAWqC,EAEmB,CAClC,KAAK,QAAQ,MAAM,aAAc,CAAE,KAAM,CAAE,gBAAiBA,CAAO,CAAE,CAAC,EAEtE,MAAMC,EAA2B,MAAM,KACrC,KAAK,8BAA8B,OAAO,CAC5C,EAAE,KACCT,GACCA,EAAiB,WAAaQ,EAAO,gBAAgB,EACzD,EAEA,OAAKC,GAWLA,EAAyB,WAAW,EAC7B,QAAQ,QAAQ7C,EAAM,MAAS,CAAC,IAXrC,KAAK,QAAQ,MAAM,sCAAuC,CACxD,KAAM,CAAE,gBAAiB4C,CAAO,CAClC,CAAC,EACM,QAAQ,QACb3C,EACE,IAAIgC,EAAmB,kBAAkBW,EAAO,gBAAgB,EAAE,EAAE,CACtE,CACF,EAKJ,CAOQ,qBAAqBf,EAA2C,CACtE,MACE,WAAYA,GACZ,OAAOA,EAAM,QAAW,UACxBA,EAAM,SAAW,MACjB,cAAeA,EAAM,QACrB,OAAOA,EAAM,OAAO,WAAc,QAEtC,CAMA,MAAc,+BAA+BA,EAAc,CACzD,GAAI,CAAC,KAAK,qBAAqBA,CAAK,EAAG,CACrC,KAAK,QAAQ,MAAM,gBAAiB,CAAE,KAAM,CAAE,MAAAA,CAAM,CAAE,CAAC,EACvD,MACF,CAEA,KAAK,QAAQ,KAAK,uDAAwD,CACxE,KAAM,CAAE,MAAAA,CAAM,CAChB,CAAC,EAED,KAAK,gCAAgC,EAErC,GAAI,CACF,MAAMA,EAAM,OAAO,MAAM,CAC3B,OAASzB,EAAO,CACd,KAAK,QAAQ,MAAM,8BAA+B,CAChD,KAAM,CAAE,MAAAyB,EAAO,MAAAzB,CAAM,CACvB,CAAC,CACH,CAEA,MAAMyC,EAA2B,KAAK,8BAA8B,IAClEhB,EAAM,MACR,EAEIgB,IACFA,EAAyB,eAAe,EACxC,KAAK,sCAAsC,IAAIA,CAAwB,EACvE,KAAK,8BAA8B,OAAOhB,EAAM,MAAM,EAE1D,CAEQ,yBACNO,EACA7B,EACA,CACA,KAAK,sCAAsC,OAAO6B,CAAgB,EAClE,KAAK,8BAA8B,IAAI7B,EAAW6B,CAAgB,EAElE,GAAI,CACFA,EAAiB,mBAAmB7B,CAAS,CAC/C,OAASH,EAAO,CACd,KAAK,QAAQ,MAAM,qCAAsC,CACvD,KAAM,CAAE,MAAO,MAAAA,CAAM,CACvB,CAAC,EACDgC,EAAiB,WAAW,CAC9B,CACF,CAMQ,4BAA4BP,EAAc,CAChD,GAAI,CAAC,KAAK,qBAAqBA,CAAK,EAAG,CACrC,KAAK,QAAQ,MAAM,gBAAiB,CAAE,KAAM,CAAE,MAAAA,CAAM,CAAE,CAAC,EACvD,MACF,CAEA,KAAK,QAAQ,KAAK,iDAAkD,CAClE,KAAM,CAAE,MAAAA,CAAM,CAChB,CAAC,EAED,MAAMgB,EAA2B,MAAM,KACrC,KAAK,qCACP,EAAE,KACCT,GACC,KAAK,mBAAmBA,EAAiB,MAAM,IAC/C,KAAK,mBAAmBP,EAAM,MAAM,CACxC,EAEIgB,GACF,KAAK,yBAAyBA,EAA0BhB,EAAM,MAAM,EAQtE,KAAK,gCAAgC,CACvC,CAEO,SAAU,CACf,KAAK,gCAAgC,EACrC,KAAK,8BAA8B,QAASiB,GAAe,CACzDA,EAAW,WAAW,CACxB,CAAC,EACD,KAAK,sCAAsC,MAAM,CACnD,CACF,EA3fapD,EAANqD,EAAA,CADNC,EAAW,EA6BPC,EAAA,EAAAC,EAAOC,EAAiB,qBAAqB,GAE7CF,EAAA,EAAAC,EAAOE,EAAY,6BAA6B,GAEhDH,EAAA,EAAAC,EAAOG,EAAW,6BAA6B,IAhCvC3D",
-  "names": ["Sentry", "inject", "injectable", "EitherAsync", "Left", "Maybe", "Right", "BehaviorSubject", "from", "map", "switchMap", "uuid", "BuiltinTransports", "deviceModelTypes", "loggerTypes", "DeviceNotRecognizedError", "NoAccessibleDeviceError", "OpeningConnectionError", "UnknownDeviceError", "UsbHidTransportNotSupportedError", "InternalConnectedDevice", "LEDGER_VENDOR_ID", "usbDiTypes", "WebUsbHidTransport", "deviceModelDataSource", "loggerServiceFactory", "usbHidDeviceConnectionFactory", "BehaviorSubject", "BuiltinTransports", "Right", "Left", "UsbHidTransportNotSupportedError", "result", "error", "EitherAsync", "hidApi", "hidDevice", "LEDGER_VENDOR_ID", "deviceError", "NoAccessibleDeviceError", "Sentry", "existingDiscoveredDevice", "internalDevice", "existingDeviceConnection", "deviceModel", "id", "uuid", "discoveredDevice", "DeviceNotRecognizedError", "map", "devices", "device", "hidDevices", "discoveredHidDevices", "from", "switchMap", "either", "discoveredDevices", "event", "deviceId", "onDisconnect", "matchingInternalDevice", "UnknownDeviceError", "connectionError", "OpeningConnectionError", "deviceConnection", "connectedDevice", "InternalConnectedDevice", "apdu", "triggersDisconnection", "productId", "matchingModel", "Maybe", "params", "matchingDeviceConnection", "connection", "__decorateClass", "injectable", "__decorateParam", "inject", "deviceModelTypes", "loggerTypes", "usbDiTypes"]
-}

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

@@ -1,2 +0,0 @@
-import{Left as b,Right as k}from"purify-ts";import{Subject as C}from"rxjs";import{DeviceModelId as u}from"../../../../api/device/DeviceModel";import{StaticDeviceModelDataSource as y}from"../../../device-model/data/StaticDeviceModelDataSource";import{DefaultLoggerPublisherService as B}from"../../../logger-publisher/service/DefaultLoggerPublisherService";import{DeviceNotRecognizedError as H,NoAccessibleDeviceError as g,OpeningConnectionError as T,UnknownDeviceError as w,UsbHidTransportNotSupportedError as N}from"../../../transport/model/Errors";import{connectedDeviceStubBuilder as R}from"../../../transport/model/InternalConnectedDevice.stub";import{RECONNECT_DEVICE_TIMEOUT as p}from"../../../transport/usb/data/UsbHidConfig";import{hidDeviceStubBuilder as l}from"../../../transport/usb/model/HIDDevice.stub";import{usbHidDeviceConnectionFactoryStubBuilder as O}from"../../../transport/usb/service/UsbHidDeviceConnectionFactory.stub";import{WebUsbHidTransport as S}from"./WebUsbHidTransport";jest.mock("@internal/logger-publisher/service/LoggerPublisherService");const f=new y,M=new B([],"web-usb-hid"),d=l(),m=()=>new Promise(jest.requireActual("timers").setImmediate);describe("WebUsbHidTransport",()=>{let i;function x(){i=new S(f,()=>M,O())}beforeEach(()=>{x(),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(N),s()})})}),describe("When WebHID API is supported",()=>{const s=jest.fn(),r=jest.fn(),I=new C,E=new C;function D(t){I.next({device:t})}function h(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)}}},x()}),afterEach(()=>{jest.restoreAllMocks(),global.navigator=void 0}),it("should support the transport",()=>{expect(i.isSupported()).toBe(!0)}),describe("startDiscovering",()=>{f.getAllDeviceModels().flatMap(e=>[{testTitle:`should emit device if user grants access through hid.requestDevice (${e.productName})`,hidDevice:l({productId:e.usbProductId<<8,productName:e.productName}),expectedDeviceModel:e},{testTitle:`should emit device if user grants access through hid.requestDevice (${e.productName}, bootloader)`,hidDevice:l({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.NANO_X,productName:"Ledger Nano X",usbProductId:64})}));break;case 1:expect(o).toEqual(expect.objectContaining({deviceModel:expect.objectContaining({id:u.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(H),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(g),expect(o).toStrictEqual(new g(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(g),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,v=>n(v))}),c=await new Promise((o,n)=>{a(o,v=>n(v))});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(b(new w("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(b(new w("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(b(new T(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=R(),e=await i.disconnect({connectedDevice:t});expect(e).toStrictEqual(b(new w(`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(k(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()=>{h(d),expect(d.close).toHaveBeenCalled(),await Promise.resolve(),expect(e).not.toHaveBeenCalled(),jest.advanceTimersByTime(p/2),expect(e).not.toHaveBeenCalled(),jest.advanceTimersByTime(p/2),expect(e).toHaveBeenCalled(),t()}).catch(o=>{t(o)})}})})}),describe("reconnect",()=>{it("should stop disconnection if reconnection happen",t=>{const e=jest.fn(),c=l(),o=l();r.mockResolvedValueOnce([c]),s.mockResolvedValue([c,o]),a(async n=>{try{await i.connect({deviceId:n.id,onDisconnect:e}),h(c),expect(c.close).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(p/3),D(o),expect(o.open).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(p),expect(e).not.toHaveBeenCalled(),t()}catch(v){t(v)}})}),it("should be able to reconnect twice in a row if the device is unplugged and replugged twice",t=>{const e=jest.fn(),c=l(),o=l(),n=l();r.mockResolvedValueOnce([c]),s.mockResolvedValue([c,o,n]),a(async v=>{await i.connect({deviceId:v.id,onDisconnect:e});try{h(c),expect(c.close).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(p/3),D(o),expect(o.open).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(p),expect(e).not.toHaveBeenCalled(),h(o),expect(o.close).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(p/3),D(n),expect(n.open).toHaveBeenCalled(),await Promise.resolve(),jest.advanceTimersByTime(p),expect(e).not.toHaveBeenCalled(),t()}catch(j){t(j)}})})}),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=l();s.mockResolvedValue([t]);const e=jest.fn(),c=jest.fn();let o=[];i.listenToKnownDevices().subscribe({next:n=>{o=n},complete:e,error:c}),await m(),expect(o).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.NANO_X})})]),expect(e).not.toHaveBeenCalled(),expect(c).not.toHaveBeenCalled()}),it("should emit the new list of devices after connection and disconnection events",async()=>{x();const t=l({productId:f.getDeviceModel({id:u.NANO_X}).usbProductId<<8}),e=l({productId:f.getDeviceModel({id:u.STAX}).usbProductId<<8});s.mockResolvedValue([t]);const c=jest.fn(),o=jest.fn();let n=[];i.listenToKnownDevices().subscribe({next:v=>{n=v},complete:c,error:o}),await m(),expect(n).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.NANO_X})})]),s.mockResolvedValue([t,e]),D(e),await m(),expect(n).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.NANO_X})}),expect.objectContaining({deviceModel:expect.objectContaining({id:u.STAX})})]),s.mockResolvedValue([e]),h(t),await m(),expect(n).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.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=l();s.mockResolvedValue([t]);const e=jest.fn(),c=jest.fn();let o=[];i.listenToKnownDevices().subscribe({next:v=>{o=v},complete:e,error:c}),await m();const n=o[0]?.id;expect(n).toBeTruthy(),expect(o[0]?.deviceModel?.id).toBe(u.NANO_X),await i.connect({deviceId:o[0].id,onDisconnect:jest.fn()}),await m(),s.mockResolvedValue([]),h(t),await m(),expect(o).toEqual([]),s.mockResolvedValue([t]),D(t),await m(),expect(o).toEqual([expect.objectContaining({deviceModel:expect.objectContaining({id:u.NANO_X})})]),expect(o[0]?.id).toBeTruthy(),expect(o[0]?.id).toBe(n)})})})});
-//# sourceMappingURL=WebUsbHidTransport.test.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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": ["Left", "Right", "Subject", "DeviceModelId", "StaticDeviceModelDataSource", "DefaultLoggerPublisherService", "DeviceNotRecognizedError", "NoAccessibleDeviceError", "OpeningConnectionError", "UnknownDeviceError", "UsbHidTransportNotSupportedError", "connectedDeviceStubBuilder", "RECONNECT_DEVICE_TIMEOUT", "hidDeviceStubBuilder", "usbHidDeviceConnectionFactoryStubBuilder", "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/esm/src/internal/transport/usb/transport/__mocks__/WebUsbHidTransport.js

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

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

@@ -1,7 +0,0 @@
-{
-  "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": "AAEO,MAAMA,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,EACdC,EAA4B,CAAC,EAClB,CACX,MAAO,CACL,YAAa,KAAK,GAAG,EACrB,cAAe,KAAK,GAAG,EACvB,iBAAkB,KAAK,GAAG,EAC1B,gBAAiB,KAAK,GAAG,EACzB,QAAS,KAAK,GAAG,EACjB,WAAY,KAAK,GAAG,EACpB,qBAAsB,KAAK,GAAG,EAC9B,GAAGA,CACL,CACF",
-  "names": ["WebUsbHidTransport", "usbHidTransportMockBuilder", "props"]
-}

package/lib/types/src/api/logger-subscriber/__mocks__/ConsoleLogger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConsoleLogger.d.ts","sourceRoot":"","sources":["../../../../../../src/api/logger-subscriber/__mocks__/ConsoleLogger.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAa;IACxB,GAAG,2BAAa;CACjB"}

package/lib/types/src/internal/device-model/data/DeviceModelDataSource.d.ts

@@ -1,16 +0,0 @@
-import { type DeviceModelId } from "../../../api/device/DeviceModel";
-import { type InternalDeviceModel } from "../../device-model/model/DeviceModel";
-import { type BleDeviceInfos } from "../../transport/ble/model/BleDeviceInfos";
-/**
- * Source of truth for the device models
- */
-export interface DeviceModelDataSource {
-    getAllDeviceModels(): InternalDeviceModel[];
-    getDeviceModel(params: {
-        id: DeviceModelId;
-    }): InternalDeviceModel;
-    filterDeviceModels(params: Partial<InternalDeviceModel>): InternalDeviceModel[];
-    getBluetoothServicesInfos(): Record<string, BleDeviceInfos>;
-    getBluetoothServices(): string[];
-}
-//# sourceMappingURL=DeviceModelDataSource.d.ts.map

package/lib/types/src/internal/device-model/data/DeviceModelDataSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviceModelDataSource.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-model/data/DeviceModelDataSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,IAAI,mBAAmB,EAAE,CAAC;IAE5C,cAAc,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,aAAa,CAAA;KAAE,GAAG,mBAAmB,CAAC;IAEnE,kBAAkB,CAChB,MAAM,EAAE,OAAO,CAAC,mBAAmB,CAAC,GACnC,mBAAmB,EAAE,CAAC;IAEzB,yBAAyB,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAE5D,oBAAoB,IAAI,MAAM,EAAE,CAAC;CAClC"}

package/lib/types/src/internal/device-model/data/StaticDeviceModelDataSource.d.ts

@@ -1,21 +0,0 @@
-import { DeviceModelId } from "../../../api/device/DeviceModel";
-import { InternalDeviceModel } from "../../device-model/model/DeviceModel";
-import { BleDeviceInfos } from "../../transport/ble/model/BleDeviceInfos";
-import { DeviceModelDataSource } from "./DeviceModelDataSource";
-/**
- * Static/in memory implementation of the device model data source
- */
-export declare class StaticDeviceModelDataSource implements DeviceModelDataSource {
-    private static deviceModelByIds;
-    getAllDeviceModels(): InternalDeviceModel[];
-    getDeviceModel(params: {
-        id: DeviceModelId;
-    }): InternalDeviceModel;
-    /**
-     * Returns the list of device models that match all the given parameters
-     */
-    filterDeviceModels(params: Partial<InternalDeviceModel>): InternalDeviceModel[];
-    getBluetoothServicesInfos(): Record<string, BleDeviceInfos>;
-    getBluetoothServices(): string[];
-}
-//# sourceMappingURL=StaticDeviceModelDataSource.d.ts.map

package/lib/types/src/internal/device-model/data/StaticDeviceModelDataSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StaticDeviceModelDataSource.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-model/data/StaticDeviceModelDataSource.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAE9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;GAEG;AACH,qBACa,2BAA4B,YAAW,qBAAqB;IACvE,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAwE7B;IAEF,kBAAkB,IAAI,mBAAmB,EAAE;IAI3C,cAAc,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,aAAa,CAAA;KAAE,GAAG,mBAAmB;IAIlE;;OAEG;IACH,kBAAkB,CAChB,MAAM,EAAE,OAAO,CAAC,mBAAmB,CAAC,GACnC,mBAAmB,EAAE;IAQxB,yBAAyB,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;IA2B3D,oBAAoB,IAAI,MAAM,EAAE;CAQjC"}

package/lib/types/src/internal/device-model/data/StaticDeviceModelDataSource.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StaticDeviceModelDataSource.test.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-model/data/StaticDeviceModelDataSource.test.ts"],"names":[],"mappings":""}

package/lib/types/src/internal/device-model/model/DeviceModel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviceModel.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-model/model/DeviceModel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,EAAE,EAAE,aAAa,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,CAAC,EAAE;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,EAAE,CAAC;gBAEQ,KAAK,EAAE;QACjB,EAAE,EAAE,aAAa,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,OAAO,EAAE,OAAO,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,EAAE,CAAC;QAEhB,aAAa,CAAC,EAAE;YACd,WAAW,EAAE,MAAM,CAAC;YACpB,SAAS,EAAE,MAAM,CAAC;YAClB,YAAY,EAAE,MAAM,CAAC;YACrB,UAAU,EAAE,MAAM,CAAC;SACpB,EAAE,CAAC;KACL;IAWD,YAAY,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;CAc9C"}

package/lib/types/src/internal/device-model/model/DeviceModel.stub.d.ts

@@ -1,3 +0,0 @@
-import { type InternalDeviceModel } from "../../device-model/model/DeviceModel";
-export declare function deviceModelStubBuilder(props?: Partial<InternalDeviceModel>): InternalDeviceModel;
-//# sourceMappingURL=DeviceModel.stub.d.ts.map

package/lib/types/src/internal/device-model/model/DeviceModel.stub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviceModel.stub.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-model/model/DeviceModel.stub.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAEpF,wBAAgB,sBAAsB,CACpC,KAAK,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACvC,mBAAmB,CAoBrB"}

package/lib/types/src/internal/device-model/model/DeviceModel.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviceModel.test.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-model/model/DeviceModel.test.ts"],"names":[],"mappings":""}

package/lib/types/src/internal/device-session/data/FramerConst.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FramerConst.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/data/FramerConst.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,IAAO,CAAC;AAC7B,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,uBAAuB,IAAI,CAAC"}

package/lib/types/src/internal/device-session/service/ApduReceiverService.d.ts

@@ -1,7 +0,0 @@
-import { type Either, type Maybe } from "purify-ts";
-import { type ApduResponse } from "../../../api/device-session/ApduResponse";
-import { type DmkError } from "../../../api/Error";
-export interface ApduReceiverService {
-    handleFrame(apdu: Uint8Array): Either<DmkError, Maybe<ApduResponse>>;
-}
-//# sourceMappingURL=ApduReceiverService.d.ts.map

package/lib/types/src/internal/device-session/service/ApduReceiverService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ApduReceiverService.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/service/ApduReceiverService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;CACtE"}

package/lib/types/src/internal/device-session/service/ApduSenderService.d.ts

@@ -1,5 +0,0 @@
-import { type Frame } from "../../device-session/model/Frame";
-export interface ApduSenderService {
-    getFrames: (apdu: Uint8Array) => Frame[];
-}
-//# sourceMappingURL=ApduSenderService.d.ts.map

package/lib/types/src/internal/device-session/service/ApduSenderService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ApduSenderService.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/service/ApduSenderService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,sCAAsC,CAAC;AAElE,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,KAAK,EAAE,CAAC;CAC1C"}

package/lib/types/src/internal/device-session/service/DefaultApduReceiverService.stub.d.ts

@@ -1,5 +0,0 @@
-import { type ApduReceiverService } from "../../device-session/service/ApduReceiverService";
-import { type DefaultApduReceiverConstructorArgs } from "../../device-session/service/DefaultApduReceiverService";
-import { type LoggerPublisherService } from "../../logger-publisher/service/LoggerPublisherService";
-export declare const defaultApduReceiverServiceStubBuilder: (props: Partial<DefaultApduReceiverConstructorArgs> | undefined, loggerFactory: (tag: string) => LoggerPublisherService) => ApduReceiverService;
-//# sourceMappingURL=DefaultApduReceiverService.stub.d.ts.map

package/lib/types/src/internal/device-session/service/DefaultApduReceiverService.stub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultApduReceiverService.stub.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/service/DefaultApduReceiverService.stub.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAChG,OAAO,EACL,KAAK,kCAAkC,EAExC,MAAM,6DAA6D,CAAC;AACrE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,2DAA2D,CAAC;AAExG,eAAO,MAAM,qCAAqC,UACzC,OAAO,CAAC,kCAAkC,CAAC,6BACnC,CAAC,GAAG,EAAE,MAAM,KAAK,sBAAsB,KACrD,mBAOA,CAAC"}

package/lib/types/src/internal/device-session/service/DefaultApduSenderService.stub.d.ts

@@ -1,5 +0,0 @@
-import { type ApduSenderService } from "../../device-session/service/ApduSenderService";
-import { type DefaultApduSenderServiceConstructorArgs } from "../../device-session/service/DefaultApduSenderService";
-import { type LoggerPublisherService } from "../../logger-publisher/service/LoggerPublisherService";
-export declare const defaultApduSenderServiceStubBuilder: (props: Partial<DefaultApduSenderServiceConstructorArgs> | undefined, loggerFactory: (tag: string) => LoggerPublisherService) => ApduSenderService;
-//# sourceMappingURL=DefaultApduSenderService.stub.d.ts.map

package/lib/types/src/internal/device-session/service/DefaultApduSenderService.stub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultApduSenderService.stub.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/service/DefaultApduSenderService.stub.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,oDAAoD,CAAC;AAC5F,OAAO,EAEL,KAAK,uCAAuC,EAC7C,MAAM,2DAA2D,CAAC;AACnE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,2DAA2D,CAAC;AAExG,eAAO,MAAM,mCAAmC,UACvC,OAAO,CAAC,uCAAuC,CAAC,6BACxC,CAAC,GAAG,EAAE,MAAM,KAAK,sBAAsB,KACrD,iBASA,CAAC"}

package/lib/types/src/internal/device-session/use-case/CloseSessionsUseState.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=CloseSessionsUseState.test.d.ts.map

package/lib/types/src/internal/device-session/use-case/CloseSessionsUseState.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CloseSessionsUseState.test.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/use-case/CloseSessionsUseState.test.ts"],"names":[],"mappings":""}

package/lib/types/src/internal/device-session/utils/FramerUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FramerUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/utils/FramerUtils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;4BAME,UAAU,QAAQ,MAAM,GAAG,UAAU;6BASpC,UAAU,QAAQ,MAAM,GAAG,UAAU;yBASzC,UAAU,GAAG,MAAM;8BAcd,MAAM,QAAQ,MAAM,GAAG,UAAU;CAK5D,CAAC"}

package/lib/types/src/internal/device-session/utils/FramerUtils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FramerUtils.test.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/device-session/utils/FramerUtils.test.ts"],"names":[],"mappings":""}

package/lib/types/src/internal/logger-publisher/service/LoggerPublisherService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoggerPublisherService.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/logger-publisher/service/LoggerPublisherService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,wDAAwD,CAAC;AACtG,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAEhG,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,uBAAuB,EAAE,CAAC;IAEvC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC3D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC3D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC7D"}

package/lib/types/src/internal/logger-publisher/service/__mocks__/DefaultLoggerService.d.ts

@@ -1,11 +0,0 @@
-import { type LoggerSubscriberService } from "../../../../api/logger-subscriber/service/LoggerSubscriberService";
-import type { LoggerPublisherService } from "../../../logger-publisher/service/LoggerPublisherService";
-export declare class DefaultLoggerPublisherService implements LoggerPublisherService {
-    subscribers: LoggerSubscriberService[];
-    _log: jest.Mock<any, any, any>;
-    info: jest.Mock<any, any, any>;
-    warn: jest.Mock<any, any, any>;
-    debug: jest.Mock<any, any, any>;
-    error: jest.Mock<any, any, any>;
-}
-//# sourceMappingURL=DefaultLoggerService.d.ts.map

package/lib/types/src/internal/logger-publisher/service/__mocks__/DefaultLoggerService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultLoggerService.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/logger-publisher/service/__mocks__/DefaultLoggerService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,wDAAwD,CAAC;AACtG,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2DAA2D,CAAC;AAExG,qBAAa,6BAA8B,YAAW,sBAAsB;IAC1E,WAAW,EAAE,uBAAuB,EAAE,CAAM;IAE5C,IAAI,2BAAa;IACjB,IAAI,2BAAa;IACjB,IAAI,2BAAa;IACjB,KAAK,2BAAa;IAClB,KAAK,2BAAa;CACnB"}

package/lib/types/src/internal/manager-api/model/ManagerApiType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ManagerApiType.d.ts","sourceRoot":"","sources":["../../../../../../src/internal/manager-api/model/ManagerApiType.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,EAAE,GAAG,MAAM,CAAC;AAExB,oBAAY,OAAO;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,IAAI,SAAS;CACd;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,EAAE,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC"}

package/lib/types/src/internal/transport/ble/di/bleDiTypes.d.ts

@@ -1,4 +0,0 @@
-export declare const bleDiTypes: {
-    BleDeviceConnectionFactory: symbol;
-};
-//# sourceMappingURL=bleDiTypes.d.ts.map

package/lib/types/src/internal/transport/ble/di/bleDiTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bleDiTypes.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/di/bleDiTypes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;CAEtB,CAAC"}

package/lib/types/src/internal/transport/ble/di/bleModule.d.ts

@@ -1,3 +0,0 @@
-import { ContainerModule } from "inversify";
-export declare const bleModuleFactory: () => ContainerModule;
-//# sourceMappingURL=bleModule.d.ts.map

package/lib/types/src/internal/transport/ble/di/bleModule.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bleModule.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/di/bleModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAM5C,eAAO,MAAM,gBAAgB,uBAGzB,CAAC"}

package/lib/types/src/internal/transport/ble/di/bleModule.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=bleModule.test.d.ts.map

package/lib/types/src/internal/transport/ble/di/bleModule.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bleModule.test.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/di/bleModule.test.ts"],"names":[],"mappings":""}

package/lib/types/src/internal/transport/ble/model/BleDevice.stub.d.ts

@@ -1,3 +0,0 @@
-export declare const bleCharacteristicStubBuilder: (props?: Partial<BluetoothRemoteGATTCharacteristic>) => BluetoothRemoteGATTCharacteristic;
-export declare const bleDeviceStubBuilder: (props?: Partial<BluetoothDevice>) => BluetoothDevice;
-//# sourceMappingURL=BleDevice.stub.d.ts.map

package/lib/types/src/internal/transport/ble/model/BleDevice.stub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BleDevice.stub.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/model/BleDevice.stub.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,4BAA4B,WAChC,OAAO,CAAC,iCAAiC,CAAC,KAChD,iCAQsC,CAAC;AAE1C,eAAO,MAAM,oBAAoB,WACxB,OAAO,CAAC,eAAe,CAAC,KAC9B,eAaD,CAAC"}

package/lib/types/src/internal/transport/ble/model/BleDeviceInfos.d.ts

@@ -1,10 +0,0 @@
-import { type InternalDeviceModel } from "../../../device-model/model/DeviceModel";
-export declare class BleDeviceInfos {
-    deviceModel: InternalDeviceModel;
-    serviceUuid: string;
-    writeUuid: string;
-    writeCmdUuid: string;
-    notifyUuid: string;
-    constructor(deviceModel: InternalDeviceModel, serviceUuid: string, writeUuid: string, writeCmdUuid: string, notifyUuid: string);
-}
-//# sourceMappingURL=BleDeviceInfos.d.ts.map

package/lib/types/src/internal/transport/ble/model/BleDeviceInfos.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BleDeviceInfos.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/model/BleDeviceInfos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAEpF,qBAAa,cAAc;IAEhB,WAAW,EAAE,mBAAmB;IAChC,WAAW,EAAE,MAAM;IACnB,SAAS,EAAE,MAAM;IACjB,YAAY,EAAE,MAAM;IACpB,UAAU,EAAE,MAAM;gBAJlB,WAAW,EAAE,mBAAmB,EAChC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM;CAE5B"}

package/lib/types/src/internal/transport/ble/service/BleDeviceConnectionFactory.d.ts

@@ -1,13 +0,0 @@
-import { ApduReceiverService } from "../../../device-session/service/ApduReceiverService";
-import { ApduSenderService } from "../../../device-session/service/ApduSenderService";
-import { DefaultApduSenderServiceConstructorArgs } from "../../../device-session/service/DefaultApduSenderService";
-import { LoggerPublisherService } from "../../../logger-publisher/service/LoggerPublisherService";
-import { BleDeviceConnection } from "../../../transport/ble/transport/BleDeviceConnection";
-export declare class BleDeviceConnectionFactory {
-    private readonly apduSenderFactory;
-    private readonly apduReceiverFactory;
-    private readonly loggerFactory;
-    constructor(apduSenderFactory: (args: DefaultApduSenderServiceConstructorArgs) => ApduSenderService, apduReceiverFactory: () => ApduReceiverService, loggerFactory: (name: string) => LoggerPublisherService);
-    create(writeCharacteristic: BluetoothRemoteGATTCharacteristic, notifyCharacteristic: BluetoothRemoteGATTCharacteristic): BleDeviceConnection;
-}
-//# sourceMappingURL=BleDeviceConnectionFactory.d.ts.map

package/lib/types/src/internal/transport/ble/service/BleDeviceConnectionFactory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BleDeviceConnectionFactory.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/service/BleDeviceConnectionFactory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAC3F,OAAO,EAAE,iBAAiB,EAAE,MAAM,oDAAoD,CAAC;AACvF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2DAA2D,CAAC;AAEpH,OAAO,EAAE,sBAAsB,EAAE,MAAM,2DAA2D,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAAE,MAAM,uDAAuD,CAAC;AAE5F,qBACa,0BAA0B;IAGnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAIlC,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAEpC,OAAO,CAAC,QAAQ,CAAC,aAAa;gBANb,iBAAiB,EAAE,CAClC,IAAI,EAAE,uCAAuC,KAC1C,iBAAiB,EAEL,mBAAmB,EAAE,MAAM,mBAAmB,EAE9C,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,sBAAsB;IAGnE,MAAM,CACX,mBAAmB,EAAE,iCAAiC,EACtD,oBAAoB,EAAE,iCAAiC,GACtD,mBAAmB;CAWvB"}

package/lib/types/src/internal/transport/ble/service/BleDeviceConnectionFactory.stub.d.ts

@@ -1,3 +0,0 @@
-import { BleDeviceConnectionFactory } from "../../../transport/ble/service/BleDeviceConnectionFactory";
-export declare const bleDeviceConnectionFactoryStubBuilder: () => BleDeviceConnectionFactory;
-//# sourceMappingURL=BleDeviceConnectionFactory.stub.d.ts.map

package/lib/types/src/internal/transport/ble/service/BleDeviceConnectionFactory.stub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BleDeviceConnectionFactory.stub.d.ts","sourceRoot":"","sources":["../../../../../../../src/internal/transport/ble/service/BleDeviceConnectionFactory.stub.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,0BAA0B,EAAE,MAAM,4DAA4D,CAAC;AAIxG,eAAO,MAAM,qCAAqC,kCAK/C,CAAC"}