@xsolla/payment-client-core 0.2.21 → 0.2.23

package/esm2022/lib/core/payment/three-ds/api/notify-dfp-status/notify-dfp-status.service.mjs

@@ -0,0 +1,49 @@
+import { lastValueFrom } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { notifyDfpStatusRequestFactoryToken, } from './request/notify-dfp-status-request.token';
+import { TokenError } from '../../../../exceptions-handling/errors/token-error.class';
+import { XpsResponseError } from '../../../xps-response.error';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../http/secure-api/secure-api.service";
+import * as i2 from "../../../../settings/settings.service";
+export class NotifyDfpStatusService {
+    constructor(secureApi, settingsService, requestFactory) {
+        this.secureApi = secureApi;
+        this.settingsService = settingsService;
+        this.requestFactory = requestFactory;
+        this.apiRouteComplete = 'secure3d/notify';
+    }
+    /*
+     * isCompind is a flag of dfp expired state
+     */
+    request(threeDsId, isCompind) {
+        const token = this.settingsService.token;
+        if (!token) {
+            throw new TokenError();
+        }
+        const requestParams = this.requestFactory({
+            token: token,
+            threeDsTrXid: threeDsId,
+            isCompind,
+        });
+        lastValueFrom(this.secureApi.post(this.apiRouteComplete, new URLSearchParams({ ...requestParams }), {
+            headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+            responseType: 'json',
+        })).catch((error) => {
+            throw new XpsResponseError(error.message);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NotifyDfpStatusService, deps: [{ token: i1.SecureApiClient }, { token: i2.SettingsService }, { token: notifyDfpStatusRequestFactoryToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NotifyDfpStatusService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NotifyDfpStatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SecureApiClient }, { type: i2.SettingsService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [notifyDfpStatusRequestFactoryToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/payment/three-ds/api/status-three-ds/status-three-ds.service.mjs

@@ -0,0 +1,60 @@
+import { lastValueFrom, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Inject, Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { TokenError } from '../../../../exceptions-handling/errors/token-error.class';
+import { XpsResponseError } from '../../../xps-response.error';
+import { statusThreeDsRequestFactoryToken, } from './request/status-three-ds-request.token';
+import { statusThreeDsResponseFactoryToken, } from './response/status-three-ds-response.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../http/secure-api/secure-api.service";
+import * as i2 from "../../../../settings/settings.service";
+export class StatusThreeDsService {
+    get response$() {
+        return this.response.asObservable();
+    }
+    constructor(secureApi, settingsService, requestFactory, responseFactory) {
+        this.secureApi = secureApi;
+        this.settingsService = settingsService;
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.apiRoute = 'secure3d/check';
+        this.response = new Subject();
+    }
+    request(data) {
+        const token = this.settingsService.token;
+        if (!token) {
+            throw new TokenError();
+        }
+        const requestParams = this.requestFactory(token, data.threeDSTrXid);
+        void lastValueFrom(this.secureApi
+            .post(this.apiRoute, new URLSearchParams({ ...requestParams }), {
+            headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+            responseType: 'json',
+        })
+            .pipe(map((response) => {
+            const statusResponse = this.responseFactory({
+                status: response.secure3d.status,
+                checkoutForm: response.secure3d.checkout_form,
+            });
+            this.response.next(statusResponse);
+        }))).catch((error) => {
+            throw new XpsResponseError(error.message);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StatusThreeDsService, deps: [{ token: i1.SecureApiClient }, { token: i2.SettingsService }, { token: statusThreeDsRequestFactoryToken }, { token: statusThreeDsResponseFactoryToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StatusThreeDsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StatusThreeDsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SecureApiClient }, { type: i2.SettingsService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [statusThreeDsRequestFactoryToken]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [statusThreeDsResponseFactoryToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/payment/three-ds/dfp-collect/dfp-collect.service.mjs

@@ -0,0 +1,105 @@
+import { Inject, Injectable } from '@angular/core';
+import { windowToken } from '../../../window.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/notify-dfp-status/notify-dfp-status.service";
+export class DfpCollectService {
+    constructor(window, notifyDfpStatusService) {
+        this.window = window;
+        this.notifyDfpStatusService = notifyDfpStatusService;
+        this.iframeName = 'iframeDFP';
+        this.formName = 'formDFP';
+    }
+    collectDfpStatus(threeDsForm) {
+        if (threeDsForm.waitCallback) {
+            this.openIframeWithPostRequest(threeDsForm, false);
+        }
+        else {
+            this.openIframeWithPostRequest(threeDsForm, true);
+        }
+    }
+    /*
+     * This method create invisible iframe with required params and after that it submit form in iframe
+     * */
+    openIframeWithPostRequest(threeDsForm, isNeedNotifyAfterLoad) {
+        const iFrameElement = this.window.document.getElementById(this.iframeName);
+        if (!iFrameElement) {
+            this.createIframe(isNeedNotifyAfterLoad, threeDsForm.threeDSTrXid);
+            this.postFormToIframe(threeDsForm.threeDSMethod, threeDsForm.threeDSMethodData);
+        }
+    }
+    /*
+     * isNeedNotifyAfterLoad is need to send notification of dft to server
+     * */
+    createIframe(isNeedNotifyAfterLoad, threeDsTrXid) {
+        const attributes = {
+            name: this.iframeName,
+            id: this.iframeName,
+            src: 'javascript:false',
+            style: 'display:none',
+        };
+        const iFrame = this.window.document.createElement('iframe');
+        this.setAttributes(iFrame, attributes);
+        this.window.document.body.appendChild(iFrame);
+        if (isNeedNotifyAfterLoad) {
+            this.window.document.getElementById(this.iframeName).onload = () => {
+                this.notifyDfpStatusService.request(threeDsTrXid, true);
+            };
+        }
+    }
+    /*
+     * This method will submit form in our iframe. Form will be created, if it's don't exist
+     * */
+    postFormToIframe(url, threeDsMethod) {
+        let form = this.window.document.getElementById(this.formName);
+        if (!form) {
+            form = this.createForm();
+            this.window.document.body.appendChild(form);
+        }
+        form.setAttribute('action', url);
+        form.setAttribute('target', this.iframeName);
+        form.appendChild(this.createInput('threeDSMethodData', threeDsMethod));
+        form.submit();
+    }
+    /*
+     * This method will create invisible form with required params
+     */
+    createForm() {
+        const form = this.window.document.createElement('form');
+        const initAttributes = {
+            name: this.formName,
+            id: this.formName,
+            style: 'display:none',
+            method: 'POST',
+            enctype: 'application/x-www-form-urlencoded',
+        };
+        this.setAttributes(form, initAttributes);
+        return form;
+    }
+    createInput(name, value) {
+        const input = this.window.document.createElement('input');
+        input.type = 'hidden';
+        input.name = name;
+        input.value = value;
+        return input;
+    }
+    /*
+     * This method will set attributes to form/iframe
+     * */
+    setAttributes(element, attributes) {
+        Object.keys(attributes).forEach((name) => {
+            element.setAttribute(name, attributes[name]);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DfpCollectService, deps: [{ token: windowToken }, { token: i1.NotifyDfpStatusService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DfpCollectService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DfpCollectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.NotifyDfpStatusService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dfp-collect.service.js","sourceRoot":"","sources":["../../../../../../../../packages/payment-client-core/src/lib/core/payment/three-ds/dfp-collect/dfp-collect.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { windowToken } from '../../../window.token';\nimport { ExtendedWindow } from '../../../extended-window.interface';\nimport { NotifyDfpStatusService } from '../api/notify-dfp-status/notify-dfp-status.service';\nimport { ThreeDsForm } from '../three-ds-form.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DfpCollectService {\n  private readonly iframeName = 'iframeDFP';\n  private readonly formName = 'formDFP';\n\n  public constructor(\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow,\n    private readonly notifyDfpStatusService: NotifyDfpStatusService\n  ) {}\n\n  public collectDfpStatus(threeDsForm: ThreeDsForm): void {\n    if (threeDsForm.waitCallback) {\n      this.openIframeWithPostRequest(threeDsForm, false);\n    } else {\n      this.openIframeWithPostRequest(threeDsForm, true);\n    }\n  }\n\n  /*\n   * This method create invisible iframe with required params and after that it submit form in iframe\n   * */\n  private openIframeWithPostRequest(\n    threeDsForm: ThreeDsForm,\n    isNeedNotifyAfterLoad: boolean\n  ): void {\n    const iFrameElement = this.window.document.getElementById(this.iframeName);\n    if (!iFrameElement) {\n      this.createIframe(isNeedNotifyAfterLoad, threeDsForm.threeDSTrXid);\n      this.postFormToIframe(\n        threeDsForm.threeDSMethod,\n        threeDsForm.threeDSMethodData\n      );\n    }\n  }\n\n  /*\n   * isNeedNotifyAfterLoad is need to send notification of dft to server\n   * */\n  private createIframe(\n    isNeedNotifyAfterLoad: boolean,\n    threeDsTrXid: string\n  ): void {\n    const attributes: { [key: string]: string } = {\n      name: this.iframeName,\n      id: this.iframeName,\n      src: 'javascript:false',\n      style: 'display:none',\n    };\n\n    const iFrame = this.window.document.createElement('iframe');\n    this.setAttributes(iFrame, attributes);\n    this.window.document.body.appendChild(iFrame);\n\n    if (isNeedNotifyAfterLoad) {\n      (\n        this.window.document.getElementById(\n          this.iframeName\n        ) as HTMLIFrameElement\n      ).onload = () => {\n        this.notifyDfpStatusService.request(threeDsTrXid, true);\n      };\n    }\n  }\n\n  /*\n   * This method will submit form in our iframe. Form will be created, if it's don't exist\n   * */\n  private postFormToIframe(url: string, threeDsMethod: string): void {\n    let form = this.window.document.getElementById(\n      this.formName\n    ) as HTMLFormElement;\n\n    if (!form) {\n      form = this.createForm();\n      this.window.document.body.appendChild(form);\n    }\n\n    form.setAttribute('action', url);\n    form.setAttribute('target', this.iframeName);\n    form.appendChild(this.createInput('threeDSMethodData', threeDsMethod));\n\n    form.submit();\n  }\n\n  /*\n   * This method will create invisible form with required params\n   */\n  private createForm(): HTMLFormElement {\n    const form = this.window.document.createElement('form');\n    const initAttributes: { [key: string]: string } = {\n      name: this.formName,\n      id: this.formName,\n      style: 'display:none',\n      method: 'POST',\n      enctype: 'application/x-www-form-urlencoded',\n    };\n\n    this.setAttributes(form, initAttributes);\n\n    return form;\n  }\n\n  private createInput(name: string, value: string): HTMLInputElement {\n    const input = this.window.document.createElement('input');\n    input.type = 'hidden';\n    input.name = name;\n    input.value = value;\n    return input;\n  }\n\n  /*\n   * This method will set attributes to form/iframe\n   * */\n  private setAttributes(\n    element: HTMLElement,\n    attributes: { [key: string]: string }\n  ): void {\n    Object.keys(attributes).forEach((name) => {\n      element.setAttribute(name, attributes[name]);\n    });\n  }\n}\n"]}

package/esm2022/lib/core/payment/three-ds/reinsurance-check/reinsurance-check.service.mjs

@@ -0,0 +1,41 @@
+import { Inject, Injectable } from '@angular/core';
+import { windowToken } from '../../../window.token';
+import * as i0 from "@angular/core";
+export class ReinsuranceCheckService {
+    constructor(window) {
+        this.window = window;
+        this.timers = {};
+    }
+    addTimer(timer) {
+        if (!timer) {
+            return;
+        }
+        this.removeTimer(timer.id);
+        this.timers[timer.id] = timer;
+        const timerInStorage = this.timers[timer.id];
+        this.window.setTimeout(() => {
+            timerInStorage.callback();
+            this.timers[timer.id] = null;
+        }, timerInStorage.timeoutMs);
+    }
+    removeTimer(id) {
+        const timerInStorage = this.timers[id];
+        if (!timerInStorage) {
+            return;
+        }
+        this.window.clearTimeout(timerInStorage.timeoutRef);
+        this.timers[id] = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ReinsuranceCheckService, deps: [{ token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ReinsuranceCheckService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ReinsuranceCheckService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/payment/three-ds/three-ds-20/three-ds20.service.mjs

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ThreeDsStatusWebSocketTypes } from '../three-ds-status-websocket-types.enum';
+import { ThreeDsStatusTypes } from '../api/status-three-ds/status-types.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/status-three-ds/status-three-ds.service";
+import * as i2 from "../api/notify-dfp-status/notify-dfp-status.service";
+import * as i3 from "../../../web-socket/web-socket.factory";
+import * as i4 from "../dfp-collect/dfp-collect.service";
+import * as i5 from "../reinsurance-check/reinsurance-check.service";
+export class ThreeDs20Service {
+    get statusUpdates$() {
+        return this.statusUpdates.asObservable();
+    }
+    constructor(statusThreeDsService, notifyDfpStatusService, webSocketFactory, dfpCollectService, reinsuranceCheckService) {
+        this.statusThreeDsService = statusThreeDsService;
+        this.notifyDfpStatusService = notifyDfpStatusService;
+        this.webSocketFactory = webSocketFactory;
+        this.dfpCollectService = dfpCollectService;
+        this.reinsuranceCheckService = reinsuranceCheckService;
+        this.webSocketClient = null;
+        this.statusUpdates = new Subject();
+        this.statusRequestSubscription = null;
+        this.notifyDfpTimerId = 'notify-dfp';
+        this.notifyDfpTimeoutMs = 10000;
+        this.statusThreeDsTimerId = 'status-three-ds';
+        this.statusThreeDsTimeoutMs = 180000;
+    }
+    async checkThreeDs20(threeDsForm) {
+        if (!threeDsForm) {
+            return;
+        }
+        this.reinsuranceCheckService.addTimer({
+            id: this.notifyDfpTimerId,
+            timeoutMs: this.notifyDfpTimeoutMs,
+            callback: () => {
+                this.notifyDfpStatusService.request(threeDsForm.threeDSTrXid, false);
+            },
+        });
+        this.webSocketClient = this.webSocketFactory.createWebSocketClient(threeDsForm.webSocketChannelUrl, threeDsForm.webSocketClientType);
+        await this.webSocketClient.open(threeDsForm.webSocketChannelUrl, threeDsForm.webSocketClientType);
+        this.webSocketSubscription?.unsubscribe();
+        this.webSocketSubscription = this.webSocketClient.messages$.subscribe((message) => {
+            if (message !== ThreeDsStatusWebSocketTypes.status3DS_changed) {
+                return;
+            }
+            this.statusThreeDsService.request(threeDsForm);
+        });
+        this.webSocketReconnectionSubscription?.unsubscribe();
+        this.webSocketReconnectionSubscription =
+            this.webSocketClient.subscribeOnSuccessfulReconnection(() => {
+                this.statusThreeDsService.request(threeDsForm);
+            });
+        this.handleThreeDsUpdates(threeDsForm);
+        this.statusThreeDsService.request(threeDsForm);
+        this.reinsuranceCheckService.addTimer({
+            id: this.statusThreeDsTimerId,
+            timeoutMs: this.statusThreeDsTimeoutMs,
+            callback: () => {
+                this.statusThreeDsService.request(threeDsForm);
+            },
+        });
+    }
+    handleThreeDsUpdates(threeDsForm) {
+        this.statusRequestSubscription?.unsubscribe();
+        this.statusRequestSubscription =
+            this.statusThreeDsService.response$.subscribe((threeDsStatus) => {
+                if (!threeDsStatus) {
+                    return;
+                }
+                if (threeDsStatus.status === ThreeDsStatusTypes.completed) {
+                    this.stopReinsuranceMethods();
+                    this.statusUpdates.next({
+                        type: 'complete',
+                        data: {
+                            statusUrl: threeDsForm.statusUrl,
+                        },
+                    });
+                    return;
+                }
+                if (threeDsStatus.status === ThreeDsStatusTypes.challenge &&
+                    threeDsStatus.checkoutForm) {
+                    this.stopReinsuranceMethods();
+                    this.statusUpdates.next({
+                        type: 'challenge',
+                        data: threeDsStatus.checkoutForm,
+                    });
+                }
+                if (threeDsStatus.status === ThreeDsStatusTypes.collectDfp) {
+                    this.dfpCollectService.collectDfpStatus(threeDsForm);
+                }
+            });
+    }
+    stopReinsuranceMethods() {
+        this.reinsuranceCheckService.removeTimer(this.notifyDfpTimerId);
+        this.reinsuranceCheckService.removeTimer(this.statusThreeDsTimerId);
+        this.webSocketClient?.close();
+        this.statusRequestSubscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ThreeDs20Service, deps: [{ token: i1.StatusThreeDsService }, { token: i2.NotifyDfpStatusService }, { token: i3.WebSocketFactory }, { token: i4.DfpCollectService }, { token: i5.ReinsuranceCheckService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ThreeDs20Service, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ThreeDs20Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.StatusThreeDsService }, { type: i2.NotifyDfpStatusService }, { type: i3.WebSocketFactory }, { type: i4.DfpCollectService }, { type: i5.ReinsuranceCheckService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"three-ds20.service.js","sourceRoot":"","sources":["../../../../../../../../packages/payment-client-core/src/lib/core/payment/three-ds/three-ds-20/three-ds20.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, Subject, Subscription } from 'rxjs';\nimport { WebSocketFactory } from '../../../web-socket/web-socket.factory';\nimport { WebSocketClient } from '../../../web-socket/web-socket.interface';\nimport { StatusThreeDsService } from '../api/status-three-ds/status-three-ds.service';\nimport { NotifyDfpStatusService } from '../api/notify-dfp-status/notify-dfp-status.service';\nimport { ThreeDsStatusWebSocketTypes } from '../three-ds-status-websocket-types.enum';\nimport { ThreeDsForm } from '../three-ds-form.interface';\nimport { ThreeDsStatusTypes } from '../api/status-three-ds/status-types.enum';\nimport { DfpCollectService } from '../dfp-collect/dfp-collect.service';\nimport { ReinsuranceCheckService } from '../reinsurance-check/reinsurance-check.service';\nimport { StatusUpdate } from './status-update.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ThreeDs20Service {\n  public get statusUpdates$(): Observable<StatusUpdate> {\n    return this.statusUpdates.asObservable();\n  }\n\n  private webSocketSubscription: Subscription | undefined;\n  private webSocketReconnectionSubscription: Subscription | undefined;\n  private webSocketClient: WebSocketClient | null = null;\n\n  private readonly statusUpdates = new Subject<StatusUpdate>();\n\n  private statusRequestSubscription: Subscription | null = null;\n\n  private readonly notifyDfpTimerId = 'notify-dfp';\n  private readonly notifyDfpTimeoutMs = 10000;\n\n  private readonly statusThreeDsTimerId = 'status-three-ds';\n  private readonly statusThreeDsTimeoutMs = 180000;\n\n  public constructor(\n    private readonly statusThreeDsService: StatusThreeDsService,\n    private readonly notifyDfpStatusService: NotifyDfpStatusService,\n    private readonly webSocketFactory: WebSocketFactory,\n    private readonly dfpCollectService: DfpCollectService,\n    private readonly reinsuranceCheckService: ReinsuranceCheckService\n  ) {}\n\n  public async checkThreeDs20(threeDsForm: ThreeDsForm | null): Promise<void> {\n    if (!threeDsForm) {\n      return;\n    }\n\n    this.reinsuranceCheckService.addTimer({\n      id: this.notifyDfpTimerId,\n      timeoutMs: this.notifyDfpTimeoutMs,\n      callback: () => {\n        this.notifyDfpStatusService.request(threeDsForm.threeDSTrXid, false);\n      },\n    });\n\n    this.webSocketClient = this.webSocketFactory.createWebSocketClient(\n      threeDsForm.webSocketChannelUrl,\n      threeDsForm.webSocketClientType\n    );\n\n    await this.webSocketClient.open(\n      threeDsForm.webSocketChannelUrl,\n      threeDsForm.webSocketClientType\n    );\n    this.webSocketSubscription?.unsubscribe();\n\n    this.webSocketSubscription = this.webSocketClient.messages$.subscribe(\n      (message) => {\n        if (message !== ThreeDsStatusWebSocketTypes.status3DS_changed) {\n          return;\n        }\n\n        this.statusThreeDsService.request(threeDsForm);\n      }\n    );\n\n    this.webSocketReconnectionSubscription?.unsubscribe();\n    this.webSocketReconnectionSubscription =\n      this.webSocketClient.subscribeOnSuccessfulReconnection(() => {\n        this.statusThreeDsService.request(threeDsForm);\n      });\n\n    this.handleThreeDsUpdates(threeDsForm);\n    this.statusThreeDsService.request(threeDsForm);\n\n    this.reinsuranceCheckService.addTimer({\n      id: this.statusThreeDsTimerId,\n      timeoutMs: this.statusThreeDsTimeoutMs,\n      callback: () => {\n        this.statusThreeDsService.request(threeDsForm);\n      },\n    });\n  }\n\n  private handleThreeDsUpdates(threeDsForm: ThreeDsForm): void {\n    this.statusRequestSubscription?.unsubscribe();\n    this.statusRequestSubscription =\n      this.statusThreeDsService.response$.subscribe((threeDsStatus) => {\n        if (!threeDsStatus) {\n          return;\n        }\n\n        if (threeDsStatus.status === ThreeDsStatusTypes.completed) {\n          this.stopReinsuranceMethods();\n          this.statusUpdates.next({\n            type: 'complete',\n            data: {\n              statusUrl: threeDsForm.statusUrl,\n            },\n          });\n          return;\n        }\n\n        if (\n          threeDsStatus.status === ThreeDsStatusTypes.challenge &&\n          threeDsStatus.checkoutForm\n        ) {\n          this.stopReinsuranceMethods();\n          this.statusUpdates.next({\n            type: 'challenge',\n            data: threeDsStatus.checkoutForm,\n          });\n        }\n\n        if (threeDsStatus.status === ThreeDsStatusTypes.collectDfp) {\n          this.dfpCollectService.collectDfpStatus(threeDsForm);\n        }\n      });\n  }\n\n  private stopReinsuranceMethods(): void {\n    this.reinsuranceCheckService.removeTimer(this.notifyDfpTimerId);\n    this.reinsuranceCheckService.removeTimer(this.statusThreeDsTimerId);\n    this.webSocketClient?.close();\n    this.statusRequestSubscription?.unsubscribe();\n  }\n}\n"]}

package/esm2022/lib/core/payment/three-ds/three-ds.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./three-ds-20/three-ds20.service";
+import * as i2 from "../actions/next-action.service";
+import * as i3 from "../actions/check-status/check-status.action.class";
+import * as i4 from "../actions/three-ds/three-ds.action.class";
+export class ThreeDsService {
+    constructor(threeDs20Service, nextActionService, checkStatusActionCreator, threeDsActionCreator) {
+        this.threeDs20Service = threeDs20Service;
+        this.nextActionService = nextActionService;
+        this.checkStatusActionCreator = checkStatusActionCreator;
+        this.threeDsActionCreator = threeDsActionCreator;
+        this.statusSubscription = null;
+    }
+    checkThreeDs(params) {
+        /*
+          At this moment we support only 3ds 2.0 version.
+          3ds 1.0 currently working by our redirect logic (Redirect NextAction).
+          If in future we will get new version of 3ds, we should add 3ds determination logic to this service
+        */
+        void this.threeDs20Service.checkThreeDs20(params.parameters.threeDSForm);
+        this.statusSubscription?.unsubscribe();
+        this.statusSubscription = this.threeDs20Service.statusUpdates$.subscribe((statusUpdate) => {
+            if (statusUpdate.type === 'complete') {
+                return this.nextActionService.emitFlowUpdates(this.checkStatusActionCreator.getActionData());
+            }
+            this.nextActionService.emitFlowUpdates(this.threeDsActionCreator.getActionData(statusUpdate));
+        });
+    }
+    stopChecking() {
+        this.statusSubscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ThreeDsService, deps: [{ token: i1.ThreeDs20Service }, { token: i2.NextActionService }, { token: i3.CheckStatusActionCreator }, { token: i4.ThreeDsActionCreator }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ThreeDsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ThreeDsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ThreeDs20Service }, { type: i2.NextActionService }, { type: i3.CheckStatusActionCreator }, { type: i4.ThreeDsActionCreator }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/payment/xps-api/xps-api.service.mjs

@@ -0,0 +1,85 @@
+import { lastValueFrom } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { windowToken } from '../../window.token';
+import { cardsWith3ds } from '../credit-card-payment-methods-id.variable';
+import * as i0 from "@angular/core";
+import * as i1 from "../../http/secure-api/secure-api.service";
+import * as i2 from "../../settings/settings.service";
+import * as i3 from "../../country/country.service";
+import * as i4 from "../../user-agent/user-agent.service";
+export class XpsApiService {
+    constructor(window, secureApiClient, settingsService, countryService, userAgentService) {
+        this.window = window;
+        this.secureApiClient = secureApiClient;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.userAgentService = userAgentService;
+        this.directPaymentApiRoute = 'directpayment';
+    }
+    async directPaymentRequest(parameters) {
+        const pid = parameters.pid?.toString() ??
+            parameters.xps_fix_pid ??
+            '';
+        const paymentWithSavedMethod = parameters.paymentWithSavedMethod ??
+            parameters.xps_paymentWithSavedMethod ??
+            '';
+        const requestParams = {
+            ...this.collectAnalyticsParameters(pid, paymentWithSavedMethod),
+            ...this.collectUserSessionId(),
+            country: this.countryService.getCountry(),
+            refer: this.settingsService.refer,
+            ...parameters,
+        };
+        if (this.userAgentService.isMobileDevice) {
+            requestParams.mobile = "1" /* XpsBoolean.true */;
+        }
+        return lastValueFrom(this.secureApiClient.post(this.directPaymentApiRoute, new URLSearchParams({ ...requestParams }), {
+            headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+            responseType: 'json',
+        }));
+    }
+    collectAnalyticsParameters(paymentMethodId, paymentWithSavedMethod) {
+        const parameters = {};
+        parameters.paymentWithSavedMethod = paymentWithSavedMethod
+            ? paymentWithSavedMethod
+            : "0" /* XpsBoolean.false */;
+        if (!paymentMethodId) {
+            return parameters;
+        }
+        /* If payment method with 3DSecure */
+        if (cardsWith3ds.includes(Number(paymentMethodId))) {
+            parameters.container3DS = JSON.stringify({
+                browserjavaenabled: this.window.navigator.javaEnabled(),
+                browserlanguage: this.window.navigator.language,
+                browsercolordepth: this.window.screen.colorDepth,
+                browserscreenheight: this.window.screen.availHeight,
+                browserscreenwidth: this.window.screen.availWidth,
+                browsertz: new Date().getTimezoneOffset(),
+                browserappname: this.window.navigator.appName,
+                browserlocaltime: new Date().toString(),
+                browserplatform: this.window.navigator.platform || '',
+                browsercookiesenabled: this.window.navigator.cookieEnabled,
+            });
+        }
+        return parameters;
+    }
+    collectUserSessionId() {
+        const parameters = {};
+        parameters.xps_idUserSession = this.settingsService.user.session_id ?? '';
+        parameters.user_session_id = this.settingsService.user.session_id ?? '';
+        return parameters;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: XpsApiService, deps: [{ token: windowToken }, { token: i1.SecureApiClient }, { token: i2.SettingsService }, { token: i3.CountryService }, { token: i4.UserAgentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: XpsApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: XpsApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.SecureApiClient }, { type: i2.SettingsService }, { type: i3.CountryService }, { type: i4.UserAgentService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xps-api.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/payment/xps-api/xps-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { lastValueFrom } from 'rxjs';\nimport { Inject, Injectable } from '@angular/core';\nimport { HttpHeaders } from '@angular/common/http';\nimport { SecureApiClient } from '../../http/secure-api/secure-api.service';\nimport { XpsBoolean } from '../../xps-boolean.enum';\nimport { windowToken } from '../../window.token';\nimport { ExtendedWindow } from '../../extended-window.interface';\nimport { SettingsService } from '../../settings/settings.service';\nimport { XpsRequest } from '../xps-request.interface';\nimport { XpsResponse } from '../xps-response.interface';\nimport { XpsRequestParams } from '../xps-request-params.interface';\nimport { cardsWith3ds } from '../credit-card-payment-methods-id.variable';\nimport { CountryService } from '../../country/country.service';\nimport { UserAgentService } from '../../user-agent/user-agent.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class XpsApiService {\n  private readonly directPaymentApiRoute = 'directpayment';\n\n  public constructor(\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow,\n    private readonly secureApiClient: SecureApiClient,\n    private readonly settingsService: SettingsService,\n    private readonly countryService: CountryService,\n    private readonly userAgentService: UserAgentService\n  ) {}\n\n  public async directPaymentRequest(\n    parameters: XpsRequest\n  ): Promise<XpsResponse> {\n    const pid =\n      parameters.pid?.toString() ??\n      (parameters.xps_fix_pid as string | undefined) ??\n      '';\n    const paymentWithSavedMethod =\n      parameters.paymentWithSavedMethod ??\n      (parameters.xps_paymentWithSavedMethod as string | undefined) ??\n      '';\n\n    const requestParams: XpsRequestParams = {\n      ...this.collectAnalyticsParameters(pid, paymentWithSavedMethod),\n      ...this.collectUserSessionId(),\n      country: this.countryService.getCountry(),\n      refer: this.settingsService.refer,\n      ...parameters,\n    };\n\n    if (this.userAgentService.isMobileDevice) {\n      requestParams.mobile = XpsBoolean.true;\n    }\n\n    return lastValueFrom(\n      this.secureApiClient.post<XpsResponse>(\n        this.directPaymentApiRoute,\n        new URLSearchParams({ ...requestParams } as unknown as {\n          [key: string]: string;\n        }),\n        {\n          headers: new HttpHeaders().set(\n            'Content-Type',\n            'application/x-www-form-urlencoded; charset=utf-8'\n          ),\n          responseType: 'json',\n        }\n      )\n    );\n  }\n\n  private collectAnalyticsParameters(\n    paymentMethodId?: string,\n    paymentWithSavedMethod?: XpsBoolean | string\n  ): {\n    [key: string]: unknown;\n  } {\n    const parameters: XpsRequestParams = {};\n\n    parameters.paymentWithSavedMethod = paymentWithSavedMethod\n      ? paymentWithSavedMethod\n      : XpsBoolean.false;\n\n    if (!paymentMethodId) {\n      return parameters;\n    }\n\n    /* If payment method with 3DSecure */\n    if (cardsWith3ds.includes(Number(paymentMethodId))) {\n      parameters.container3DS = JSON.stringify({\n        browserjavaenabled: this.window.navigator.javaEnabled(),\n        browserlanguage: this.window.navigator.language,\n        browsercolordepth: this.window.screen.colorDepth,\n        browserscreenheight: this.window.screen.availHeight,\n        browserscreenwidth: this.window.screen.availWidth,\n        browsertz: new Date().getTimezoneOffset(),\n        browserappname: this.window.navigator.appName,\n        browserlocaltime: new Date().toString(),\n        browserplatform: this.window.navigator.platform || '',\n        browsercookiesenabled: this.window.navigator.cookieEnabled,\n      });\n    }\n\n    return parameters;\n  }\n\n  private collectUserSessionId(): XpsRequestParams {\n    const parameters: XpsRequestParams = {};\n\n    parameters.xps_idUserSession = this.settingsService.user.session_id ?? '';\n    parameters.user_session_id = this.settingsService.user.session_id ?? '';\n\n    return parameters;\n  }\n}\n"]}

package/esm2022/lib/core/payment/xps-api-part-request.abstract.mjs

@@ -0,0 +1,8 @@
+export class XpsApiPartRequest {
+    addXpsParameters(parameters) {
+        for (const key in parameters) {
+            this[`xps_${key}`] = parameters[key];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHBzLWFwaS1wYXJ0LXJlcXVlc3QuYWJzdHJhY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS9wYXltZW50L3hwcy1hcGktcGFydC1yZXF1ZXN0LmFic3RyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBZ0IsaUJBQWlCO0lBRzNCLGdCQUFnQixDQUFDLFVBQXNDO1FBQy9ELEtBQUssTUFBTSxHQUFHLElBQUksVUFBVSxFQUFFLENBQUM7WUFDN0IsSUFBSSxDQUFDLE9BQU8sR0FBRyxFQUFFLENBQUMsR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdkMsQ0FBQztJQUNILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhYnN0cmFjdCBjbGFzcyBYcHNBcGlQYXJ0UmVxdWVzdCB7XG4gIFtmaWVsZE5hbWU6IGB4cHNfJHtzdHJpbmd9YF06IHVua25vd247XG5cbiAgcHJvdGVjdGVkIGFkZFhwc1BhcmFtZXRlcnMocGFyYW1ldGVyczogeyBba2V5OiBzdHJpbmddOiB1bmtub3duIH0pOiB2b2lkIHtcbiAgICBmb3IgKGNvbnN0IGtleSBpbiBwYXJhbWV0ZXJzKSB7XG4gICAgICB0aGlzW2B4cHNfJHtrZXl9YF0gPSBwYXJhbWV0ZXJzW2tleV07XG4gICAgfVxuICB9XG59XG4iXX0=