@ledgerhq/device-management-kit 0.6.4 → 0.7.0

package/lib/esm/src/internal/device-session/model/DevicePinger.js

@@ -0,0 +1,2 @@
+import{DeviceModelId as c}from"../../../api/device/DeviceModel";import{GetAppAndVersionCommand as a,GetOsVersionCommand as m}from"../../../api/index";import{PINGER_TIMEOUT as o}from"../../device-session/data/ApduResponseConst";import{DEVICE_SESSION_REFRESHER_POLLING_INTERVAL as p}from"../../device-session/data/DeviceSessionRefresherConst";import{SessionEvents as i}from"../../device-session/model/DeviceSessionEventDispatcher";class D{constructor(e,t,r,n){this.connectedDevice=t;this._sessionEventDispatcher=r;this._sendCommandFunction=n,this._logger=e("device-pinger"),this._subscription=this._sessionEventDispatcher.listen().subscribe(async s=>await this.mapEventAction(s))}_sendCommandFunction;_subscription;_logger;async ping(){try{return await this.mapDevicePingAction(this.connectedDevice.deviceModel.id)}catch(e){throw this._logger.error("Error while pinging device",{data:{error:e}}),e}}mapEventAction=async e=>{switch(e.eventName){case i.REFRESH_NEEDED:return await this.ping();default:return null}};async mapDevicePingAction(e){switch(e){case c.NANO_S:{const t=async()=>{const s=await this._sendCommandFunction(new a,o);return this._sendCommandFunction(new m,o),s},r=new Promise(s=>{setTimeout(()=>s(null),p*2+100)}),n=await Promise.race([t(),r]);return n?this._sessionEventDispatcher.dispatch({eventName:i.COMMAND_SUCCEEDED,eventData:n}):this._sessionEventDispatcher.dispatch({eventName:i.DEVICE_STATE_UPDATE_LOCKED}),n}default:{const t=await this._sendCommandFunction(new a,o);return this._sessionEventDispatcher.dispatch({eventName:i.COMMAND_SUCCEEDED,eventData:t}),t}}}unsubscribe(){this._subscription.unsubscribe()}}export{D as DevicePinger};
+//# sourceMappingURL=DevicePinger.js.map

package/lib/esm/src/internal/device-session/model/DevicePinger.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/device-session/model/DevicePinger.ts"],
+  "sourcesContent": ["import { type Subscription } from \"rxjs\";\n\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport {\n  GetAppAndVersionCommand,\n  type GetAppAndVersionResponse,\n  GetOsVersionCommand,\n  type TransportConnectedDevice,\n} from \"@api/index\";\nimport {\n  type Command,\n  type CommandResult,\n  type LoggerPublisherService,\n} from \"@api/types\";\nimport { PINGER_TIMEOUT } from \"@internal/device-session/data/ApduResponseConst\";\nimport { DEVICE_SESSION_REFRESHER_POLLING_INTERVAL } from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport {\n  type DeviceSessionEventDispatcher,\n  type NewEvent,\n  SessionEvents,\n} from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\n\ntype SendCommandFunction = <Response, Args, ErrorStatusCodes>(\n  command: Command<Response, Args, ErrorStatusCodes>,\n  abortTimeout?: number,\n) => Promise<CommandResult<Response, ErrorStatusCodes>>;\n\nexport class DevicePinger {\n  private readonly _sendCommandFunction: SendCommandFunction;\n  private _subscription: Subscription;\n  private _logger: LoggerPublisherService;\n\n  constructor(\n    loggerModuleFactory: (tag: string) => LoggerPublisherService,\n    private connectedDevice: TransportConnectedDevice,\n    private _sessionEventDispatcher: DeviceSessionEventDispatcher,\n    sendCommandFunction: SendCommandFunction,\n  ) {\n    this._sendCommandFunction = sendCommandFunction;\n    this._logger = loggerModuleFactory(\"device-pinger\");\n    this._subscription = this._sessionEventDispatcher\n      .listen()\n      .subscribe(async (event) => await this.mapEventAction(event));\n  }\n\n  public async ping(): Promise<CommandResult<GetAppAndVersionResponse> | null> {\n    try {\n      const result = await this.mapDevicePingAction(\n        this.connectedDevice.deviceModel.id,\n      );\n      return result;\n    } catch (error) {\n      this._logger.error(\"Error while pinging device\", {\n        data: {\n          error,\n        },\n      });\n      throw error;\n    }\n  }\n\n  private mapEventAction = async (event: NewEvent) => {\n    switch (event.eventName) {\n      case SessionEvents.REFRESH_NEEDED:\n        return await this.ping();\n      default:\n        return null;\n    }\n  };\n\n  private async mapDevicePingAction(deviceModelId: DeviceModelId) {\n    switch (deviceModelId) {\n      case DeviceModelId.NANO_S: {\n        const chainPromise: () => Promise<\n          CommandResult<GetAppAndVersionResponse>\n        > = async () => {\n          const appVersionResult = await this._sendCommandFunction(\n            new GetAppAndVersionCommand(),\n            PINGER_TIMEOUT,\n          );\n\n          this._sendCommandFunction(new GetOsVersionCommand(), PINGER_TIMEOUT);\n          return appVersionResult;\n        };\n\n        const timeoutPromise: Promise<null> = new Promise((resolve) => {\n          setTimeout(\n            () => resolve(null),\n            DEVICE_SESSION_REFRESHER_POLLING_INTERVAL * 2 + 100,\n          );\n        });\n\n        const resultOrTimeout: CommandResult<GetAppAndVersionResponse> | null =\n          await Promise.race([chainPromise(), timeoutPromise]);\n\n        if (!resultOrTimeout) {\n          this._sessionEventDispatcher.dispatch({\n            eventName: SessionEvents.DEVICE_STATE_UPDATE_LOCKED,\n          });\n        } else {\n          this._sessionEventDispatcher.dispatch({\n            eventName: SessionEvents.COMMAND_SUCCEEDED,\n            eventData: resultOrTimeout,\n          });\n        }\n        return resultOrTimeout;\n      }\n      default: {\n        const result = await this._sendCommandFunction(\n          new GetAppAndVersionCommand(),\n          PINGER_TIMEOUT,\n        );\n        this._sessionEventDispatcher.dispatch({\n          eventName: SessionEvents.COMMAND_SUCCEEDED,\n          eventData: result,\n        });\n        return result;\n      }\n    }\n  }\n\n  public unsubscribe(): void {\n    this._subscription.unsubscribe();\n  }\n}\n"],
+  "mappings": "AAEA,OAAS,iBAAAA,MAAqB,0BAC9B,OACE,2BAAAC,EAEA,uBAAAC,MAEK,aAMP,OAAS,kBAAAC,MAAsB,kDAC/B,OAAS,6CAAAC,MAAiD,4DAC1D,OAGE,iBAAAC,MACK,8DAOA,MAAMC,CAAa,CAKxB,YACEC,EACQC,EACAC,EACRC,EACA,CAHQ,qBAAAF,EACA,6BAAAC,EAGR,KAAK,qBAAuBC,EAC5B,KAAK,QAAUH,EAAoB,eAAe,EAClD,KAAK,cAAgB,KAAK,wBACvB,OAAO,EACP,UAAU,MAAOI,GAAU,MAAM,KAAK,eAAeA,CAAK,CAAC,CAChE,CAfiB,qBACT,cACA,QAeR,MAAa,MAAgE,CAC3E,GAAI,CAIF,OAHe,MAAM,KAAK,oBACxB,KAAK,gBAAgB,YAAY,EACnC,CAEF,OAASC,EAAO,CACd,WAAK,QAAQ,MAAM,6BAA8B,CAC/C,KAAM,CACJ,MAAAA,CACF,CACF,CAAC,EACKA,CACR,CACF,CAEQ,eAAiB,MAAOD,GAAoB,CAClD,OAAQA,EAAM,UAAW,CACvB,KAAKN,EAAc,eACjB,OAAO,MAAM,KAAK,KAAK,EACzB,QACE,OAAO,IACX,CACF,EAEA,MAAc,oBAAoBQ,EAA8B,CAC9D,OAAQA,EAAe,CACrB,KAAKb,EAAc,OAAQ,CACzB,MAAMc,EAEF,SAAY,CACd,MAAMC,EAAmB,MAAM,KAAK,qBAClC,IAAId,EACJE,CACF,EAEA,YAAK,qBAAqB,IAAID,EAAuBC,CAAc,EAC5DY,CACT,EAEMC,EAAgC,IAAI,QAASC,GAAY,CAC7D,WACE,IAAMA,EAAQ,IAAI,EAClBb,EAA4C,EAAI,GAClD,CACF,CAAC,EAEKc,EACJ,MAAM,QAAQ,KAAK,CAACJ,EAAa,EAAGE,CAAc,CAAC,EAErD,OAAKE,EAKH,KAAK,wBAAwB,SAAS,CACpC,UAAWb,EAAc,kBACzB,UAAWa,CACb,CAAC,EAPD,KAAK,wBAAwB,SAAS,CACpC,UAAWb,EAAc,0BAC3B,CAAC,EAOIa,CACT,CACA,QAAS,CACP,MAAMC,EAAS,MAAM,KAAK,qBACxB,IAAIlB,EACJE,CACF,EACA,YAAK,wBAAwB,SAAS,CACpC,UAAWE,EAAc,kBACzB,UAAWc,CACb,CAAC,EACMA,CACT,CACF,CACF,CAEO,aAAoB,CACzB,KAAK,cAAc,YAAY,CACjC,CACF",
+  "names": ["DeviceModelId", "GetAppAndVersionCommand", "GetOsVersionCommand", "PINGER_TIMEOUT", "DEVICE_SESSION_REFRESHER_POLLING_INTERVAL", "SessionEvents", "DevicePinger", "loggerModuleFactory", "connectedDevice", "_sessionEventDispatcher", "sendCommandFunction", "event", "error", "deviceModelId", "chainPromise", "appVersionResult", "timeoutPromise", "resolve", "resultOrTimeout", "result"]
+}

package/lib/esm/src/internal/device-session/model/DevicePinger.test.js

@@ -0,0 +1,2 @@
+import{Subject as D}from"rxjs";import{afterEach as f,beforeEach as C,describe as N,expect as n,it as r,vi as t}from"vitest";import{DeviceModelId as E}from"../../../api/device/DeviceModel";import{GetAppAndVersionCommand as S}from"../../../api/index";import{DEVICE_SESSION_REFRESHER_POLLING_INTERVAL as g}from"../../device-session/data/DeviceSessionRefresherConst";import{SessionEvents as i}from"../../device-session/model/DeviceSessionEventDispatcher";import{DevicePinger as p}from"./DevicePinger";N("DevicePinger",()=>{let e,u;const v=t.fn(()=>u);let c,a,l,s;C(()=>{c=new D,a={listen:()=>c.asObservable(),dispatch:t.fn()},e=t.fn(),u={info:t.fn(),warn:t.fn(),error:t.fn(),debug:t.fn(),subscribers:[]},l={deviceModel:{id:E.NANO_X}},s=new p(v,l,a,e)}),f(()=>{s.unsubscribe(),t.restoreAllMocks()}),r("should call sendCommandFunction and dispatch COMMAND_SUCCEEDED event on successful ping for non-NANO_S",async()=>{const o={status:"success",data:{foo:"bar"}};e.mockResolvedValue(o);const d=await s.ping();n(e).toHaveBeenCalledTimes(1);const m=e.mock.calls[0][0];n(m).toBeInstanceOf(S),n(a.dispatch).toHaveBeenCalledWith({eventName:i.COMMAND_SUCCEEDED,eventData:o}),n(d).toEqual(o)}),r("should log error and throw error on ping failure",async()=>{const o=new Error("ping failed");e.mockRejectedValue(o),await n(s.ping()).rejects.toThrow("ping failed"),n(e).toHaveBeenCalledTimes(1)}),r("should dispatch DEVICE_STATE_UPDATE_LOCKED and return null on timeout for NANO_S",async()=>{l.deviceModel.id=E.NANO_S,s.unsubscribe(),s=new p(v,l,a,e);const o=new Promise(()=>{});e.mockReturnValueOnce(o),t.useFakeTimers();const d=s.ping();t.advanceTimersByTime(g*4);const m=await d;n(m).toBeNull(),n(a.dispatch).toHaveBeenCalledWith({eventName:i.DEVICE_STATE_UPDATE_LOCKED}),n(e).toHaveBeenCalledTimes(1),t.useRealTimers()}),r("should call ping on REFRESH_NEEDED event",async()=>{const o={status:"success",data:{foo:"bar"}};e.mockResolvedValue(o),c.next({eventName:i.REFRESH_NEEDED,eventData:void 0}),await Promise.resolve(),n(e).toHaveBeenCalled(),n(a.dispatch).toHaveBeenCalledWith({eventName:i.COMMAND_SUCCEEDED,eventData:o})}),r("should not process events after unsubscribe is called",async()=>{s.unsubscribe(),e.mockClear(),c.next({eventName:i.REFRESH_NEEDED,eventData:void 0}),await Promise.resolve(),n(e).not.toHaveBeenCalled()})});
+//# sourceMappingURL=DevicePinger.test.js.map

package/lib/esm/src/internal/device-session/model/DevicePinger.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/device-session/model/DevicePinger.test.ts"],
+  "sourcesContent": ["import { Subject } from \"rxjs\";\nimport { afterEach, beforeEach, describe, expect, it, vi } from \"vitest\";\n\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport {\n  GetAppAndVersionCommand,\n  type TransportConnectedDevice,\n} from \"@api/index\";\nimport type { LoggerPublisherService } from \"@api/types\";\nimport { DEVICE_SESSION_REFRESHER_POLLING_INTERVAL } from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport {\n  type DeviceSessionEventDispatcher,\n  type NewEvent,\n  SessionEvents,\n} from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\n\nimport { DevicePinger } from \"./DevicePinger\";\n\ndescribe(\"DevicePinger\", () => {\n  let dummySendCommandFunction: ReturnType<typeof vi.fn>;\n  let mockLogger: LoggerPublisherService & {\n    info: ReturnType<typeof vi.fn>;\n    warn: ReturnType<typeof vi.fn>;\n    error: ReturnType<typeof vi.fn>;\n  };\n  const mockedLoggerModuleFactory = vi.fn(() => mockLogger);\n  let eventSubject: Subject<NewEvent>;\n  let mockSessionEventDispatcher: DeviceSessionEventDispatcher;\n  let dummyConnectedDevice: TransportConnectedDevice;\n  let devicePinger: DevicePinger;\n\n  beforeEach(() => {\n    eventSubject = new Subject<NewEvent>();\n    mockSessionEventDispatcher = {\n      listen: () => eventSubject.asObservable(),\n      dispatch: vi.fn(),\n    } as unknown as DeviceSessionEventDispatcher;\n\n    dummySendCommandFunction = vi.fn();\n    mockLogger = {\n      info: vi.fn(),\n      warn: vi.fn(),\n      error: vi.fn(),\n      debug: vi.fn(),\n      subscribers: [],\n    };\n\n    dummyConnectedDevice = {\n      deviceModel: {\n        id: DeviceModelId.NANO_X,\n      },\n    } as unknown as TransportConnectedDevice;\n\n    devicePinger = new DevicePinger(\n      mockedLoggerModuleFactory,\n      dummyConnectedDevice,\n      mockSessionEventDispatcher,\n      dummySendCommandFunction,\n    );\n  });\n\n  afterEach(() => {\n    devicePinger.unsubscribe();\n    vi.restoreAllMocks();\n  });\n\n  it(\"should call sendCommandFunction and dispatch COMMAND_SUCCEEDED event on successful ping for non-NANO_S\", async () => {\n    // given\n    const dummyResult = {\n      status: \"success\",\n      data: { foo: \"bar\" },\n    };\n    dummySendCommandFunction.mockResolvedValue(dummyResult);\n\n    // when\n    const result = await devicePinger.ping();\n\n    // then\n    expect(dummySendCommandFunction).toHaveBeenCalledTimes(1);\n    const commandArg = dummySendCommandFunction.mock\n      .calls[0]![0] as GetAppAndVersionCommand;\n    expect(commandArg).toBeInstanceOf(GetAppAndVersionCommand);\n    expect(mockSessionEventDispatcher.dispatch).toHaveBeenCalledWith({\n      eventName: SessionEvents.COMMAND_SUCCEEDED,\n      eventData: dummyResult,\n    });\n    expect(result).toEqual(dummyResult);\n  });\n\n  it(\"should log error and throw error on ping failure\", async () => {\n    // given\n    const dummyError = new Error(\"ping failed\");\n    dummySendCommandFunction.mockRejectedValue(dummyError);\n\n    // then\n    await expect(devicePinger.ping()).rejects.toThrow(\"ping failed\");\n    expect(dummySendCommandFunction).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"should dispatch DEVICE_STATE_UPDATE_LOCKED and return null on timeout for NANO_S\", async () => {\n    // given\n    dummyConnectedDevice.deviceModel.id = DeviceModelId.NANO_S;\n    devicePinger.unsubscribe();\n    devicePinger = new DevicePinger(\n      mockedLoggerModuleFactory,\n      dummyConnectedDevice,\n      mockSessionEventDispatcher,\n      dummySendCommandFunction,\n    );\n    const neverResolvingPromise = new Promise(() => {});\n    dummySendCommandFunction.mockReturnValueOnce(neverResolvingPromise);\n    vi.useFakeTimers();\n\n    // when\n    const pingPromise = devicePinger.ping();\n    vi.advanceTimersByTime(DEVICE_SESSION_REFRESHER_POLLING_INTERVAL * 4);\n\n    const result = await pingPromise;\n\n    // then\n    expect(result).toBeNull();\n    expect(mockSessionEventDispatcher.dispatch).toHaveBeenCalledWith({\n      eventName: SessionEvents.DEVICE_STATE_UPDATE_LOCKED,\n    });\n    expect(dummySendCommandFunction).toHaveBeenCalledTimes(1);\n\n    vi.useRealTimers();\n  });\n\n  it(\"should call ping on REFRESH_NEEDED event\", async () => {\n    // given\n    const dummyResult = {\n      status: \"success\",\n      data: { foo: \"bar\" },\n    };\n    dummySendCommandFunction.mockResolvedValue(dummyResult);\n\n    // when\n    eventSubject.next({\n      eventName: SessionEvents.REFRESH_NEEDED,\n      eventData: undefined,\n    });\n    await Promise.resolve();\n\n    // then\n    expect(dummySendCommandFunction).toHaveBeenCalled();\n    expect(mockSessionEventDispatcher.dispatch).toHaveBeenCalledWith({\n      eventName: SessionEvents.COMMAND_SUCCEEDED,\n      eventData: dummyResult,\n    });\n  });\n\n  it(\"should not process events after unsubscribe is called\", async () => {\n    // given\n    devicePinger.unsubscribe();\n    dummySendCommandFunction.mockClear();\n\n    // when\n    eventSubject.next({\n      eventName: SessionEvents.REFRESH_NEEDED,\n      eventData: undefined,\n    });\n    await Promise.resolve();\n\n    // then\n    expect(dummySendCommandFunction).not.toHaveBeenCalled();\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["Subject", "afterEach", "beforeEach", "describe", "expect", "it", "vi", "DeviceModelId", "GetAppAndVersionCommand", "DEVICE_SESSION_REFRESHER_POLLING_INTERVAL", "SessionEvents", "DevicePinger", "dummySendCommandFunction", "mockLogger", "mockedLoggerModuleFactory", "eventSubject", "mockSessionEventDispatcher", "dummyConnectedDevice", "devicePinger", "dummyResult", "result", "commandArg", "dummyError", "neverResolvingPromise", "pingPromise"]
+}

package/lib/esm/src/internal/device-session/model/DeviceSession.js

@@ -1,2 +1,2 @@
-import{Left as a}from"purify-ts";import{BehaviorSubject as d}from"rxjs";import{v4 as v}from"uuid";import{CommandUtils as p}from"../../../api/command/utils/CommandUtils";import{DeviceStatus as s}from"../../../api/device/DeviceStatus";import{DeviceSessionStateType as u}from"../../../api/device-session/DeviceSessionState";import{DeviceBusyError as S}from"../../../api/Error";import{DEVICE_SESSION_REFRESH_INTERVAL as l}from"../../device-session/data/DeviceSessionRefresherConst";import{RefresherService as h}from"../../device-session/service/RefresherService";import{DeviceSessionRefresher as m}from"./DeviceSessionRefresher";class I{_id;_connectedDevice;_deviceState;_refresher;_refresherService;_managerApiService;_secureChannelService;_readyPromise;_resolveReady;constructor({connectedDevice:e,id:t=v()},r,i,o){this._id=t,this._connectedDevice=e,this._deviceState=new d({sessionStateType:u.Connected,deviceStatus:s.CONNECTED,deviceModelId:this._connectedDevice.deviceModel.id}),this._refresher=new m({refreshInterval:l,deviceStatus:s.CONNECTED,deviceModelId:this._connectedDevice.deviceModel.id,sendApduFn:n=>this.sendApdu(n,{isPolling:!0,triggersDisconnection:!1}),updateStateFn:n=>{const c=this._deviceState.getValue();this.setDeviceSessionState(n(c))}},r("device-session-refresher")),this._refresherService=new h(this._refresher),this._managerApiService=i,this._secureChannelService=o,this._readyPromise=new Promise(n=>{this._resolveReady=n}),this._refresher.start()}async waitIsReady(){await this._readyPromise}get id(){return this._id}get connectedDevice(){return this._connectedDevice}get state(){return this._deviceState.asObservable()}setDeviceSessionState(e){this._deviceState.next(e),this._resolveReady()}async sendApdu(e,t={isPolling:!1,triggersDisconnection:!1}){let r;return t.isPolling||(r=this._refresherService.disableRefresher("sendApdu"),await this.waitUntilReady()),this._deviceState.getValue().deviceStatus===s.BUSY?a(new S):(this.updateDeviceStatus(s.BUSY),(await this._connectedDevice.sendApdu(e,t.triggersDisconnection)).ifRight(n=>{p.isLockedDeviceResponse(n)?this.updateDeviceStatus(s.LOCKED):this.updateDeviceStatus(s.CONNECTED),!t.isPolling&&r&&r()}).ifLeft(()=>{this.updateDeviceStatus(s.CONNECTED),!t.isPolling&&r&&r()}))}async sendCommand(e){const t=e.getApdu();return(await this.sendApdu(t.getRawApdu(),{isPolling:!1,triggersDisconnection:e.triggersDisconnection??!1})).caseOf({Left:i=>{throw i},Right:i=>e.parseResponse(i,this._connectedDevice.deviceModel.id)})}executeDeviceAction(e){const{observable:t,cancel:r}=e._execute({sendApdu:async i=>this.sendApdu(i),sendCommand:async i=>this.sendCommand(i),getDeviceSessionState:()=>this._deviceState.getValue(),getDeviceSessionStateObservable:()=>this.state,setDeviceSessionState:i=>(this.setDeviceSessionState(i),this._deviceState.getValue()),disableRefresher:i=>this._refresherService.disableRefresher(i),getManagerApiService:()=>this._managerApiService,getSecureChannelService:()=>this._secureChannelService});return{observable:t,cancel:r}}close(){this.updateDeviceStatus(s.NOT_CONNECTED),this._deviceState.complete(),this._refresher.stop()}disableRefresher(e){return this._refresherService.disableRefresher(e)}updateDeviceStatus(e){const t=this._deviceState.getValue();this._refresher.setDeviceStatus(e),this._deviceState.next({...t,deviceStatus:e})}async waitUntilReady(){let e;await new Promise(t=>{e=this._deviceState.subscribe(r=>{[s.LOCKED,s.CONNECTED].includes(r.deviceStatus)&&(e?.unsubscribe(),t())})})}}export{I as DeviceSession};
+import{BehaviorSubject as v}from"rxjs";import{v4 as d}from"uuid";import{CommandUtils as h}from"../../../api/command/utils/CommandUtils";import{DeviceStatus as c}from"../../../api/device/DeviceStatus";import{DeviceSessionStateType as S}from"../../../api/device-session/DeviceSessionState";import{DEVICE_SESSION_REFRESHER_DEFAULT_OPTIONS as u}from"../../device-session/data/DeviceSessionRefresherConst";import{MutexService as m}from"../../device-session/service/MutexService";import{RefresherService as D}from"../../device-session/service/RefresherService";import{DevicePinger as l}from"./DevicePinger";import{DeviceSessionEventDispatcher as _,SessionEvents as n}from"./DeviceSessionEventDispatcher";import{DeviceSessionRefresher as f}from"./DeviceSessionRefresher";import{DeviceSessionStateHandler as g}from"./DeviceSessionStateHandler";class V{_id;_connectedDevice;_deviceState;_managerApiService;_secureChannelService;_logger;_refresherOptions;_pinger;_deviceSessionRefresher;_refresherService;_commandMutex=new m;_sessionEventDispatcher=new _;constructor({connectedDevice:e,id:s=d()},t,i,r,a){this._id=s,this._connectedDevice=e,this._logger=t("device-session"),this._managerApiService=i,this._secureChannelService=r,this._refresherOptions={...u,...a},this._deviceState=new v({sessionStateType:S.Connected,deviceStatus:c.CONNECTED,deviceModelId:this._connectedDevice.deviceModel.id}),this._pinger=new l(t,e,this._sessionEventDispatcher,(o,p)=>this.sendCommand(o,p)),this._deviceSessionRefresher=new f(t,this._refresherOptions,this._sessionEventDispatcher,this._connectedDevice),new g(t,this._sessionEventDispatcher,this._connectedDevice,this._deviceState,o=>this.setDeviceSessionState(o)),this._refresherService=new D(t,{start:()=>this._deviceSessionRefresher.restartRefresher(),stop:()=>this._deviceSessionRefresher.stopRefresher()})}async initialiseSession(){try{await this._pinger.ping()}catch(e){throw this._logger.error("Error while initialising session",{data:{error:e}}),e}finally{this._refresherOptions.isRefresherDisabled||this._deviceSessionRefresher.startRefresher()}}get id(){return this._id}get connectedDevice(){return this._connectedDevice}get state(){return this._deviceState.asObservable()}getDeviceSessionState(){return this._deviceState.getValue()}setDeviceSessionState(e){this._deviceState.next(e)}async sendApdu(e,s={isPolling:!1,triggersDisconnection:!1,abortTimeout:void 0}){const t=await this._commandMutex.lock();try{this._sessionEventDispatcher.dispatch({eventName:n.DEVICE_STATE_UPDATE_BUSY});const i=await this._connectedDevice.sendApdu(e,s.triggersDisconnection,s.abortTimeout);return i.ifRight(r=>{h.isLockedDeviceResponse(r)?this._sessionEventDispatcher.dispatch({eventName:n.DEVICE_STATE_UPDATE_LOCKED}):this._sessionEventDispatcher.dispatch({eventName:n.DEVICE_STATE_UPDATE_CONNECTED})}).ifLeft(()=>{this._sessionEventDispatcher.dispatch({eventName:n.DEVICE_STATE_UPDATE_CONNECTED})}),i}finally{t()}}async sendCommand(e,s){const t=e.getApdu();return(await this.sendApdu(t.getRawApdu(),{isPolling:!1,triggersDisconnection:e.triggersDisconnection??!1,abortTimeout:s})).caseOf({Left:r=>{throw r},Right:r=>e.parseResponse(r,this._connectedDevice.deviceModel.id)})}executeDeviceAction(e){const{observable:s,cancel:t}=e._execute({sendApdu:async i=>this.sendApdu(i),sendCommand:async(i,r)=>this.sendCommand(i,r),getDeviceModel:()=>this._connectedDevice.deviceModel,getDeviceSessionState:()=>this._deviceState.getValue(),getDeviceSessionStateObservable:()=>this.state,setDeviceSessionState:i=>(this.setDeviceSessionState(i),this._deviceState.getValue()),disableRefresher:i=>this._refresherService.disableRefresher(i),getManagerApiService:()=>this._managerApiService,getSecureChannelService:()=>this._secureChannelService});return{observable:s,cancel:t}}close(){this._updateDeviceStatus(c.NOT_CONNECTED),this._deviceState.complete(),this._deviceSessionRefresher.stopRefresher()}disableRefresher(e){return this._refresherService.disableRefresher(e)}_updateDeviceStatus(e){const s=this._deviceState.getValue();this._deviceState.next({...s,deviceStatus:e})}}export{V as DeviceSession};
 //# sourceMappingURL=DeviceSession.js.map

package/lib/esm/src/internal/device-session/model/DeviceSession.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/device-session/model/DeviceSession.ts"],
-  "sourcesContent": ["import { type Either, Left } from \"purify-ts\";\nimport { BehaviorSubject, type Subscription } from \"rxjs\";\nimport { v4 as uuidv4 } from \"uuid\";\n\nimport { type Command } from \"@api/command/Command\";\nimport { type CommandResult } from \"@api/command/model/CommandResult\";\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { DeviceStatus } from \"@api/device/DeviceStatus\";\nimport {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type ExecuteDeviceActionReturnType,\n} from \"@api/device-action/DeviceAction\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport {\n  type DeviceSessionState,\n  DeviceSessionStateType,\n} from \"@api/device-session/DeviceSessionState\";\nimport { type DeviceSessionId } from \"@api/device-session/types\";\nimport { DeviceBusyError, type DmkError } from \"@api/Error\";\nimport { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { type TransportConnectedDevice } from \"@api/transport/model/TransportConnectedDevice\";\nimport { DEVICE_SESSION_REFRESH_INTERVAL } from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport { RefresherService } from \"@internal/device-session/service/RefresherService\";\nimport { type ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\nimport { type SecureChannelService } from \"@internal/secure-channel/service/SecureChannelService\";\n\nimport { DeviceSessionRefresher } from \"./DeviceSessionRefresher\";\n\nexport type SessionConstructorArgs = {\n  connectedDevice: TransportConnectedDevice;\n  id?: DeviceSessionId;\n};\n\ntype SendApduOptions = {\n  isPolling?: boolean;\n  triggersDisconnection?: boolean;\n};\n\n/**\n * Represents a session with a device.\n */\nexport class DeviceSession {\n  private readonly _id: DeviceSessionId;\n  private readonly _connectedDevice: TransportConnectedDevice;\n  private readonly _deviceState: BehaviorSubject<DeviceSessionState>;\n  private readonly _refresher: DeviceSessionRefresher;\n  private readonly _refresherService: RefresherService;\n  private readonly _managerApiService: ManagerApiService;\n  private readonly _secureChannelService: SecureChannelService;\n  private readonly _readyPromise: Promise<void>;\n  private _resolveReady!: () => void;\n\n  constructor(\n    { connectedDevice, id = uuidv4() }: SessionConstructorArgs,\n    loggerModuleFactory: (tag: string) => LoggerPublisherService,\n    managerApiService: ManagerApiService,\n    secureChannelService: SecureChannelService,\n  ) {\n    this._id = id;\n    this._connectedDevice = connectedDevice;\n    this._deviceState = new BehaviorSubject<DeviceSessionState>({\n      sessionStateType: DeviceSessionStateType.Connected,\n      deviceStatus: DeviceStatus.CONNECTED,\n      deviceModelId: this._connectedDevice.deviceModel.id,\n    });\n    this._refresher = new DeviceSessionRefresher(\n      {\n        refreshInterval: DEVICE_SESSION_REFRESH_INTERVAL,\n        deviceStatus: DeviceStatus.CONNECTED,\n        deviceModelId: this._connectedDevice.deviceModel.id,\n        sendApduFn: (rawApdu: Uint8Array) =>\n          this.sendApdu(rawApdu, {\n            isPolling: true,\n            triggersDisconnection: false,\n          }),\n        updateStateFn: (callback) => {\n          const state = this._deviceState.getValue();\n          this.setDeviceSessionState(callback(state));\n        },\n      },\n      loggerModuleFactory(\"device-session-refresher\"),\n    );\n    this._refresherService = new RefresherService(this._refresher);\n    this._managerApiService = managerApiService;\n    this._secureChannelService = secureChannelService;\n    this._readyPromise = new Promise<void>((resolve) => {\n      this._resolveReady = resolve;\n    });\n    this._refresher.start();\n  }\n\n  public async waitIsReady() {\n    await this._readyPromise;\n  }\n\n  public get id() {\n    return this._id;\n  }\n\n  public get connectedDevice() {\n    return this._connectedDevice;\n  }\n\n  public get state() {\n    return this._deviceState.asObservable();\n  }\n\n  public setDeviceSessionState(state: DeviceSessionState) {\n    this._deviceState.next(state);\n    this._resolveReady();\n  }\n\n  public async sendApdu(\n    rawApdu: Uint8Array,\n    options: SendApduOptions = {\n      isPolling: false,\n      triggersDisconnection: false,\n    },\n  ): Promise<Either<DmkError, ApduResponse>> {\n    let reenableRefresher: () => void;\n    if (!options.isPolling) {\n      reenableRefresher = this._refresherService.disableRefresher(\"sendApdu\");\n      await this.waitUntilReady();\n    }\n\n    const sessionState = this._deviceState.getValue();\n    if (sessionState.deviceStatus === DeviceStatus.BUSY) {\n      return Left(new DeviceBusyError());\n    }\n\n    this.updateDeviceStatus(DeviceStatus.BUSY);\n\n    const errorOrResponse = await this._connectedDevice.sendApdu(\n      rawApdu,\n      options.triggersDisconnection,\n    );\n\n    return errorOrResponse\n      .ifRight((response: ApduResponse) => {\n        if (CommandUtils.isLockedDeviceResponse(response)) {\n          this.updateDeviceStatus(DeviceStatus.LOCKED);\n        } else {\n          this.updateDeviceStatus(DeviceStatus.CONNECTED);\n        }\n\n        if (!options.isPolling && reenableRefresher) {\n          reenableRefresher();\n        }\n      })\n      .ifLeft(() => {\n        this.updateDeviceStatus(DeviceStatus.CONNECTED);\n\n        if (!options.isPolling && reenableRefresher) {\n          reenableRefresher();\n        }\n      });\n  }\n\n  public async sendCommand<Response, Args, ErrorStatusCodes>(\n    command: Command<Response, Args, ErrorStatusCodes>,\n  ): Promise<CommandResult<Response, ErrorStatusCodes>> {\n    const apdu = command.getApdu();\n    const response = await this.sendApdu(apdu.getRawApdu(), {\n      isPolling: false,\n      triggersDisconnection: command.triggersDisconnection ?? false,\n    });\n\n    return response.caseOf({\n      Left: (err) => {\n        throw err;\n      },\n      Right: (r) =>\n        command.parseResponse(r, this._connectedDevice.deviceModel.id),\n    });\n  }\n\n  public executeDeviceAction<\n    Output,\n    Input,\n    Error extends DmkError,\n    IntermediateValue extends DeviceActionIntermediateValue,\n  >(\n    deviceAction: DeviceAction<Output, Input, Error, IntermediateValue>,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> {\n    const { observable, cancel } = deviceAction._execute({\n      sendApdu: async (apdu: Uint8Array) => this.sendApdu(apdu),\n      sendCommand: async <Response, ErrorStatusCodes, Args>(\n        command: Command<Response, ErrorStatusCodes, Args>,\n      ) => this.sendCommand(command),\n      getDeviceSessionState: () => this._deviceState.getValue(),\n      getDeviceSessionStateObservable: () => this.state,\n      setDeviceSessionState: (state: DeviceSessionState) => {\n        this.setDeviceSessionState(state);\n        return this._deviceState.getValue();\n      },\n      disableRefresher: (blockerId: string) =>\n        this._refresherService.disableRefresher(blockerId),\n      getManagerApiService: () => this._managerApiService,\n      getSecureChannelService: () => this._secureChannelService,\n    });\n\n    return {\n      observable,\n      cancel,\n    };\n  }\n\n  public close() {\n    this.updateDeviceStatus(DeviceStatus.NOT_CONNECTED);\n    this._deviceState.complete();\n    this._refresher.stop();\n  }\n\n  public disableRefresher(id: string): () => void {\n    return this._refresherService.disableRefresher(id);\n  }\n\n  private updateDeviceStatus(deviceStatus: DeviceStatus) {\n    const sessionState = this._deviceState.getValue();\n    this._refresher.setDeviceStatus(deviceStatus);\n    this._deviceState.next({\n      ...sessionState,\n      deviceStatus,\n    });\n  }\n\n  private async waitUntilReady() {\n    let deviceStateSub: Subscription;\n\n    await new Promise<void>((resolve) => {\n      deviceStateSub = this._deviceState.subscribe((state) => {\n        if (\n          [DeviceStatus.LOCKED, DeviceStatus.CONNECTED].includes(\n            state.deviceStatus,\n          )\n        ) {\n          deviceStateSub?.unsubscribe();\n          resolve();\n        }\n      });\n    });\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["Left", "BehaviorSubject", "uuidv4", "CommandUtils", "DeviceStatus", "DeviceSessionStateType", "DeviceBusyError", "DEVICE_SESSION_REFRESH_INTERVAL", "RefresherService", "DeviceSessionRefresher", "DeviceSession", "connectedDevice", "id", "loggerModuleFactory", "managerApiService", "secureChannelService", "rawApdu", "callback", "state", "resolve", "options", "reenableRefresher", "response", "command", "apdu", "err", "r", "deviceAction", "observable", "cancel", "blockerId", "deviceStatus", "sessionState", "deviceStateSub"]
+  "sourcesContent": ["import { type Either } from \"purify-ts\";\nimport { BehaviorSubject, type Observable } from \"rxjs\";\nimport { v4 as uuidv4 } from \"uuid\";\n\nimport { type Command } from \"@api/command/Command\";\nimport { type CommandResult } from \"@api/command/model/CommandResult\";\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { DeviceStatus } from \"@api/device/DeviceStatus\";\nimport {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type ExecuteDeviceActionReturnType,\n} from \"@api/device-action/DeviceAction\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport {\n  type DeviceSessionState,\n  DeviceSessionStateType,\n} from \"@api/device-session/DeviceSessionState\";\nimport { type DeviceSessionId } from \"@api/device-session/types\";\nimport { type DmkError } from \"@api/Error\";\nimport { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { type TransportConnectedDevice } from \"@api/transport/model/TransportConnectedDevice\";\nimport { DEVICE_SESSION_REFRESHER_DEFAULT_OPTIONS } from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport { MutexService } from \"@internal/device-session/service/MutexService\";\nimport { RefresherService } from \"@internal/device-session/service/RefresherService\";\nimport { type ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\nimport { type SecureChannelService } from \"@internal/secure-channel/service/SecureChannelService\";\n\nimport { DevicePinger } from \"./DevicePinger\";\nimport {\n  DeviceSessionEventDispatcher,\n  SessionEvents,\n} from \"./DeviceSessionEventDispatcher\";\nimport { DeviceSessionRefresher } from \"./DeviceSessionRefresher\";\nimport { DeviceSessionStateHandler } from \"./DeviceSessionStateHandler\";\n\nexport type SessionConstructorArgs = {\n  connectedDevice: TransportConnectedDevice;\n  id?: DeviceSessionId;\n};\n\nexport type DeviceSessionRefresherOptions = {\n  isRefresherDisabled: boolean;\n  pollingInterval?: number;\n};\n\ntype SendApduOptions = {\n  isPolling?: boolean;\n  triggersDisconnection?: boolean;\n  abortTimeout?: number;\n};\n\n/**\n * Represents a session with a device.\n */\nexport class DeviceSession {\n  private readonly _id: DeviceSessionId;\n  private readonly _connectedDevice: TransportConnectedDevice;\n  private readonly _deviceState: BehaviorSubject<DeviceSessionState>;\n  private readonly _managerApiService: ManagerApiService;\n  private readonly _secureChannelService: SecureChannelService;\n  private readonly _logger: LoggerPublisherService;\n  private readonly _refresherOptions: DeviceSessionRefresherOptions;\n  private _pinger: DevicePinger;\n  private _deviceSessionRefresher: DeviceSessionRefresher;\n  private readonly _refresherService: RefresherService;\n  private _commandMutex = new MutexService();\n  private _sessionEventDispatcher = new DeviceSessionEventDispatcher();\n\n  constructor(\n    { connectedDevice, id = uuidv4() }: SessionConstructorArgs,\n    loggerModuleFactory: (tag: string) => LoggerPublisherService,\n    managerApiService: ManagerApiService,\n    secureChannelService: SecureChannelService,\n    deviceSessionRefresherOptions: DeviceSessionRefresherOptions | undefined,\n  ) {\n    this._id = id;\n    this._connectedDevice = connectedDevice;\n    this._logger = loggerModuleFactory(\"device-session\");\n    this._managerApiService = managerApiService;\n    this._secureChannelService = secureChannelService;\n    this._refresherOptions = {\n      ...DEVICE_SESSION_REFRESHER_DEFAULT_OPTIONS,\n      ...deviceSessionRefresherOptions,\n    };\n    this._deviceState = new BehaviorSubject<DeviceSessionState>({\n      sessionStateType: DeviceSessionStateType.Connected,\n      deviceStatus: DeviceStatus.CONNECTED,\n      deviceModelId: this._connectedDevice.deviceModel.id,\n    });\n\n    this._pinger = new DevicePinger(\n      loggerModuleFactory,\n      connectedDevice,\n      this._sessionEventDispatcher,\n      (command, abortTimeout) => this.sendCommand(command, abortTimeout),\n    );\n    this._deviceSessionRefresher = new DeviceSessionRefresher(\n      loggerModuleFactory,\n      this._refresherOptions,\n      this._sessionEventDispatcher,\n      this._connectedDevice,\n    );\n    new DeviceSessionStateHandler(\n      loggerModuleFactory,\n      this._sessionEventDispatcher,\n      this._connectedDevice,\n      this._deviceState,\n      (state) => this.setDeviceSessionState(state),\n    );\n\n    this._refresherService = new RefresherService(loggerModuleFactory, {\n      start: () => this._deviceSessionRefresher.restartRefresher(),\n      stop: () => this._deviceSessionRefresher.stopRefresher(),\n    });\n  }\n\n  public async initialiseSession(): Promise<void> {\n    try {\n      await this._pinger.ping();\n    } catch (error) {\n      this._logger.error(\"Error while initialising session\", {\n        data: { error },\n      });\n      throw error;\n    } finally {\n      if (!this._refresherOptions.isRefresherDisabled) {\n        this._deviceSessionRefresher.startRefresher();\n      }\n    }\n  }\n\n  public get id(): DeviceSessionId {\n    return this._id;\n  }\n\n  public get connectedDevice(): TransportConnectedDevice {\n    return this._connectedDevice;\n  }\n\n  public get state(): Observable<DeviceSessionState> {\n    return this._deviceState.asObservable();\n  }\n\n  public getDeviceSessionState(): DeviceSessionState {\n    return this._deviceState.getValue();\n  }\n\n  public setDeviceSessionState(state: DeviceSessionState): void {\n    this._deviceState.next(state);\n  }\n\n  public async sendApdu(\n    rawApdu: Uint8Array,\n    options: SendApduOptions = {\n      isPolling: false,\n      triggersDisconnection: false,\n      abortTimeout: undefined,\n    },\n  ): Promise<Either<DmkError, ApduResponse>> {\n    const release = await this._commandMutex.lock();\n\n    try {\n      this._sessionEventDispatcher.dispatch({\n        eventName: SessionEvents.DEVICE_STATE_UPDATE_BUSY,\n      });\n      const result = await this._connectedDevice.sendApdu(\n        rawApdu,\n        options.triggersDisconnection,\n        options.abortTimeout,\n      );\n\n      result\n        .ifRight((response: ApduResponse) => {\n          if (CommandUtils.isLockedDeviceResponse(response)) {\n            this._sessionEventDispatcher.dispatch({\n              eventName: SessionEvents.DEVICE_STATE_UPDATE_LOCKED,\n            });\n          } else {\n            this._sessionEventDispatcher.dispatch({\n              eventName: SessionEvents.DEVICE_STATE_UPDATE_CONNECTED,\n            });\n          }\n        })\n        .ifLeft(() => {\n          this._sessionEventDispatcher.dispatch({\n            eventName: SessionEvents.DEVICE_STATE_UPDATE_CONNECTED,\n          });\n        });\n      return result;\n    } finally {\n      release();\n    }\n  }\n\n  public async sendCommand<Response, Args, ErrorStatusCodes>(\n    command: Command<Response, Args, ErrorStatusCodes>,\n    abortTimeout?: number,\n  ): Promise<CommandResult<Response, ErrorStatusCodes>> {\n    const apdu = command.getApdu();\n\n    const response = await this.sendApdu(apdu.getRawApdu(), {\n      isPolling: false,\n      triggersDisconnection: command.triggersDisconnection ?? false,\n      abortTimeout,\n    });\n\n    return response.caseOf({\n      Left: (err) => {\n        throw err;\n      },\n      Right: (r) =>\n        command.parseResponse(r, this._connectedDevice.deviceModel.id),\n    });\n  }\n\n  public executeDeviceAction<\n    Output,\n    Input,\n    E extends DmkError,\n    IntermediateValue extends DeviceActionIntermediateValue,\n  >(\n    deviceAction: DeviceAction<Output, Input, E, IntermediateValue>,\n  ): ExecuteDeviceActionReturnType<Output, E, IntermediateValue> {\n    const { observable, cancel } = deviceAction._execute({\n      sendApdu: async (apdu: Uint8Array) => this.sendApdu(apdu),\n      sendCommand: async <Response, ErrorStatusCodes, Args>(\n        command: Command<Response, ErrorStatusCodes, Args>,\n        abortTimeout?: number,\n      ) => this.sendCommand(command, abortTimeout),\n      getDeviceModel: () => this._connectedDevice.deviceModel,\n      getDeviceSessionState: () => this._deviceState.getValue(),\n      getDeviceSessionStateObservable: () => this.state,\n      setDeviceSessionState: (state: DeviceSessionState) => {\n        this.setDeviceSessionState(state);\n        return this._deviceState.getValue();\n      },\n      disableRefresher: (blockerId: string) =>\n        this._refresherService.disableRefresher(blockerId),\n      getManagerApiService: () => this._managerApiService,\n      getSecureChannelService: () => this._secureChannelService,\n    });\n    return { observable, cancel };\n  }\n\n  public close(): void {\n    this._updateDeviceStatus(DeviceStatus.NOT_CONNECTED);\n    this._deviceState.complete();\n    this._deviceSessionRefresher.stopRefresher();\n  }\n\n  public disableRefresher(id: string): () => void {\n    return this._refresherService.disableRefresher(id);\n  }\n\n  private _updateDeviceStatus(deviceStatus: DeviceStatus): void {\n    const state = this._deviceState.getValue();\n    this._deviceState.next({ ...state, deviceStatus });\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["BehaviorSubject", "uuidv4", "CommandUtils", "DeviceStatus", "DeviceSessionStateType", "DEVICE_SESSION_REFRESHER_DEFAULT_OPTIONS", "MutexService", "RefresherService", "DevicePinger", "DeviceSessionEventDispatcher", "SessionEvents", "DeviceSessionRefresher", "DeviceSessionStateHandler", "DeviceSession", "connectedDevice", "id", "loggerModuleFactory", "managerApiService", "secureChannelService", "deviceSessionRefresherOptions", "command", "abortTimeout", "state", "error", "rawApdu", "options", "release", "result", "response", "apdu", "err", "deviceAction", "observable", "cancel", "blockerId", "deviceStatus"]
 }

package/lib/esm/src/internal/device-session/model/DeviceSession.stub.js

@@ -1,2 +1,2 @@
-import{connectedDeviceStubBuilder as n}from"../../../api/transport/model/TransportConnectedDevice.stub";import{DeviceSession as t}from"../../device-session/model/DeviceSession";const a=(e={},r,i,o)=>new t({connectedDevice:n(),id:"fakeSessionId",...e},r,i,o);export{a as deviceSessionStubBuilder};
+import{connectedDeviceStubBuilder as s}from"../../../api/transport/model/TransportConnectedDevice.stub";import{DeviceSession as t}from"../../device-session/model/DeviceSession";const p=(e={},r,i,o,n)=>new t({connectedDevice:s(),id:"fakeSessionId",...e},r,i,o,n);export{p as deviceSessionStubBuilder};
 //# sourceMappingURL=DeviceSession.stub.js.map

package/lib/esm/src/internal/device-session/model/DeviceSession.stub.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/device-session/model/DeviceSession.stub.ts"],
-  "sourcesContent": ["import { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { connectedDeviceStubBuilder } from \"@api/transport/model/TransportConnectedDevice.stub\";\nimport {\n  DeviceSession,\n  type SessionConstructorArgs,\n} from \"@internal/device-session/model/DeviceSession\";\nimport type { ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\nimport { type SecureChannelService } from \"@internal/secure-channel/service/SecureChannelService\";\n\nexport const deviceSessionStubBuilder = (\n  props: Partial<SessionConstructorArgs> = {},\n  loggerFactory: (tag: string) => LoggerPublisherService,\n  managerApi: ManagerApiService,\n  secureChannel: SecureChannelService,\n) =>\n  new DeviceSession(\n    {\n      connectedDevice: connectedDeviceStubBuilder(),\n      id: \"fakeSessionId\",\n      ...props,\n    },\n    loggerFactory,\n    managerApi,\n    secureChannel,\n  );\n"],
-  "mappings": "AACA,OAAS,8BAAAA,MAAkC,qDAC3C,OACE,iBAAAC,MAEK,+CAIA,MAAMC,EAA2B,CACtCC,EAAyC,CAAC,EAC1CC,EACAC,EACAC,IAEA,IAAIL,EACF,CACE,gBAAiBD,EAA2B,EAC5C,GAAI,gBACJ,GAAGG,CACL,EACAC,EACAC,EACAC,CACF",
-  "names": ["connectedDeviceStubBuilder", "DeviceSession", "deviceSessionStubBuilder", "props", "loggerFactory", "managerApi", "secureChannel"]
+  "sourcesContent": ["import { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { connectedDeviceStubBuilder } from \"@api/transport/model/TransportConnectedDevice.stub\";\nimport {\n  DeviceSession,\n  type DeviceSessionRefresherOptions,\n  type SessionConstructorArgs,\n} from \"@internal/device-session/model/DeviceSession\";\nimport type { ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\nimport { type SecureChannelService } from \"@internal/secure-channel/service/SecureChannelService\";\n\nexport const deviceSessionStubBuilder = (\n  props: Partial<SessionConstructorArgs> = {},\n  loggerFactory: (tag: string) => LoggerPublisherService,\n  managerApi: ManagerApiService,\n  secureChannel: SecureChannelService,\n  deviceSessionRefresherOptions: DeviceSessionRefresherOptions,\n) =>\n  new DeviceSession(\n    {\n      connectedDevice: connectedDeviceStubBuilder(),\n      id: \"fakeSessionId\",\n      ...props,\n    },\n    loggerFactory,\n    managerApi,\n    secureChannel,\n    deviceSessionRefresherOptions,\n  );\n"],
+  "mappings": "AACA,OAAS,8BAAAA,MAAkC,qDAC3C,OACE,iBAAAC,MAGK,+CAIA,MAAMC,EAA2B,CACtCC,EAAyC,CAAC,EAC1CC,EACAC,EACAC,EACAC,IAEA,IAAIN,EACF,CACE,gBAAiBD,EAA2B,EAC5C,GAAI,gBACJ,GAAGG,CACL,EACAC,EACAC,EACAC,EACAC,CACF",
+  "names": ["connectedDeviceStubBuilder", "DeviceSession", "deviceSessionStubBuilder", "props", "loggerFactory", "managerApi", "secureChannel", "deviceSessionRefresherOptions"]
 }

package/lib/esm/src/internal/device-session/model/DeviceSessionEventDispatcher.js

@@ -0,0 +1,2 @@
+import{Subject as n}from"rxjs";var t=(e=>(e.NEW_STATE="NEW_STATE",e.REFRESH_NEEDED="REFRESH_NEEDED",e.COMMAND_SUCCEEDED="COMMAND_SUCCEEDED",e.DEVICE_STATE_UPDATE_BUSY="DEVICE_STATE_UPDATE_BUSY",e.DEVICE_STATE_UPDATE_LOCKED="DEVICE_STATE_UPDATE_LOCKED",e.DEVICE_STATE_UPDATE_CONNECTED="DEVICE_STATE_UPDATE_CONNECTED",e))(t||{});class s{_eventEmitter=new n;listen(){return this._eventEmitter.asObservable()}dispatch(E){this._eventEmitter.next(E)}}export{s as DeviceSessionEventDispatcher,t as SessionEvents};
+//# sourceMappingURL=DeviceSessionEventDispatcher.js.map

package/lib/esm/src/internal/device-session/model/DeviceSessionEventDispatcher.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/device-session/model/DeviceSessionEventDispatcher.ts"],
+  "sourcesContent": ["import { type Observable, Subject } from \"rxjs\";\n\nimport { type GetAppAndVersionResponse } from \"@api/index\";\nimport { type CommandResult } from \"@api/types\";\n\nexport enum SessionEvents {\n  NEW_STATE = \"NEW_STATE\",\n  REFRESH_NEEDED = \"REFRESH_NEEDED\",\n  COMMAND_SUCCEEDED = \"COMMAND_SUCCEEDED\",\n  DEVICE_STATE_UPDATE_BUSY = \"DEVICE_STATE_UPDATE_BUSY\",\n  DEVICE_STATE_UPDATE_LOCKED = \"DEVICE_STATE_UPDATE_LOCKED\",\n  DEVICE_STATE_UPDATE_CONNECTED = \"DEVICE_STATE_UPDATE_CONNECTED\",\n}\n\ninterface SessionEventPayloads {\n  [SessionEvents.NEW_STATE]: undefined;\n  [SessionEvents.REFRESH_NEEDED]: undefined;\n  [SessionEvents.DEVICE_STATE_UPDATE_BUSY]: undefined;\n  [SessionEvents.DEVICE_STATE_UPDATE_LOCKED]: undefined;\n  [SessionEvents.DEVICE_STATE_UPDATE_CONNECTED]: undefined;\n  [SessionEvents.COMMAND_SUCCEEDED]: CommandResult<GetAppAndVersionResponse>;\n}\n\nexport type NewEvent = {\n  [K in SessionEvents]: SessionEventPayloads[K] extends undefined\n    ? { eventName: K; eventData?: undefined }\n    : { eventName: K; eventData: SessionEventPayloads[K] };\n}[SessionEvents];\n\nexport class DeviceSessionEventDispatcher {\n  private _eventEmitter: Subject<NewEvent> = new Subject();\n\n  public listen(): Observable<NewEvent> {\n    return this._eventEmitter.asObservable();\n  }\n\n  public dispatch(event: NewEvent): void {\n    this._eventEmitter.next(event);\n  }\n}\n"],
+  "mappings": "AAAA,OAA0B,WAAAA,MAAe,OAKlC,IAAKC,OACVA,EAAA,UAAY,YACZA,EAAA,eAAiB,iBACjBA,EAAA,kBAAoB,oBACpBA,EAAA,yBAA2B,2BAC3BA,EAAA,2BAA6B,6BAC7BA,EAAA,8BAAgC,gCANtBA,OAAA,IAwBL,MAAMC,CAA6B,CAChC,cAAmC,IAAIF,EAExC,QAA+B,CACpC,OAAO,KAAK,cAAc,aAAa,CACzC,CAEO,SAASG,EAAuB,CACrC,KAAK,cAAc,KAAKA,CAAK,CAC/B,CACF",
+  "names": ["Subject", "SessionEvents", "DeviceSessionEventDispatcher", "event"]
+}

package/lib/esm/src/internal/device-session/model/DeviceSessionEventDispatcher.test.js

@@ -0,0 +1,2 @@
+import{describe as u,expect as E,it as d}from"vitest";import{DeviceSessionEventDispatcher as p,SessionEvents as c}from"./DeviceSessionEventDispatcher";u("DeviceSessionEventDispatcher",()=>{let s;beforeEach(()=>{s=new p}),d("should dispatch and receive an event without payload",()=>new Promise((i,a)=>{const e={eventName:c.REFRESH_NEEDED,eventData:void 0},t=s.listen().subscribe(o=>{try{E(o).toEqual(e),i(void 0)}catch(n){a(n)}finally{t.unsubscribe()}});s.dispatch(e)})),d("should dispatch and receive a COMMAND_SUCCEEDED event with payload",()=>new Promise((i,a)=>{const e={status:"success",data:{someField:"dummyValue"}},t={eventName:c.COMMAND_SUCCEEDED,eventData:e},o=s.listen().subscribe(n=>{if(n.eventName===c.COMMAND_SUCCEEDED)try{E(n).toEqual(t),i(void 0)}catch(r){a(r)}finally{o.unsubscribe()}});s.dispatch(t)})),d("should dispatch multiple events",()=>new Promise((i,a)=>{const e=[{eventName:c.DEVICE_STATE_UPDATE_BUSY,eventData:void 0},{eventName:c.DEVICE_STATE_UPDATE_CONNECTED,eventData:void 0}],t=[],o=s.listen().subscribe(n=>{if(t.push(n),t.length===e.length)try{E(t).toEqual(e),i(void 0)}catch(r){a(r)}finally{o.unsubscribe()}});e.forEach(n=>s.dispatch(n))}))});
+//# sourceMappingURL=DeviceSessionEventDispatcher.test.js.map

package/lib/esm/src/internal/device-session/model/DeviceSessionEventDispatcher.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/device-session/model/DeviceSessionEventDispatcher.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from \"vitest\";\n\nimport { type GetAppAndVersionResponse } from \"@api/index\";\nimport type { CommandResult } from \"@api/types\";\n\nimport {\n  DeviceSessionEventDispatcher,\n  type NewEvent,\n  SessionEvents,\n} from \"./DeviceSessionEventDispatcher\";\n\ndescribe(\"DeviceSessionEventDispatcher\", () => {\n  let dispatcher: DeviceSessionEventDispatcher;\n\n  beforeEach(() => {\n    dispatcher = new DeviceSessionEventDispatcher();\n  });\n\n  it(\"should dispatch and receive an event without payload\", () =>\n    new Promise((resolve, reject) => {\n      // given\n      const expectedEvent: NewEvent = {\n        eventName: SessionEvents.REFRESH_NEEDED,\n        eventData: undefined,\n      };\n\n      // when\n      const subscription = dispatcher.listen().subscribe((event) => {\n        // then\n        try {\n          expect(event).toEqual(expectedEvent);\n          resolve(undefined);\n        } catch (error) {\n          reject(error);\n        } finally {\n          subscription.unsubscribe();\n        }\n      });\n\n      dispatcher.dispatch(expectedEvent);\n    }));\n\n  it(\"should dispatch and receive a COMMAND_SUCCEEDED event with payload\", () =>\n    new Promise((resolve, reject) => {\n      // given\n      const dummyCommandResult = {\n        status: \"success\",\n        data: { someField: \"dummyValue\" },\n      } as unknown as CommandResult<GetAppAndVersionResponse>;\n\n      const expectedEvent: NewEvent = {\n        eventName: SessionEvents.COMMAND_SUCCEEDED,\n        eventData: dummyCommandResult,\n      };\n\n      // when\n      const subscription = dispatcher.listen().subscribe((event) => {\n        if (event.eventName === SessionEvents.COMMAND_SUCCEEDED) {\n          // then\n          try {\n            expect(event).toEqual(expectedEvent);\n            resolve(undefined);\n          } catch (error) {\n            reject(error);\n          } finally {\n            subscription.unsubscribe();\n          }\n        }\n      });\n\n      dispatcher.dispatch(expectedEvent);\n    }));\n\n  it(\"should dispatch multiple events\", () =>\n    new Promise((resolve, reject) => {\n      // given\n      const events: NewEvent[] = [\n        {\n          eventName: SessionEvents.DEVICE_STATE_UPDATE_BUSY,\n          eventData: undefined,\n        },\n        {\n          eventName: SessionEvents.DEVICE_STATE_UPDATE_CONNECTED,\n          eventData: undefined,\n        },\n      ];\n      const received: NewEvent[] = [];\n\n      // when\n      const subscription = dispatcher.listen().subscribe((event) => {\n        received.push(event);\n\n        // then\n        if (received.length === events.length) {\n          try {\n            expect(received).toEqual(events);\n            resolve(undefined);\n          } catch (error) {\n            reject(error);\n          } finally {\n            subscription.unsubscribe();\n          }\n        }\n      });\n\n      events.forEach((event) => dispatcher.dispatch(event));\n    }));\n});\n"],
+  "mappings": "AAAA,OAAS,YAAAA,EAAU,UAAAC,EAAQ,MAAAC,MAAU,SAKrC,OACE,gCAAAC,EAEA,iBAAAC,MACK,iCAEPJ,EAAS,+BAAgC,IAAM,CAC7C,IAAIK,EAEJ,WAAW,IAAM,CACfA,EAAa,IAAIF,CACnB,CAAC,EAEDD,EAAG,uDAAwD,IACzD,IAAI,QAAQ,CAACI,EAASC,IAAW,CAE/B,MAAMC,EAA0B,CAC9B,UAAWJ,EAAc,eACzB,UAAW,MACb,EAGMK,EAAeJ,EAAW,OAAO,EAAE,UAAWK,GAAU,CAE5D,GAAI,CACFT,EAAOS,CAAK,EAAE,QAAQF,CAAa,EACnCF,EAAQ,MAAS,CACnB,OAASK,EAAO,CACdJ,EAAOI,CAAK,CACd,QAAE,CACAF,EAAa,YAAY,CAC3B,CACF,CAAC,EAEDJ,EAAW,SAASG,CAAa,CACnC,CAAC,CAAC,EAEJN,EAAG,qEAAsE,IACvE,IAAI,QAAQ,CAACI,EAASC,IAAW,CAE/B,MAAMK,EAAqB,CACzB,OAAQ,UACR,KAAM,CAAE,UAAW,YAAa,CAClC,EAEMJ,EAA0B,CAC9B,UAAWJ,EAAc,kBACzB,UAAWQ,CACb,EAGMH,EAAeJ,EAAW,OAAO,EAAE,UAAWK,GAAU,CAC5D,GAAIA,EAAM,YAAcN,EAAc,kBAEpC,GAAI,CACFH,EAAOS,CAAK,EAAE,QAAQF,CAAa,EACnCF,EAAQ,MAAS,CACnB,OAASK,EAAO,CACdJ,EAAOI,CAAK,CACd,QAAE,CACAF,EAAa,YAAY,CAC3B,CAEJ,CAAC,EAEDJ,EAAW,SAASG,CAAa,CACnC,CAAC,CAAC,EAEJN,EAAG,kCAAmC,IACpC,IAAI,QAAQ,CAACI,EAASC,IAAW,CAE/B,MAAMM,EAAqB,CACzB,CACE,UAAWT,EAAc,yBACzB,UAAW,MACb,EACA,CACE,UAAWA,EAAc,8BACzB,UAAW,MACb,CACF,EACMU,EAAuB,CAAC,EAGxBL,EAAeJ,EAAW,OAAO,EAAE,UAAWK,GAAU,CAI5D,GAHAI,EAAS,KAAKJ,CAAK,EAGfI,EAAS,SAAWD,EAAO,OAC7B,GAAI,CACFZ,EAAOa,CAAQ,EAAE,QAAQD,CAAM,EAC/BP,EAAQ,MAAS,CACnB,OAASK,EAAO,CACdJ,EAAOI,CAAK,CACd,QAAE,CACAF,EAAa,YAAY,CAC3B,CAEJ,CAAC,EAEDI,EAAO,QAASH,GAAUL,EAAW,SAASK,CAAK,CAAC,CACtD,CAAC,CAAC,CACN,CAAC",
+  "names": ["describe", "expect", "it", "DeviceSessionEventDispatcher", "SessionEvents", "dispatcher", "resolve", "reject", "expectedEvent", "subscription", "event", "error", "dummyCommandResult", "events", "received"]
+}

package/lib/esm/src/internal/device-session/model/DeviceSessionRefresher.js

@@ -1,2 +1,2 @@
-var h=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var u=(p,r,t,e)=>{for(var s=e>1?void 0:e?v(r,t):r,i=p.length-1,n;i>=0;i--)(n=p[i])&&(s=(e?n(r,t,s):n(s))||s);return e&&s&&h(r,t,s),s};import{injectable as _}from"inversify";import{delay as b,filter as l,from as S,map as c,of as A,race as f,switchMap as d,timer as m}from"rxjs";import{isSuccessCommandResult as g}from"../../../api/command/model/CommandResult";import{GetAppAndVersionCommand as O}from"../../../api/command/os/GetAppAndVersionCommand";import{GetOsVersionCommand as y}from"../../../api/command/os/GetOsVersionCommand";import{DeviceModelId as D}from"../../../api/device/DeviceModel";import{DeviceStatus as o}from"../../../api/device/DeviceStatus";import{DeviceSessionStateType as C}from"../../../api/device-session/DeviceSessionState";let a=class{_logger;_getAppAndVersionCommand=new O;_getOsVersionCommand=new y;_deviceStatus;_subscription;_refreshInterval;_deviceModelId;_sendApduFn;_updateStateFn;constructor({refreshInterval:r,deviceStatus:t,sendApduFn:e,updateStateFn:s,deviceModelId:i},n){this._deviceStatus=t,this._logger=n,this._sendApduFn=e,this._updateStateFn=s,this._refreshInterval=r,this._deviceModelId=i}start(){if(this._subscription&&!this._subscription.closed){this._logger.warn("Refresher already started");return}const r=this._deviceModelId===D.NANO_S?this._getNanoSRefreshObservable(this._refreshInterval*2):this._getDefaultRefreshObservable(m(0,this._refreshInterval));this._subscription=r.subscribe(t=>{!t||!g(t)||this._updateStateFn(e=>({...e,sessionStateType:C.ReadyWithoutSecureChannel,deviceStatus:this._deviceStatus,currentApp:t.data,installedApps:"installedApps"in e?e.installedApps:[],isSecureConnectionAllowed:"isSecureConnectionAllowed"in e?e.isSecureConnectionAllowed:!1}))})}_getDefaultRefreshObservable(r=S([0])){return r.pipe(l(()=>![o.BUSY,o.NOT_CONNECTED].includes(this._deviceStatus)),d(async()=>{const t=this._getAppAndVersionCommand.getApdu().getRawApdu();return await this._sendApduFn(t)}),c(t=>t.caseOf({Left:e=>(this._logger.error("Error in sending APDU when polling",{data:{error:e}}),null),Right:e=>{try{return this._getAppAndVersionCommand.parseResponse(e)}catch(s){return this._logger.error("Error in parsing APDU response",{data:{error:s}}),null}}})),l(t=>t!==null))}_getNanoSRefreshObservable(r){const t=this._getDefaultRefreshObservable().pipe(d(async s=>{const i=this._getOsVersionCommand.getApdu().getRawApdu();return await this._sendApduFn(i),s})),e=A(null).pipe(b(r),c(s=>{this._logger.warn("Nanos refresh timeout, setting device status to LOCKED"),this._updateStateFn(i=>({...i,deviceStatus:o.LOCKED}))}));return m(0,r+100).pipe(d(()=>f(t,e)))}setDeviceStatus(r){r===o.NOT_CONNECTED&&this.stop(),this._deviceStatus=r}stop(){!this._subscription||this._subscription.closed||(this._subscription.unsubscribe(),this._subscription=void 0)}};a=u([_()],a);export{a as DeviceSessionRefresher};
+import{timer as n}from"rxjs";import{DeviceModelId as c}from"../../../api/device/DeviceModel";import{DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL as t,DEVICE_SESSION_REFRESHER_POLLING_INTERVAL as o}from"../../device-session/data/DeviceSessionRefresherConst";import{SessionEvents as h}from"../../device-session/model/DeviceSessionEventDispatcher";class d{constructor(i,s,e,r){this._sessionEventDispatcher=e;this._refresherOptions=s,this._logger=i("device-session-refresher"),this._connectedDeviceID=r.deviceModel.id}_refresherSubscription;_refresherOptions;_logger;_connectedDeviceID;startRefresher(){if(this._refresherOptions.isRefresherDisabled)return;const i=this.getValidPollingInterval(this._refresherOptions,this._logger)*2;this._refresherSubscription=n(0,i).subscribe(()=>{this._sessionEventDispatcher.dispatch({eventName:h.REFRESH_NEEDED})})}stopRefresher(){this._refresherSubscription&&(this._refresherSubscription.unsubscribe(),this._refresherSubscription=void 0,this._logger.info("Refresher stopped."))}restartRefresher(){this.stopRefresher(),this.startRefresher(),this._logger.info("Refresher restarted.")}destroy(){this.stopRefresher()}getValidPollingInterval=(i,s)=>{const{pollingInterval:e}=i;switch(this._connectedDeviceID){case c.NANO_S:{const r=o*2;return e!==void 0&&e<r?(s.warn(`Polling interval of ${e} is too low, setting to minimum as ${r}`),r):e??r}default:return e!==void 0&&e<t?(s.warn(`Polling interval of ${e} is too low, setting to minimum as ${t}`),t):e??o}}}export{d as DeviceSessionRefresher};
 //# sourceMappingURL=DeviceSessionRefresher.js.map

package/lib/esm/src/internal/device-session/model/DeviceSessionRefresher.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/device-session/model/DeviceSessionRefresher.ts"],
-  "sourcesContent": ["import { injectable } from \"inversify\";\nimport { Either } from \"purify-ts\";\nimport {\n  delay,\n  filter,\n  from,\n  map,\n  Observable,\n  of,\n  race,\n  Subscription,\n  switchMap,\n  timer,\n} from \"rxjs\";\n\nimport { isSuccessCommandResult } from \"@api/command/model/CommandResult\";\nimport {\n  GetAppAndVersionCommand,\n  GetAppAndVersionCommandResult,\n} from \"@api/command/os/GetAppAndVersionCommand\";\nimport { GetOsVersionCommand } from \"@api/command/os/GetOsVersionCommand\";\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { DeviceStatus } from \"@api/device/DeviceStatus\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\nimport {\n  DeviceSessionState,\n  DeviceSessionStateType,\n} from \"@api/device-session/DeviceSessionState\";\nimport { DmkError } from \"@api/Error\";\nimport { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { SendApduFnType } from \"@api/transport/model/DeviceConnection\";\n\ntype UpdateStateFnType = (\n  callback: (state: DeviceSessionState) => DeviceSessionState,\n) => void;\n\n/**\n * The arguments for the DeviceSessionRefresher.\n */\nexport type DeviceSessionRefresherArgs = {\n  /**\n   * The refresh interval in milliseconds.\n   */\n  refreshInterval: number;\n\n  /**\n   * The current device status when the refresher is created.\n   */\n  deviceStatus: Exclude<DeviceStatus, DeviceStatus.NOT_CONNECTED>;\n\n  /**\n   * The function used to send APDU commands to the device.\n   */\n  sendApduFn: (rawApdu: Uint8Array) => Promise<Either<DmkError, ApduResponse>>;\n\n  /**\n   * Callback that updates the state of the device session with\n   * polling response.\n   * @param callback - A function that will take the previous state and return the new state.\n   * @returns void\n   */\n  updateStateFn: UpdateStateFnType;\n\n  /**\n   * Device model to handle NanoS specific refresher\n   */\n  deviceModelId: DeviceModelId;\n};\n\n/**\n * The session refresher that periodically sends a command to refresh the session.\n */\n@injectable()\nexport class DeviceSessionRefresher {\n  private readonly _logger: LoggerPublisherService;\n  private readonly _getAppAndVersionCommand = new GetAppAndVersionCommand();\n  private readonly _getOsVersionCommand = new GetOsVersionCommand();\n  private _deviceStatus: DeviceStatus;\n  private _subscription?: Subscription;\n  private readonly _refreshInterval: number;\n  private readonly _deviceModelId: DeviceModelId;\n  private readonly _sendApduFn: SendApduFnType;\n  private readonly _updateStateFn: UpdateStateFnType;\n\n  constructor(\n    {\n      refreshInterval,\n      deviceStatus,\n      sendApduFn,\n      updateStateFn,\n      deviceModelId,\n    }: DeviceSessionRefresherArgs,\n    logger: LoggerPublisherService,\n  ) {\n    this._deviceStatus = deviceStatus;\n    this._logger = logger;\n    this._sendApduFn = sendApduFn;\n    this._updateStateFn = updateStateFn;\n    this._refreshInterval = refreshInterval;\n    this._deviceModelId = deviceModelId;\n  }\n\n  /**\n   * Start the session refresher.\n   * The refresher will send commands to refresh the session.\n   */\n  start() {\n    if (this._subscription && !this._subscription.closed) {\n      this._logger.warn(\"Refresher already started\");\n      return;\n    }\n\n    // NanoS has a specific refresher that sends GetAppAndVersion and GetOsVersion commands\n    const refreshObservable =\n      this._deviceModelId === DeviceModelId.NANO_S\n        ? this._getNanoSRefreshObservable(this._refreshInterval * 2)\n        : this._getDefaultRefreshObservable(timer(0, this._refreshInterval));\n\n    this._subscription = refreshObservable.subscribe((parsedResponse) => {\n      if (!parsedResponse || !isSuccessCommandResult(parsedResponse)) {\n        return;\n      }\n      // `batteryStatus` and `firmwareVersion` are not available in the polling response.\n      this._updateStateFn((state) => ({\n        ...state,\n        sessionStateType: DeviceSessionStateType.ReadyWithoutSecureChannel,\n        deviceStatus: this._deviceStatus,\n        currentApp: parsedResponse.data,\n        installedApps: \"installedApps\" in state ? state.installedApps : [],\n        isSecureConnectionAllowed:\n          \"isSecureConnectionAllowed\" in state\n            ? state.isSecureConnectionAllowed\n            : false,\n      }));\n    });\n  }\n\n  /**\n   * Creates an observable that refreshes a device state with GetAppAndVersion command result.\n   *\n   * @param {ObservableInput<number>} parentObservable - The parent observable to base the refresh observable on. Defaults to an array with a single number [0].\n   * @return {Observable<GetAppAndVersionCommandResult>} An observable that emits the result of the GetAppAndVersionCommand.\n   */\n  private _getDefaultRefreshObservable(\n    parentObservable: Observable<number> = from([0]),\n  ): Observable<GetAppAndVersionCommandResult> {\n    return parentObservable.pipe(\n      filter(\n        () =>\n          ![DeviceStatus.BUSY, DeviceStatus.NOT_CONNECTED].includes(\n            this._deviceStatus,\n          ),\n      ),\n      switchMap(async () => {\n        const rawApdu = this._getAppAndVersionCommand.getApdu().getRawApdu();\n        return await this._sendApduFn(rawApdu);\n      }),\n      map((resp) =>\n        resp.caseOf({\n          Left: (error) => {\n            this._logger.error(\"Error in sending APDU when polling\", {\n              data: { error },\n            });\n            return null;\n          },\n          Right: (data: ApduResponse) => {\n            try {\n              return this._getAppAndVersionCommand.parseResponse(data);\n            } catch (error) {\n              this._logger.error(\"Error in parsing APDU response\", {\n                data: { error },\n              });\n              return null;\n            }\n          },\n        }),\n      ),\n      filter((parsedResponse) => parsedResponse !== null),\n    );\n  }\n\n  /**\n   * Creates an observable that emits events to refresh the NanoS device state.\n   *\n   * @param {number} refreshInterval - The interval, in milliseconds, at which the NanoS state should be refreshed.\n   * @return {Observable<GetAppAndVersionCommandResult | void>} An observable that emits events to refresh the NanoS device state and handle timeout scenarios.\n   */\n  private _getNanoSRefreshObservable(\n    refreshInterval: number,\n  ): Observable<GetAppAndVersionCommandResult | void> {\n    const nanoSRefreshObservable = this._getDefaultRefreshObservable().pipe(\n      switchMap(async (resp) => {\n        const rawApdu = this._getOsVersionCommand.getApdu().getRawApdu();\n        await this._sendApduFn(rawApdu);\n        return resp;\n      }),\n    );\n    const timeoutObservable = of(null).pipe(\n      delay(refreshInterval),\n      map((_) => {\n        this._logger.warn(\n          \"Nanos refresh timeout, setting device status to LOCKED\",\n        );\n        this._updateStateFn((state) => ({\n          ...state,\n          deviceStatus: DeviceStatus.LOCKED,\n        }));\n      }),\n    );\n    return timer(0, refreshInterval + 100).pipe(\n      switchMap(() => race(nanoSRefreshObservable, timeoutObservable)),\n    );\n  }\n\n  /**\n   * Maintain a device status to prevent sending APDU when the device is busy.\n   *\n   * @param {DeviceStatus} deviceStatus - The new device status.\n   */\n  setDeviceStatus(deviceStatus: DeviceStatus) {\n    if (deviceStatus === DeviceStatus.NOT_CONNECTED) {\n      this.stop();\n    }\n    this._deviceStatus = deviceStatus;\n  }\n\n  /**\n   * Stops the session refresher.\n   * The refresher will no longer send commands to refresh the session.\n   */\n  stop() {\n    if (!this._subscription || this._subscription.closed) {\n      return;\n    }\n    this._subscription.unsubscribe();\n    this._subscription = undefined;\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["injectable", "delay", "filter", "from", "map", "of", "race", "switchMap", "timer", "isSuccessCommandResult", "GetAppAndVersionCommand", "GetOsVersionCommand", "DeviceModelId", "DeviceStatus", "DeviceSessionStateType", "DeviceSessionRefresher", "GetAppAndVersionCommand", "GetOsVersionCommand", "refreshInterval", "deviceStatus", "sendApduFn", "updateStateFn", "deviceModelId", "logger", "refreshObservable", "DeviceModelId", "timer", "parsedResponse", "isSuccessCommandResult", "state", "DeviceSessionStateType", "parentObservable", "from", "filter", "DeviceStatus", "switchMap", "rawApdu", "map", "resp", "error", "data", "nanoSRefreshObservable", "timeoutObservable", "of", "delay", "_", "race", "__decorateClass", "injectable"]
+  "sourcesContent": ["import { type Subscription, timer } from \"rxjs\";\n\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { type TransportConnectedDevice } from \"@api/transport/model/TransportConnectedDevice\";\nimport { type LoggerPublisherService } from \"@api/types\";\nimport {\n  DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL,\n  DEVICE_SESSION_REFRESHER_POLLING_INTERVAL,\n} from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport {\n  type DeviceSessionEventDispatcher,\n  SessionEvents,\n} from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\n\nexport interface DeviceSessionRefresherOptions {\n  isRefresherDisabled: boolean;\n  pollingInterval?: number;\n}\n\nexport class DeviceSessionRefresher {\n  private _refresherSubscription!: Subscription | undefined;\n  private _refresherOptions: DeviceSessionRefresherOptions;\n  private readonly _logger: LoggerPublisherService;\n  private _connectedDeviceID: DeviceModelId;\n\n  constructor(\n    loggerModuleFactory: (tag: string) => LoggerPublisherService,\n    refresherOptions: DeviceSessionRefresherOptions,\n    private _sessionEventDispatcher: DeviceSessionEventDispatcher,\n    connectedDevice: TransportConnectedDevice,\n  ) {\n    this._refresherOptions = refresherOptions;\n    this._logger = loggerModuleFactory(\"device-session-refresher\");\n    this._connectedDeviceID = connectedDevice.deviceModel.id;\n  }\n\n  public startRefresher(): void {\n    if (this._refresherOptions.isRefresherDisabled) return;\n\n    const pollingInterval =\n      this.getValidPollingInterval(this._refresherOptions, this._logger) * 2;\n\n    this._refresherSubscription = timer(0, pollingInterval).subscribe(() => {\n      this._sessionEventDispatcher.dispatch({\n        eventName: SessionEvents.REFRESH_NEEDED,\n      });\n    });\n  }\n\n  public stopRefresher(): void {\n    if (this._refresherSubscription) {\n      this._refresherSubscription.unsubscribe();\n      this._refresherSubscription = undefined;\n      this._logger.info(\"Refresher stopped.\");\n    }\n  }\n\n  public restartRefresher(): void {\n    this.stopRefresher();\n    this.startRefresher();\n    this._logger.info(\"Refresher restarted.\");\n  }\n\n  public destroy(): void {\n    this.stopRefresher();\n  }\n\n  private getValidPollingInterval = (\n    refresherOptions: DeviceSessionRefresherOptions,\n    logger: LoggerPublisherService,\n  ): number => {\n    const { pollingInterval } = refresherOptions;\n    switch (this._connectedDeviceID) {\n      case DeviceModelId.NANO_S: {\n        const defaultNanoPollingInterval =\n          DEVICE_SESSION_REFRESHER_POLLING_INTERVAL * 2;\n        if (\n          pollingInterval !== undefined &&\n          pollingInterval < defaultNanoPollingInterval\n        ) {\n          logger.warn(\n            `Polling interval of ${pollingInterval} is too low, setting to minimum as ${defaultNanoPollingInterval}`,\n          );\n          return defaultNanoPollingInterval;\n        }\n        return pollingInterval ?? defaultNanoPollingInterval;\n      }\n      default:\n        if (\n          pollingInterval !== undefined &&\n          pollingInterval < DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL\n        ) {\n          logger.warn(\n            `Polling interval of ${pollingInterval} is too low, setting to minimum as ${DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL}`,\n          );\n          return DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL;\n        }\n\n        return pollingInterval ?? DEVICE_SESSION_REFRESHER_POLLING_INTERVAL;\n    }\n  };\n}\n"],
+  "mappings": "AAAA,OAA4B,SAAAA,MAAa,OAEzC,OAAS,iBAAAC,MAAqB,0BAG9B,OACE,qDAAAC,EACA,6CAAAC,MACK,4DACP,OAEE,iBAAAC,MACK,8DAOA,MAAMC,CAAuB,CAMlC,YACEC,EACAC,EACQC,EACRC,EACA,CAFQ,6BAAAD,EAGR,KAAK,kBAAoBD,EACzB,KAAK,QAAUD,EAAoB,0BAA0B,EAC7D,KAAK,mBAAqBG,EAAgB,YAAY,EACxD,CAdQ,uBACA,kBACS,QACT,mBAaD,gBAAuB,CAC5B,GAAI,KAAK,kBAAkB,oBAAqB,OAEhD,MAAMC,EACJ,KAAK,wBAAwB,KAAK,kBAAmB,KAAK,OAAO,EAAI,EAEvE,KAAK,uBAAyBV,EAAM,EAAGU,CAAe,EAAE,UAAU,IAAM,CACtE,KAAK,wBAAwB,SAAS,CACpC,UAAWN,EAAc,cAC3B,CAAC,CACH,CAAC,CACH,CAEO,eAAsB,CACvB,KAAK,yBACP,KAAK,uBAAuB,YAAY,EACxC,KAAK,uBAAyB,OAC9B,KAAK,QAAQ,KAAK,oBAAoB,EAE1C,CAEO,kBAAyB,CAC9B,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,QAAQ,KAAK,sBAAsB,CAC1C,CAEO,SAAgB,CACrB,KAAK,cAAc,CACrB,CAEQ,wBAA0B,CAChCG,EACAI,IACW,CACX,KAAM,CAAE,gBAAAD,CAAgB,EAAIH,EAC5B,OAAQ,KAAK,mBAAoB,CAC/B,KAAKN,EAAc,OAAQ,CACzB,MAAMW,EACJT,EAA4C,EAC9C,OACEO,IAAoB,QACpBA,EAAkBE,GAElBD,EAAO,KACL,uBAAuBD,CAAe,sCAAsCE,CAA0B,EACxG,EACOA,GAEFF,GAAmBE,CAC5B,CACA,QACE,OACEF,IAAoB,QACpBA,EAAkBR,GAElBS,EAAO,KACL,uBAAuBD,CAAe,sCAAsCR,CAAiD,EAC/H,EACOA,GAGFQ,GAAmBP,CAC9B,CACF,CACF",
+  "names": ["timer", "DeviceModelId", "DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL", "DEVICE_SESSION_REFRESHER_POLLING_INTERVAL", "SessionEvents", "DeviceSessionRefresher", "loggerModuleFactory", "refresherOptions", "_sessionEventDispatcher", "connectedDevice", "pollingInterval", "logger", "defaultNanoPollingInterval"]
 }

package/lib/esm/src/internal/device-session/model/DeviceSessionRefresher.test.js

@@ -1,2 +1,2 @@
-import{Left as v,Right as m}from"purify-ts";import{CommandResultFactory as u}from"../../../api/command/model/CommandResult";import{GetAppAndVersionCommand as p}from"../../../api/command/os/GetAppAndVersionCommand";import{GetOsVersionCommand as l}from"../../../api/command/os/GetOsVersionCommand";import{DeviceModelId as n}from"../../../api/device/DeviceModel";import{DeviceStatus as a}from"../../../api/device/DeviceStatus";import{DEVICE_SESSION_REFRESH_INTERVAL as s}from"../../device-session/data/DeviceSessionRefresherConst";import{DefaultLoggerPublisherService as h}from"../../logger-publisher/service/DefaultLoggerPublisherService";import{DeviceSessionRefresher as c}from"./DeviceSessionRefresher";describe("DeviceSessionRefresher",()=>{const t=vi.fn(),o=vi.fn();let e,r;beforeEach(()=>{vi.clearAllMocks(),vi.useFakeTimers(),vi.spyOn(p.prototype,"parseResponse").mockReturnValueOnce(u({data:{name:"testAppName"}})),vi.spyOn(l.prototype,"parseResponse").mockReturnValueOnce(u({data:{}})),t.mockResolvedValue(m({})),o.mockImplementation(()=>{}),r=new h([],"DeviceSessionRefresherTest")}),describe("With a modern device",()=>{beforeEach(()=>{const i=Object.values(n).filter(d=>d!==n.NANO_S);e=new c({refreshInterval:s,deviceStatus:a.CONNECTED,sendApduFn:t,updateStateFn:o,deviceModelId:i[Math.floor(Math.random()*i.length)]},r),e.start()}),afterEach(()=>{e.stop()}),it("should poll by calling sendApduFn 3 times",()=>{vi.advanceTimersByTime(s*2),expect(t).toHaveBeenCalledTimes(3)}),it("should not poll when device is busy",()=>{e.setDeviceStatus(a.BUSY),vi.advanceTimersByTime(s),expect(t).not.toHaveBeenCalled()}),it("should not poll when device is disconnected",()=>{e.setDeviceStatus(a.NOT_CONNECTED),vi.advanceTimersByTime(s),expect(t).not.toHaveBeenCalled()}),it("should update device session state by calling updateStateFn",async()=>{vi.advanceTimersByTime(s),await Promise.resolve(),expect(t).toHaveBeenCalled(),await Promise.resolve(),expect(o).toHaveBeenCalled()}),it("should not update device session state with failed polling response",async()=>{t.mockResolvedValue(v("error")),vi.advanceTimersByTime(s),await Promise.resolve(),expect(t).toHaveBeenCalled(),await Promise.resolve(),expect(o).not.toHaveBeenCalled()}),it("should stop the refresher when device is disconnected",()=>{const i=vi.spyOn(e,"stop");e.setDeviceStatus(a.NOT_CONNECTED),expect(i).toHaveBeenCalledTimes(1)}),it("should not throw error if stop is called on a stopped refresher",()=>{e.stop(),expect(()=>e.stop()).not.toThrow()}),it("should not throw error if start is called on a started refresher",()=>{e.start(),expect(()=>e.start()).not.toThrow()})}),describe("With a NanoS device",()=>{afterEach(()=>{e.stop()}),it("should call sendApduFn 3 times and update state 2 time for a single interval",async()=>{e=new c({refreshInterval:s,deviceStatus:a.CONNECTED,sendApduFn:t,updateStateFn:o,deviceModelId:n.NANO_S},r),e.start(),vi.advanceTimersByTime(s*2+100),await Promise.resolve(),expect(t).toHaveBeenNthCalledWith(1,new p().getApdu().getRawApdu()),await Promise.resolve(),expect(t).toHaveBeenLastCalledWith(new l().getApdu().getRawApdu()),await Promise.resolve(),expect(t).toHaveBeenCalledTimes(3),await Promise.resolve(),expect(o).toHaveBeenCalledTimes(2)}),it("should set device locked when get os version times out",async()=>{t.mockImplementation(i=>i.toString()===new l().getApdu().getRawApdu().toString()?new Promise(d=>setTimeout(()=>d(v("timeout")),s*10)):Promise.resolve(m({}))),o.mockImplementation(i=>{e.setDeviceStatus(i().deviceStatus)}),e=new c({refreshInterval:s,deviceStatus:a.CONNECTED,sendApduFn:t,updateStateFn:o,deviceModelId:n.NANO_S},r),e.start(),vi.spyOn(e,"setDeviceStatus"),vi.advanceTimersByTime(s*5+100),await Promise.resolve(),expect(t).toHaveBeenNthCalledWith(1,new p().getApdu().getRawApdu()),await Promise.resolve(),expect(e.setDeviceStatus).toHaveBeenCalledWith(a.LOCKED)})})});
+import{Subject as u}from"rxjs";import{afterEach as D,beforeEach as S,describe as y,expect as n,it as l,vi as t}from"vitest";import{DeviceModelId as h}from"../../../api/device/DeviceModel";import{DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL as p,DEVICE_SESSION_REFRESHER_POLLING_INTERVAL as E}from"../../device-session/data/DeviceSessionRefresherConst";import{SessionEvents as w}from"../../device-session/model/DeviceSessionEventDispatcher";import{DeviceSessionRefresher as c}from"./DeviceSessionRefresher";y("DeviceSessionRefresher",()=>{let d,s,o;const f={deviceModel:{id:h.FLEX}},m={deviceModel:{id:h.NANO_S}},i=t.fn(()=>o);let e;S(()=>{t.useFakeTimers(),d=new u,s={listen:()=>d.asObservable(),dispatch:t.fn()},o={info:t.fn(),warn:t.fn(),error:t.fn(),debug:t.fn(),subscribers:[]}}),D(()=>{e?.destroy(),t.useRealTimers(),t.restoreAllMocks()}),l("should not start refresher if disabled",()=>{const r={isRefresherDisabled:!0,pollingInterval:1e3};e=new c(i,r,s,f),e.startRefresher(),t.advanceTimersByTime(2e3),n(s.dispatch).not.toHaveBeenCalled()}),l("should warn and use minimum polling interval for default device when provided interval is too low",()=>{const r=p-100,a={isRefresherDisabled:!1,pollingInterval:r};e=new c(i,a,s,f),e.startRefresher();const v=`Polling interval of ${r} is too low, setting to minimum as ${p}`;n(o.warn).toHaveBeenCalledWith(v)}),l("should warn and use minimum polling interval for NANO_S device when provided interval is too low",()=>{const r=E*2,a=r-100,v={isRefresherDisabled:!1,pollingInterval:a};e=new c(i,v,s,m),e.startRefresher();const R=`Polling interval of ${a} is too low, setting to minimum as ${r}`;n(o.warn).toHaveBeenCalledWith(R)}),l("should not warn when provided polling interval is valid for default device",()=>{const a={isRefresherDisabled:!1,pollingInterval:p+100};e=new c(i,a,s,f),e.startRefresher(),n(o.warn).not.toHaveBeenCalled()}),l("should dispatch refresh event on timer ticks",()=>{const r=p+100,a={isRefresherDisabled:!1,pollingInterval:r};e=new c(i,a,s,f),e.startRefresher();const v=r*2;t.advanceTimersByTime(v*3),n(s.dispatch.mock.calls.length).toBe(4),n(s.dispatch.mock.calls[0][0]).toEqual({eventName:w.REFRESH_NEEDED})}),l("should stop refresher",()=>{const r={isRefresherDisabled:!1,pollingInterval:1e3};e=new c(i,r,s,f),e.startRefresher(),s.dispatch.mockClear(),e.stopRefresher(),t.advanceTimersByTime(2e3),n(s.dispatch).not.toHaveBeenCalled(),n(o.info).toHaveBeenCalledWith("Refresher stopped.")}),l("should restart refresher",()=>{const r={isRefresherDisabled:!1,pollingInterval:1e3};e=new c(i,r,s,f),e.startRefresher(),s.dispatch.mockClear(),t.clearAllTimers(),e.restartRefresher(),n(o.info).toHaveBeenCalledWith("Refresher stopped."),n(o.info).toHaveBeenCalledWith("Refresher restarted."),t.advanceTimersByTime(2e3),n(s.dispatch.mock.calls.length).toBeGreaterThan(0)}),l("should destroy refresher",()=>{const r={isRefresherDisabled:!1,pollingInterval:1e3};e=new c(i,r,s,f),e.startRefresher(),e.destroy(),t.advanceTimersByTime(2e3),n(s.dispatch).not.toHaveBeenCalled()})});
 //# sourceMappingURL=DeviceSessionRefresher.test.js.map

package/lib/esm/src/internal/device-session/model/DeviceSessionRefresher.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/device-session/model/DeviceSessionRefresher.test.ts"],
-  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { type Apdu } from \"@api/apdu/model/Apdu\";\nimport { CommandResultFactory } from \"@api/command/model/CommandResult\";\nimport {\n  GetAppAndVersionCommand,\n  type GetAppAndVersionResponse,\n} from \"@api/command/os/GetAppAndVersionCommand\";\nimport {\n  GetOsVersionCommand,\n  type GetOsVersionResponse,\n} from \"@api/command/os/GetOsVersionCommand\";\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { DeviceStatus } from \"@api/device/DeviceStatus\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { type DeviceSessionState } from \"@api/device-session/DeviceSessionState\";\nimport { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { DEVICE_SESSION_REFRESH_INTERVAL } from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/DefaultLoggerPublisherService\";\n\nimport { DeviceSessionRefresher } from \"./DeviceSessionRefresher\";\n\ndescribe(\"DeviceSessionRefresher\", () => {\n  const mockSendApduFn = vi.fn();\n  const mockUpdateStateFn = vi.fn();\n\n  let deviceSessionRefresher: DeviceSessionRefresher;\n  let logger: LoggerPublisherService;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n    vi.useFakeTimers();\n    vi.spyOn(\n      GetAppAndVersionCommand.prototype,\n      \"parseResponse\",\n    ).mockReturnValueOnce(\n      CommandResultFactory({\n        data: {\n          name: \"testAppName\",\n        } as GetAppAndVersionResponse,\n      }),\n    );\n    vi.spyOn(\n      GetOsVersionCommand.prototype,\n      \"parseResponse\",\n    ).mockReturnValueOnce(\n      CommandResultFactory({\n        data: {} as GetOsVersionResponse,\n      }),\n    );\n    mockSendApduFn.mockResolvedValue(Right({} as ApduResponse));\n    mockUpdateStateFn.mockImplementation(() => undefined);\n    logger = new DefaultLoggerPublisherService(\n      [],\n      \"DeviceSessionRefresherTest\",\n    );\n  });\n\n  describe(\"With a modern device\", () => {\n    beforeEach(() => {\n      const deviceIds = Object.values(DeviceModelId).filter(\n        (id) => id !== DeviceModelId.NANO_S,\n      );\n      deviceSessionRefresher = new DeviceSessionRefresher(\n        {\n          refreshInterval: DEVICE_SESSION_REFRESH_INTERVAL,\n          deviceStatus: DeviceStatus.CONNECTED,\n          sendApduFn: mockSendApduFn,\n          updateStateFn: mockUpdateStateFn,\n          deviceModelId:\n            deviceIds[Math.floor(Math.random() * deviceIds.length)]!,\n        },\n        logger,\n      );\n      deviceSessionRefresher.start();\n    });\n\n    afterEach(() => {\n      deviceSessionRefresher.stop();\n    });\n\n    it(\"should poll by calling sendApduFn 3 times\", () => {\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL * 2);\n      expect(mockSendApduFn).toHaveBeenCalledTimes(3);\n    });\n\n    it(\"should not poll when device is busy\", () => {\n      deviceSessionRefresher.setDeviceStatus(DeviceStatus.BUSY);\n\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL);\n\n      expect(mockSendApduFn).not.toHaveBeenCalled();\n    });\n\n    it(\"should not poll when device is disconnected\", () => {\n      deviceSessionRefresher.setDeviceStatus(DeviceStatus.NOT_CONNECTED);\n\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL);\n\n      expect(mockSendApduFn).not.toHaveBeenCalled();\n    });\n\n    it(\"should update device session state by calling updateStateFn\", async () => {\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL);\n\n      await Promise.resolve();\n      expect(mockSendApduFn).toHaveBeenCalled();\n      await Promise.resolve();\n      expect(mockUpdateStateFn).toHaveBeenCalled();\n    });\n\n    it(\"should not update device session state with failed polling response\", async () => {\n      mockSendApduFn.mockResolvedValue(Left(\"error\"));\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL);\n\n      await Promise.resolve();\n      expect(mockSendApduFn).toHaveBeenCalled();\n      await Promise.resolve();\n      expect(mockUpdateStateFn).not.toHaveBeenCalled();\n    });\n\n    it(\"should stop the refresher when device is disconnected\", () => {\n      const spy = vi.spyOn(deviceSessionRefresher, \"stop\");\n      deviceSessionRefresher.setDeviceStatus(DeviceStatus.NOT_CONNECTED);\n      expect(spy).toHaveBeenCalledTimes(1);\n    });\n\n    it(\"should not throw error if stop is called on a stopped refresher\", () => {\n      deviceSessionRefresher.stop();\n      expect(() => deviceSessionRefresher.stop()).not.toThrow();\n    });\n\n    it(\"should not throw error if start is called on a started refresher\", () => {\n      deviceSessionRefresher.start();\n      expect(() => deviceSessionRefresher.start()).not.toThrow();\n    });\n  });\n\n  describe(\"With a NanoS device\", () => {\n    afterEach(() => {\n      deviceSessionRefresher.stop();\n    });\n\n    it(\"should call sendApduFn 3 times and update state 2 time for a single interval\", async () => {\n      deviceSessionRefresher = new DeviceSessionRefresher(\n        {\n          refreshInterval: DEVICE_SESSION_REFRESH_INTERVAL,\n          deviceStatus: DeviceStatus.CONNECTED,\n          sendApduFn: mockSendApduFn,\n          updateStateFn: mockUpdateStateFn,\n          deviceModelId: DeviceModelId.NANO_S,\n        },\n        logger,\n      );\n      deviceSessionRefresher.start();\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL * 2 + 100);\n\n      await Promise.resolve();\n      expect(mockSendApduFn).toHaveBeenNthCalledWith(\n        1,\n        new GetAppAndVersionCommand().getApdu().getRawApdu(),\n      );\n      await Promise.resolve();\n      expect(mockSendApduFn).toHaveBeenLastCalledWith(\n        new GetOsVersionCommand().getApdu().getRawApdu(),\n      );\n      await Promise.resolve();\n      expect(mockSendApduFn).toHaveBeenCalledTimes(3);\n      await Promise.resolve();\n      expect(mockUpdateStateFn).toHaveBeenCalledTimes(2);\n    });\n\n    it(\"should set device locked when get os version times out\", async () => {\n      mockSendApduFn.mockImplementation((apdu: Apdu) => {\n        if (\n          apdu.toString() ===\n          new GetOsVersionCommand().getApdu().getRawApdu().toString()\n        ) {\n          return new Promise((resolve) =>\n            setTimeout(\n              () => resolve(Left(\"timeout\")),\n              DEVICE_SESSION_REFRESH_INTERVAL * 10,\n            ),\n          );\n        }\n        return Promise.resolve(Right({}));\n      });\n      mockUpdateStateFn.mockImplementation(\n        (getState: () => DeviceSessionState) => {\n          deviceSessionRefresher.setDeviceStatus(getState().deviceStatus);\n        },\n      );\n      deviceSessionRefresher = new DeviceSessionRefresher(\n        {\n          refreshInterval: DEVICE_SESSION_REFRESH_INTERVAL,\n          deviceStatus: DeviceStatus.CONNECTED,\n          sendApduFn: mockSendApduFn,\n          updateStateFn: mockUpdateStateFn,\n          deviceModelId: DeviceModelId.NANO_S,\n        },\n        logger,\n      );\n      deviceSessionRefresher.start();\n      vi.spyOn(deviceSessionRefresher, \"setDeviceStatus\");\n      vi.advanceTimersByTime(DEVICE_SESSION_REFRESH_INTERVAL * 5 + 100);\n      await Promise.resolve();\n      expect(mockSendApduFn).toHaveBeenNthCalledWith(\n        1,\n        new GetAppAndVersionCommand().getApdu().getRawApdu(),\n      );\n      await Promise.resolve();\n      expect(deviceSessionRefresher.setDeviceStatus).toHaveBeenCalledWith(\n        DeviceStatus.LOCKED,\n      );\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["Left", "Right", "CommandResultFactory", "GetAppAndVersionCommand", "GetOsVersionCommand", "DeviceModelId", "DeviceStatus", "DEVICE_SESSION_REFRESH_INTERVAL", "DefaultLoggerPublisherService", "DeviceSessionRefresher", "mockSendApduFn", "mockUpdateStateFn", "deviceSessionRefresher", "logger", "deviceIds", "id", "spy", "apdu", "resolve", "getState"]
+  "sourcesContent": ["import { Subject } from \"rxjs\";\nimport { afterEach, beforeEach, describe, expect, it, vi } from \"vitest\";\n\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { type TransportConnectedDevice } from \"@api/transport/model/TransportConnectedDevice\";\nimport type { LoggerPublisherService } from \"@api/types\";\nimport {\n  DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL,\n  DEVICE_SESSION_REFRESHER_POLLING_INTERVAL,\n} from \"@internal/device-session/data/DeviceSessionRefresherConst\";\nimport type {\n  DeviceSessionEventDispatcher,\n  NewEvent,\n} from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\nimport { SessionEvents } from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\n\nimport {\n  DeviceSessionRefresher,\n  type DeviceSessionRefresherOptions,\n} from \"./DeviceSessionRefresher\";\n\ndescribe(\"DeviceSessionRefresher\", () => {\n  let subject: Subject<NewEvent>;\n  let mockSessionEventDispatcher: DeviceSessionEventDispatcher;\n  let mockLogger: LoggerPublisherService & {\n    info: ReturnType<typeof vi.fn>;\n    warn: ReturnType<typeof vi.fn>;\n    error: ReturnType<typeof vi.fn>;\n    debug: ReturnType<typeof vi.fn>;\n    subscribers?: unknown[];\n  };\n\n  const stubDefaultDevice = {\n    deviceModel: {\n      id: DeviceModelId.FLEX,\n    },\n  } as TransportConnectedDevice;\n\n  const stubNanoSDevice = {\n    deviceModel: {\n      id: DeviceModelId.NANO_S,\n    },\n  } as TransportConnectedDevice;\n\n  const mockedLoggerModuleFactory = vi.fn(() => mockLogger);\n  let refresher: DeviceSessionRefresher;\n\n  beforeEach(() => {\n    vi.useFakeTimers();\n    subject = new Subject<NewEvent>();\n    mockSessionEventDispatcher = {\n      listen: () => subject.asObservable(),\n      dispatch: vi.fn(),\n    } as unknown as DeviceSessionEventDispatcher;\n    mockLogger = {\n      info: vi.fn(),\n      warn: vi.fn(),\n      error: vi.fn(),\n      debug: vi.fn(),\n      subscribers: [],\n    };\n  });\n\n  afterEach(() => {\n    refresher?.destroy();\n    vi.useRealTimers();\n    vi.restoreAllMocks();\n  });\n\n  it(\"should not start refresher if disabled\", () => {\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: true,\n      pollingInterval: 1000,\n    };\n\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n    vi.advanceTimersByTime(2000);\n\n    expect(mockSessionEventDispatcher.dispatch).not.toHaveBeenCalled();\n  });\n\n  it(\"should warn and use minimum polling interval for default device when provided interval is too low\", () => {\n    const lowInterval = DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL - 100;\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: lowInterval,\n    };\n\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n\n    const expectedMessage = `Polling interval of ${lowInterval} is too low, setting to minimum as ${DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL}`;\n    expect(mockLogger.warn).toHaveBeenCalledWith(expectedMessage);\n  });\n\n  it(\"should warn and use minimum polling interval for NANO_S device when provided interval is too low\", () => {\n    const defaultNanoPollingInterval =\n      DEVICE_SESSION_REFRESHER_POLLING_INTERVAL * 2;\n    const lowInterval = defaultNanoPollingInterval - 100;\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: lowInterval,\n    };\n\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubNanoSDevice,\n    );\n    refresher.startRefresher();\n\n    const expectedMessage = `Polling interval of ${lowInterval} is too low, setting to minimum as ${defaultNanoPollingInterval}`;\n    expect(mockLogger.warn).toHaveBeenCalledWith(expectedMessage);\n  });\n\n  it(\"should not warn when provided polling interval is valid for default device\", () => {\n    const validInterval =\n      DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL + 100;\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: validInterval,\n    };\n\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n\n    expect(mockLogger.warn).not.toHaveBeenCalled();\n  });\n\n  it(\"should dispatch refresh event on timer ticks\", () => {\n    const validInterval =\n      DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL + 100;\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: validInterval,\n    };\n\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n\n    const timerInterval = validInterval * 2;\n\n    vi.advanceTimersByTime(timerInterval * 3);\n\n    expect(\n      (mockSessionEventDispatcher.dispatch as ReturnType<typeof vi.fn>).mock\n        .calls.length,\n    ).toBe(4);\n    expect(\n      (mockSessionEventDispatcher.dispatch as ReturnType<typeof vi.fn>).mock\n        .calls[0]![0],\n    ).toEqual({\n      eventName: SessionEvents.REFRESH_NEEDED,\n    });\n  });\n\n  it(\"should stop refresher\", () => {\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: 1000,\n    };\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n    (\n      mockSessionEventDispatcher.dispatch as ReturnType<typeof vi.fn>\n    ).mockClear();\n\n    refresher.stopRefresher();\n    vi.advanceTimersByTime(2000);\n\n    expect(mockSessionEventDispatcher.dispatch).not.toHaveBeenCalled();\n    expect(mockLogger.info).toHaveBeenCalledWith(\"Refresher stopped.\");\n  });\n\n  it(\"should restart refresher\", () => {\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: 1000,\n    };\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n    (\n      mockSessionEventDispatcher.dispatch as ReturnType<typeof vi.fn>\n    ).mockClear();\n    vi.clearAllTimers();\n\n    refresher.restartRefresher();\n    expect(mockLogger.info).toHaveBeenCalledWith(\"Refresher stopped.\");\n    expect(mockLogger.info).toHaveBeenCalledWith(\"Refresher restarted.\");\n\n    vi.advanceTimersByTime(2000);\n    expect(\n      (mockSessionEventDispatcher.dispatch as ReturnType<typeof vi.fn>).mock\n        .calls.length,\n    ).toBeGreaterThan(0);\n  });\n\n  it(\"should destroy refresher\", () => {\n    const options: DeviceSessionRefresherOptions = {\n      isRefresherDisabled: false,\n      pollingInterval: 1000,\n    };\n    refresher = new DeviceSessionRefresher(\n      mockedLoggerModuleFactory,\n      options,\n      mockSessionEventDispatcher,\n      stubDefaultDevice,\n    );\n    refresher.startRefresher();\n\n    refresher.destroy();\n    vi.advanceTimersByTime(2000);\n\n    expect(mockSessionEventDispatcher.dispatch).not.toHaveBeenCalled();\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["Subject", "afterEach", "beforeEach", "describe", "expect", "it", "vi", "DeviceModelId", "DEVICE_SESSION_REFRESHER_MINIMUM_POLLING_INTERVAL", "DEVICE_SESSION_REFRESHER_POLLING_INTERVAL", "SessionEvents", "DeviceSessionRefresher", "subject", "mockSessionEventDispatcher", "mockLogger", "stubDefaultDevice", "stubNanoSDevice", "mockedLoggerModuleFactory", "refresher", "options", "lowInterval", "expectedMessage", "defaultNanoPollingInterval", "validInterval", "timerInterval"]
 }

package/lib/esm/src/internal/device-session/model/DeviceSessionStateHandler.js

@@ -0,0 +1,2 @@
+import{DeviceSessionStateType as o,DeviceStatus as i,isSuccessCommandResult as v}from"../../../api/index";import{SessionEvents as s}from"../../device-session/model/DeviceSessionEventDispatcher";class d{constructor(e,n,a,c,r){this._sessionEventDispatcher=n;this._connectedDevice=a;this._deviceState=c;this.setDeviceSessionState=r;this._subscription=this._sessionEventDispatcher.listen().subscribe(t=>this.mapEventAction(t)),this._logger=e("device-session-state-handler")}_subscription;_logger;_updateDeviceState(e){const n=this._parseDeviceStatus(e);if(n){const{sessionStateType:a,deviceStatus:c,currentApp:r}=n,t=this._deviceState.getValue();t.sessionStateType===o.Connected?this.setDeviceSessionState({sessionStateType:a,deviceStatus:c,deviceModelId:this._connectedDevice.deviceModel.id,currentApp:r,installedApps:[],isSecureConnectionAllowed:!1}):this.setDeviceSessionState({...t,sessionStateType:a,deviceStatus:c,deviceModelId:this._connectedDevice.deviceModel.id,currentApp:r})}}mapEventAction=e=>{switch(e.eventName){case s.COMMAND_SUCCEEDED:return this._updateDeviceState(e.eventData);case s.DEVICE_STATE_UPDATE_BUSY:return this.setDeviceSessionState({...this._deviceState.getValue(),deviceStatus:i.BUSY});case s.DEVICE_STATE_UPDATE_LOCKED:return this.setDeviceSessionState({...this._deviceState.getValue(),deviceStatus:i.LOCKED});case s.DEVICE_STATE_UPDATE_CONNECTED:return this.setDeviceSessionState({...this._deviceState.getValue(),deviceStatus:i.CONNECTED});default:return null}};_parseDeviceStatus(e){return v(e)?{sessionStateType:o.ReadyWithoutSecureChannel,deviceStatus:i.CONNECTED,currentApp:{name:e.data.name,version:e.data.version}}:(this._logger.debug("Error while parsing APDU response",{data:{parsedResponse:e}}),null)}unsubscribe(){this._subscription.unsubscribe()}}export{d as DeviceSessionStateHandler};
+//# sourceMappingURL=DeviceSessionStateHandler.js.map

package/lib/esm/src/internal/device-session/model/DeviceSessionStateHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/device-session/model/DeviceSessionStateHandler.ts"],
+  "sourcesContent": ["import { type BehaviorSubject, type Subscription } from \"rxjs\";\n\nimport { type DeviceSessionState } from \"@api/device-session/DeviceSessionState\";\nimport {\n  DeviceSessionStateType,\n  DeviceStatus,\n  type GetAppAndVersionResponse,\n  isSuccessCommandResult,\n  type TransportConnectedDevice,\n} from \"@api/index\";\nimport { type CommandResult, type LoggerPublisherService } from \"@api/types\";\nimport {\n  type DeviceSessionEventDispatcher,\n  type NewEvent,\n  SessionEvents,\n} from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\n\nexport type SetDeviceSessionStateFn = (state: DeviceSessionState) => void;\n\ntype NewDeviceStatus = {\n  sessionStateType: DeviceSessionStateType;\n  deviceStatus: DeviceStatus;\n  currentApp: {\n    name: string;\n    version: string;\n  };\n};\n\nexport class DeviceSessionStateHandler {\n  private _subscription: Subscription;\n  private readonly _logger: LoggerPublisherService;\n\n  constructor(\n    loggerModuleFactory: (tag: string) => LoggerPublisherService,\n    private _sessionEventDispatcher: DeviceSessionEventDispatcher,\n    private _connectedDevice: TransportConnectedDevice,\n    private _deviceState: BehaviorSubject<DeviceSessionState>,\n    private setDeviceSessionState: SetDeviceSessionStateFn,\n  ) {\n    this._subscription = this._sessionEventDispatcher\n      .listen()\n      .subscribe((event) => this.mapEventAction(event));\n    this._logger = loggerModuleFactory(\"device-session-state-handler\");\n  }\n\n  private _updateDeviceState(\n    parsedResponse: CommandResult<GetAppAndVersionResponse>,\n  ): void {\n    const newDeviceStatus = this._parseDeviceStatus(parsedResponse);\n\n    if (newDeviceStatus) {\n      const { sessionStateType, deviceStatus, currentApp } = newDeviceStatus;\n      const state = this._deviceState.getValue();\n      if (state.sessionStateType === DeviceSessionStateType.Connected) {\n        // When device is connected, initialize fields to default values\n        this.setDeviceSessionState({\n          sessionStateType,\n          deviceStatus,\n          deviceModelId: this._connectedDevice.deviceModel.id,\n          currentApp,\n          installedApps: [],\n          isSecureConnectionAllowed: false,\n        });\n      } else {\n        // When device is ready, keep un-modified state fields\n        this.setDeviceSessionState({\n          ...state,\n          sessionStateType,\n          deviceStatus,\n          deviceModelId: this._connectedDevice.deviceModel.id,\n          currentApp,\n        });\n      }\n    }\n  }\n\n  private mapEventAction = (event: NewEvent) => {\n    switch (event.eventName) {\n      case SessionEvents.COMMAND_SUCCEEDED:\n        return this._updateDeviceState(event.eventData);\n      case SessionEvents.DEVICE_STATE_UPDATE_BUSY:\n        return this.setDeviceSessionState({\n          ...this._deviceState.getValue(),\n          deviceStatus: DeviceStatus.BUSY,\n        });\n      case SessionEvents.DEVICE_STATE_UPDATE_LOCKED:\n        return this.setDeviceSessionState({\n          ...this._deviceState.getValue(),\n          deviceStatus: DeviceStatus.LOCKED,\n        });\n      case SessionEvents.DEVICE_STATE_UPDATE_CONNECTED:\n        return this.setDeviceSessionState({\n          ...this._deviceState.getValue(),\n          deviceStatus: DeviceStatus.CONNECTED,\n        });\n      default:\n        return null;\n    }\n  };\n\n  private _parseDeviceStatus(\n    parsedResponse: CommandResult<GetAppAndVersionResponse>,\n  ): NewDeviceStatus | null {\n    if (isSuccessCommandResult(parsedResponse)) {\n      return {\n        sessionStateType: DeviceSessionStateType.ReadyWithoutSecureChannel,\n        deviceStatus: DeviceStatus.CONNECTED,\n        currentApp: {\n          name: parsedResponse.data.name,\n          version: parsedResponse.data.version,\n        },\n      };\n    } else {\n      this._logger.debug(\"Error while parsing APDU response\", {\n        data: { parsedResponse },\n      });\n      return null;\n    }\n  }\n\n  public unsubscribe(): void {\n    this._subscription.unsubscribe();\n  }\n}\n"],
+  "mappings": "AAGA,OACE,0BAAAA,EACA,gBAAAC,EAEA,0BAAAC,MAEK,aAEP,OAGE,iBAAAC,MACK,8DAaA,MAAMC,CAA0B,CAIrC,YACEC,EACQC,EACAC,EACAC,EACAC,EACR,CAJQ,6BAAAH,EACA,sBAAAC,EACA,kBAAAC,EACA,2BAAAC,EAER,KAAK,cAAgB,KAAK,wBACvB,OAAO,EACP,UAAWC,GAAU,KAAK,eAAeA,CAAK,CAAC,EAClD,KAAK,QAAUL,EAAoB,8BAA8B,CACnE,CAdQ,cACS,QAeT,mBACNM,EACM,CACN,MAAMC,EAAkB,KAAK,mBAAmBD,CAAc,EAE9D,GAAIC,EAAiB,CACnB,KAAM,CAAE,iBAAAC,EAAkB,aAAAC,EAAc,WAAAC,CAAW,EAAIH,EACjDI,EAAQ,KAAK,aAAa,SAAS,EACrCA,EAAM,mBAAqBhB,EAAuB,UAEpD,KAAK,sBAAsB,CACzB,iBAAAa,EACA,aAAAC,EACA,cAAe,KAAK,iBAAiB,YAAY,GACjD,WAAAC,EACA,cAAe,CAAC,EAChB,0BAA2B,EAC7B,CAAC,EAGD,KAAK,sBAAsB,CACzB,GAAGC,EACH,iBAAAH,EACA,aAAAC,EACA,cAAe,KAAK,iBAAiB,YAAY,GACjD,WAAAC,CACF,CAAC,CAEL,CACF,CAEQ,eAAkBL,GAAoB,CAC5C,OAAQA,EAAM,UAAW,CACvB,KAAKP,EAAc,kBACjB,OAAO,KAAK,mBAAmBO,EAAM,SAAS,EAChD,KAAKP,EAAc,yBACjB,OAAO,KAAK,sBAAsB,CAChC,GAAG,KAAK,aAAa,SAAS,EAC9B,aAAcF,EAAa,IAC7B,CAAC,EACH,KAAKE,EAAc,2BACjB,OAAO,KAAK,sBAAsB,CAChC,GAAG,KAAK,aAAa,SAAS,EAC9B,aAAcF,EAAa,MAC7B,CAAC,EACH,KAAKE,EAAc,8BACjB,OAAO,KAAK,sBAAsB,CAChC,GAAG,KAAK,aAAa,SAAS,EAC9B,aAAcF,EAAa,SAC7B,CAAC,EACH,QACE,OAAO,IACX,CACF,EAEQ,mBACNU,EACwB,CACxB,OAAIT,EAAuBS,CAAc,EAChC,CACL,iBAAkBX,EAAuB,0BACzC,aAAcC,EAAa,UAC3B,WAAY,CACV,KAAMU,EAAe,KAAK,KAC1B,QAASA,EAAe,KAAK,OAC/B,CACF,GAEA,KAAK,QAAQ,MAAM,oCAAqC,CACtD,KAAM,CAAE,eAAAA,CAAe,CACzB,CAAC,EACM,KAEX,CAEO,aAAoB,CACzB,KAAK,cAAc,YAAY,CACjC,CACF",
+  "names": ["DeviceSessionStateType", "DeviceStatus", "isSuccessCommandResult", "SessionEvents", "DeviceSessionStateHandler", "loggerModuleFactory", "_sessionEventDispatcher", "_connectedDevice", "_deviceState", "setDeviceSessionState", "event", "parsedResponse", "newDeviceStatus", "sessionStateType", "deviceStatus", "currentApp", "state"]
+}

package/lib/esm/src/internal/device-session/model/DeviceSessionStateHandler.test.js

@@ -0,0 +1,2 @@
+import{BehaviorSubject as p,Subject as C}from"rxjs";import{expect as e}from"vitest";import{CommandResultStatus as u,DeviceModelId as S,DeviceSessionStateType as r,DeviceStatus as a}from"../../../api/index";import{SessionEvents as i}from"../../device-session/model/DeviceSessionEventDispatcher";import{DeviceSessionStateHandler as D}from"./DeviceSessionStateHandler";describe("DeviceSessionStateHandler",()=>{let t,v,c;const E=vi.fn(()=>c);let l,d,n,o;beforeEach(()=>{t=new C,v={listen:()=>t,dispatch:vi.fn()},c={error:vi.fn(),debug:vi.fn()},l={deviceModel:{id:"device-model-1"}},d=new p({sessionStateType:r.Connected,deviceStatus:a.CONNECTED,deviceModelId:S.NANO_X}),n=vi.fn(),o=new D(E,v,l,d,n)}),afterEach(()=>{o&&typeof o.unsubscribe=="function"&&o.unsubscribe()}),it("updates device state on COMMAND_SUCCEEDED event with a successful response",()=>{const s={data:{name:"TestApp",version:"1.0.0"},status:u.Success};t.next({eventName:i.COMMAND_SUCCEEDED,eventData:s}),e(n).toHaveBeenCalledWith({sessionStateType:r.ReadyWithoutSecureChannel,deviceStatus:a.CONNECTED,deviceModelId:"device-model-1",currentApp:{name:"TestApp",version:"1.0.0"},installedApps:[],isSecureConnectionAllowed:!1})}),it("updates device state on COMMAND_SUCCEEDED event when device is ready",()=>{d.next({sessionStateType:r.ReadyWithoutSecureChannel,deviceStatus:a.CONNECTED,deviceModelId:S.NANO_X,currentApp:{name:"",version:""},installedApps:["Bitcoin","Ethereum"],isSecureConnectionAllowed:!0});const s={data:{name:"TestApp",version:"1.0.0"},status:u.Success};t.next({eventName:i.COMMAND_SUCCEEDED,eventData:s}),e(n).toHaveBeenCalledWith({sessionStateType:r.ReadyWithoutSecureChannel,deviceStatus:a.CONNECTED,deviceModelId:"device-model-1",currentApp:{name:"TestApp",version:"1.0.0"},installedApps:["Bitcoin","Ethereum"],isSecureConnectionAllowed:!0})}),it("updates device state on DEVICE_STATE_UPDATE_BUSY event",()=>{t.next({eventName:i.DEVICE_STATE_UPDATE_BUSY}),e(n).toHaveBeenCalledWith(e.objectContaining({deviceStatus:a.BUSY}))}),it("updates device state on DEVICE_STATE_UPDATE_CONNECTED event",()=>{t.next({eventName:i.DEVICE_STATE_UPDATE_CONNECTED}),e(n).toHaveBeenCalledWith(e.objectContaining({deviceStatus:a.CONNECTED}))}),it("logs error and does not update state if command result is unsuccessful",()=>{const s={data:null,error:{_tag:"SomeOtherError"}};t.next({eventName:i.COMMAND_SUCCEEDED,eventData:s}),e(c.debug).toHaveBeenCalledWith("Error while parsing APDU response",{data:{parsedResponse:s}}),e(n).not.toHaveBeenCalled()}),it("does not update state if command result is not a success",()=>{const s={data:null,error:{_tag:"SomeOtherError"}};t.next({eventName:i.COMMAND_SUCCEEDED,eventData:s}),e(n).not.toHaveBeenCalled()})});
+//# sourceMappingURL=DeviceSessionStateHandler.test.js.map

package/lib/esm/src/internal/device-session/model/DeviceSessionStateHandler.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/device-session/model/DeviceSessionStateHandler.test.ts"],
+  "sourcesContent": ["import { BehaviorSubject, Subject } from \"rxjs\";\nimport { expect, type Mock } from \"vitest\";\n\nimport { type DeviceSessionState } from \"@api/device-session/DeviceSessionState\";\nimport {\n  CommandResultStatus,\n  DeviceModelId,\n  DeviceSessionStateType,\n  DeviceStatus,\n} from \"@api/index\";\nimport {\n  type DeviceSessionEventDispatcher,\n  type NewEvent,\n  SessionEvents,\n} from \"@internal/device-session/model/DeviceSessionEventDispatcher\";\nimport { type Application } from \"@internal/manager-api/model/Application\";\n\nimport {\n  DeviceSessionStateHandler,\n  type SetDeviceSessionStateFn,\n} from \"./DeviceSessionStateHandler\";\n\ndescribe(\"DeviceSessionStateHandler\", () => {\n  let fakeEventSubject: Subject<NewEvent>;\n  let fakeSessionEventDispatcher: DeviceSessionEventDispatcher;\n  let mockLogger: {\n    error: (message: string, meta?: Record<string, unknown>) => void;\n    debug: (message: string, meta?: Record<string, unknown>) => void;\n  };\n  const mockLoggerModuleFactory = vi.fn(() => mockLogger);\n  let fakeConnectedDevice: { deviceModel: { id: string } };\n  let deviceState: BehaviorSubject<DeviceSessionState>;\n  let setDeviceSessionState: Mock<SetDeviceSessionStateFn>;\n  let handler: DeviceSessionStateHandler;\n\n  beforeEach(() => {\n    fakeEventSubject = new Subject<NewEvent>();\n    //@ts-expect-error mock\n    fakeSessionEventDispatcher = {\n      listen: () => fakeEventSubject,\n      dispatch: vi.fn(),\n    };\n\n    mockLogger = {\n      error: vi.fn(),\n      debug: vi.fn(),\n    };\n\n    fakeConnectedDevice = {\n      deviceModel: {\n        id: \"device-model-1\",\n      },\n    };\n\n    deviceState = new BehaviorSubject<DeviceSessionState>({\n      sessionStateType: DeviceSessionStateType.Connected,\n      deviceStatus: DeviceStatus.CONNECTED,\n      deviceModelId: DeviceModelId.NANO_X,\n    });\n\n    setDeviceSessionState = vi.fn();\n\n    handler = new DeviceSessionStateHandler(\n      //@ts-expect-error mock\n      mockLoggerModuleFactory,\n      fakeSessionEventDispatcher,\n      fakeConnectedDevice,\n      deviceState,\n      setDeviceSessionState,\n    );\n  });\n\n  afterEach(() => {\n    if (handler && typeof handler.unsubscribe === \"function\") {\n      handler.unsubscribe();\n    }\n  });\n\n  it(\"updates device state on COMMAND_SUCCEEDED event with a successful response\", () => {\n    // Given\n    const fakeCommandResult = {\n      data: {\n        name: \"TestApp\",\n        version: \"1.0.0\",\n      },\n      status: CommandResultStatus.Success,\n    };\n\n    // When\n    fakeEventSubject.next({\n      eventName: SessionEvents.COMMAND_SUCCEEDED,\n      //@ts-expect-error mock\n      eventData: fakeCommandResult,\n    });\n\n    // Then\n    expect(setDeviceSessionState).toHaveBeenCalledWith({\n      sessionStateType: DeviceSessionStateType.ReadyWithoutSecureChannel,\n      deviceStatus: DeviceStatus.CONNECTED,\n      deviceModelId: \"device-model-1\",\n      currentApp: { name: \"TestApp\", version: \"1.0.0\" },\n      installedApps: [],\n      isSecureConnectionAllowed: false,\n    });\n  });\n\n  it(\"updates device state on COMMAND_SUCCEEDED event when device is ready\", () => {\n    // Given\n    deviceState.next({\n      sessionStateType: DeviceSessionStateType.ReadyWithoutSecureChannel,\n      deviceStatus: DeviceStatus.CONNECTED,\n      deviceModelId: DeviceModelId.NANO_X,\n      currentApp: { name: \"\", version: \"\" },\n      installedApps: [\"Bitcoin\", \"Ethereum\"] as unknown as Application[],\n      isSecureConnectionAllowed: true,\n    });\n    const fakeCommandResult = {\n      data: {\n        name: \"TestApp\",\n        version: \"1.0.0\",\n      },\n      status: CommandResultStatus.Success,\n    };\n\n    // When\n    fakeEventSubject.next({\n      eventName: SessionEvents.COMMAND_SUCCEEDED,\n      //@ts-expect-error mock\n      eventData: fakeCommandResult,\n    });\n\n    // Then\n    expect(setDeviceSessionState).toHaveBeenCalledWith({\n      sessionStateType: DeviceSessionStateType.ReadyWithoutSecureChannel,\n      deviceStatus: DeviceStatus.CONNECTED,\n      deviceModelId: \"device-model-1\",\n      currentApp: { name: \"TestApp\", version: \"1.0.0\" },\n      installedApps: [\"Bitcoin\", \"Ethereum\"] as unknown as Application[],\n      isSecureConnectionAllowed: true,\n    });\n  });\n\n  it(\"updates device state on DEVICE_STATE_UPDATE_BUSY event\", () => {\n    // When\n    fakeEventSubject.next({\n      eventName: SessionEvents.DEVICE_STATE_UPDATE_BUSY,\n    });\n\n    // Then\n    expect(setDeviceSessionState).toHaveBeenCalledWith(\n      expect.objectContaining({ deviceStatus: DeviceStatus.BUSY }),\n    );\n  });\n\n  it(\"updates device state on DEVICE_STATE_UPDATE_CONNECTED event\", () => {\n    // When\n    fakeEventSubject.next({\n      eventName: SessionEvents.DEVICE_STATE_UPDATE_CONNECTED,\n    });\n\n    // Then\n    expect(setDeviceSessionState).toHaveBeenCalledWith(\n      expect.objectContaining({ deviceStatus: DeviceStatus.CONNECTED }),\n    );\n  });\n\n  it(\"logs error and does not update state if command result is unsuccessful\", () => {\n    // Given\n    const fakeErrorCommandResult = {\n      data: null,\n      error: { _tag: \"SomeOtherError\" },\n    };\n\n    // When\n    fakeEventSubject.next({\n      eventName: SessionEvents.COMMAND_SUCCEEDED,\n      //@ts-expect-error mock\n      eventData: fakeErrorCommandResult,\n    });\n\n    // Then\n    expect(mockLogger.debug).toHaveBeenCalledWith(\n      \"Error while parsing APDU response\",\n      { data: { parsedResponse: fakeErrorCommandResult } },\n    );\n    expect(setDeviceSessionState).not.toHaveBeenCalled();\n  });\n\n  it(\"does not update state if command result is not a success\", () => {\n    // Given\n    const fakeErrorCommandResult = {\n      data: null,\n      error: { _tag: \"SomeOtherError\" },\n    };\n\n    // When\n    fakeEventSubject.next({\n      eventName: SessionEvents.COMMAND_SUCCEEDED,\n      //@ts-expect-error mock\n      eventData: fakeErrorCommandResult,\n    });\n\n    // Then\n    expect(setDeviceSessionState).not.toHaveBeenCalled();\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["BehaviorSubject", "Subject", "expect", "CommandResultStatus", "DeviceModelId", "DeviceSessionStateType", "DeviceStatus", "SessionEvents", "DeviceSessionStateHandler", "fakeEventSubject", "fakeSessionEventDispatcher", "mockLogger", "mockLoggerModuleFactory", "fakeConnectedDevice", "deviceState", "setDeviceSessionState", "handler", "fakeCommandResult", "fakeErrorCommandResult"]
+}

package/lib/esm/src/internal/device-session/model/Frame.js

@@ -1,2 +1,2 @@
-class a{_header;_data;constructor({header:t,data:r}){this._header=t,this._data=r}toString(){return JSON.stringify({header:this._header.toString(),data:this._data.toString()},null,2)}getRawData(){const t=this._header.getRawData(),r=new Uint8Array(t.length+this._data.length);return r.set(t,0),r.set(this._data,t.length),r}getHeader(){return this._header}getData(){return this._data}}export{a as Frame};
+import{bufferToHexaString as e}from"../../../api/index";class d{_header;_data;constructor({header:t,data:r}){this._header=t,this._data=r}toString(){return JSON.stringify({header:this._header.toString(),data:e(this._data)},null,2)}getRawData(){const t=this._header.getRawData(),r=new Uint8Array(t.length+this._data.length);return r.set(t,0),r.set(this._data,t.length),r}getHeader(){return this._header}getData(){return this._data}}export{d as Frame};
 //# sourceMappingURL=Frame.js.map