@xsolla/payment-client-core 0.2.20 → 0.2.21

package/esm2020/lib/core/payment/status/status.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import { firstValueFrom, skip } from 'rxjs';
+import { requiredStatusSearchParams } from './status-request/required-status-search-params.const';
+import { statusSearchParamsMap } from './status-request/status-search-params.map';
+import * as i0 from "@angular/core";
+import * as i1 from "../../url/url.service";
+import * as i2 from "./status-request/status-request.service";
+import * as i3 from "../finance-details/finance-details.service";
+import * as i4 from "./listen-status/listen-status.service";
+import * as i5 from "../actions/next-action.service";
+import * as i6 from "./save-payment-method-status/save-payment-method-status.service";
+import * as i7 from "../actions/status-updated/status-updated.action.class";
+export class StatusService {
+    constructor(urlService, statusRequestService, financeDetailsService, listenStatusService, nextActionService, savePaymentMethodStatusService, statusUpdatedActionCreator) {
+        this.urlService = urlService;
+        this.statusRequestService = statusRequestService;
+        this.financeDetailsService = financeDetailsService;
+        this.listenStatusService = listenStatusService;
+        this.nextActionService = nextActionService;
+        this.savePaymentMethodStatusService = savePaymentMethodStatusService;
+        this.statusUpdatedActionCreator = statusUpdatedActionCreator;
+    }
+    async getStatus(params) {
+        const isSavePaymentMethodMode = params?.isSavePaymentAccount === "1" /* XpsBoolean.true */;
+        if (isSavePaymentMethodMode) {
+            return this.savePaymentMethodStatusService.getStatus(params);
+        }
+        this.statusRequestService.setRequestParams(params);
+        this.startWaitingStatusUpdates(params.invoice);
+        this.statusRequestService.request();
+        const statusResponse = await firstValueFrom(this.statusRequestService.response$);
+        this.financeDetailsService.emitWithStatus(statusResponse.status);
+        return statusResponse.status;
+    }
+    async getStatusWithUrlSearchParams(url) {
+        const searchParams = this.getRequestParamsFromUrl(url);
+        if (!searchParams) {
+            throw new Error('No required search params to get status');
+        }
+        return this.getStatus(searchParams);
+    }
+    listenFinalStatus(invoice) {
+        return this.listenStatusService.listen(invoice);
+    }
+    getRequestParamsFromUrl(url) {
+        const searchParams = this.urlService.getSearchParams(url ?? '');
+        const keys = new Set(Object.keys(searchParams));
+        if (requiredStatusSearchParams.some((requiredKey) => !keys.has(requiredKey))) {
+            return null;
+        }
+        const params = {};
+        statusSearchParamsMap.forEach((settings, key) => {
+            params[settings.key] = settings.converter(searchParams[key]);
+        });
+        return params;
+    }
+    startWaitingStatusUpdates(invoice) {
+        this.listenStatusService.listen(invoice);
+        this.listenStatusService.statusUpdated$
+            .pipe(skip(1))
+            .subscribe(({ statusResponse }) => {
+            this.financeDetailsService.emitWithStatus(statusResponse.status);
+            this.nextActionService.emitFlowUpdates(this.statusUpdatedActionCreator.getActionData({ statusResponse }));
+        });
+    }
+}
+StatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, deps: [{ token: i1.UrlService }, { token: i2.StatusRequestService }, { token: i3.FinanceDetailsService }, { token: i4.ListenStatusService }, { token: i5.NextActionService }, { token: i6.SavePaymentMethodStatusService }, { token: i7.StatusUpdatedActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
+StatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UrlService }, { type: i2.StatusRequestService }, { type: i3.FinanceDetailsService }, { type: i4.ListenStatusService }, { type: i5.NextActionService }, { type: i6.SavePaymentMethodStatusService }, { type: i7.StatusUpdatedActionCreator }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/payment/status/status.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { firstValueFrom, Observable, skip } from 'rxjs';\nimport { StatusRequestService } from './status-request/status-request.service';\nimport { StatusRequestParams } from './status-request/status-request-params.interface';\nimport { ListenStatusService } from './listen-status/listen-status.service';\nimport { Status } from './status.interface';\nimport { NextActionService } from '../actions/next-action.service';\nimport { StatusUpdatedActionCreator } from '../actions/status-updated/status-updated.action.class';\nimport { UrlService } from '../../url/url.service';\nimport { requiredStatusSearchParams } from './status-request/required-status-search-params.const';\nimport { statusSearchParamsMap } from './status-request/status-search-params.map';\nimport { FinanceDetailsService } from '../finance-details/finance-details.service';\nimport { SavePaymentMethodStatusService } from './save-payment-method-status/save-payment-method-status.service';\nimport { XpsBoolean } from '../../xps-boolean.enum';\nimport { StatusSettings } from './status-settings.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StatusService {\n  public constructor(\n    private readonly urlService: UrlService,\n    private readonly statusRequestService: StatusRequestService,\n    private readonly financeDetailsService: FinanceDetailsService,\n    private readonly listenStatusService: ListenStatusService,\n    private readonly nextActionService: NextActionService,\n    private readonly savePaymentMethodStatusService: SavePaymentMethodStatusService,\n    private readonly statusUpdatedActionCreator: StatusUpdatedActionCreator\n  ) {}\n\n  public async getStatus(params: StatusRequestParams): Promise<Status> {\n    const isSavePaymentMethodMode =\n      params?.isSavePaymentAccount === XpsBoolean.true;\n    if (isSavePaymentMethodMode) {\n      return this.savePaymentMethodStatusService.getStatus(params);\n    }\n\n    this.statusRequestService.setRequestParams(params);\n\n    this.startWaitingStatusUpdates(params.invoice);\n\n    this.statusRequestService.request();\n\n    const statusResponse = await firstValueFrom(\n      this.statusRequestService.response$\n    );\n\n    this.financeDetailsService.emitWithStatus(statusResponse.status);\n\n    return statusResponse.status;\n  }\n\n  public async getStatusWithUrlSearchParams(url?: string): Promise<Status> {\n    const searchParams = this.getRequestParamsFromUrl(url);\n\n    if (!searchParams) {\n      throw new Error('No required search params to get status');\n    }\n\n    return this.getStatus(searchParams);\n  }\n\n  public listenFinalStatus(invoice: number): Observable<StatusSettings> {\n    return this.listenStatusService.listen(invoice);\n  }\n\n  private getRequestParamsFromUrl(url?: string): StatusRequestParams | null {\n    const searchParams = this.urlService.getSearchParams(url ?? '');\n    const keys = new Set(Object.keys(searchParams));\n\n    if (\n      requiredStatusSearchParams.some((requiredKey) => !keys.has(requiredKey))\n    ) {\n      return null;\n    }\n\n    const params: { [key: string]: string | number } = {};\n    statusSearchParamsMap.forEach((settings, key) => {\n      params[settings.key] = settings.converter(searchParams[key]);\n    });\n\n    return params as unknown as StatusRequestParams;\n  }\n\n  private startWaitingStatusUpdates(invoice: number): void {\n    this.listenStatusService.listen(invoice);\n\n    this.listenStatusService.statusUpdated$\n      .pipe(skip(1))\n      .subscribe(({ statusResponse }) => {\n        this.financeDetailsService.emitWithStatus(statusResponse.status);\n\n        this.nextActionService.emitFlowUpdates(\n          this.statusUpdatedActionCreator.getActionData({ statusResponse })\n        );\n      });\n  }\n}\n"]}

package/esm2020/lib/core/payment/status/websocket-status/websocket-status.service.mjs

@@ -0,0 +1,76 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { WebSocketStatus } from './websocket-status.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../web-socket/web-socket.factory";
+export class WebsocketStatusService {
+    get needCheckStatus$() {
+        return this.needCheckStatusSubject.asObservable();
+    }
+    get statusChanged$() {
+        return this.statusChangedSubject.asObservable();
+    }
+    constructor(webSocketFactory) {
+        this.webSocketFactory = webSocketFactory;
+        this.reinsuranceCheckStatus = {
+            timeoutId: null,
+            timeoutMs: 180000,
+        };
+        this.needCheckStatusSubject = new Subject();
+        this.statusChangedSubject = new Subject();
+        this.webSocketClient = null;
+    }
+    async checkStatusWithWebSocket(webSocketUrl, webSocketChannelName, webSocketClientType) {
+        this.webSocketClient = this.webSocketFactory.createWebSocketClient(webSocketUrl, webSocketClientType);
+        await this.webSocketClient.open(webSocketUrl, webSocketChannelName);
+        this.webSocketSubscription?.unsubscribe();
+        this.webSocketSubscription = this.webSocketClient.messages$.subscribe((message) => this.statusProcessing(message));
+        this.webSocketReconnectionSubscription =
+            this.webSocketClient.subscribeOnSuccessfulReconnection(() => {
+                this.needCheckStatusSubject.next();
+            });
+        this.needCheckStatusSubject.next();
+        this.startReinsuranceCheckTimeout();
+    }
+    closeWebSocket() {
+        this.removeSubscription();
+        this.webSocketClient?.close();
+        this.clearReinsuranceCheckTimeout();
+    }
+    startReinsuranceCheckTimeout() {
+        this.clearReinsuranceCheckTimeout();
+        this.reinsuranceCheckStatus.timeoutId = setTimeout(() => {
+            this.needCheckStatusSubject.next();
+        }, this.reinsuranceCheckStatus.timeoutMs);
+    }
+    clearReinsuranceCheckTimeout() {
+        if (this.reinsuranceCheckStatus.timeoutId) {
+            clearTimeout(this.reinsuranceCheckStatus.timeoutId);
+            this.reinsuranceCheckStatus.timeoutId = null;
+        }
+    }
+    statusProcessing(message) {
+        if (message === WebSocketStatus.statusChanged) {
+            this.statusChangedSubject.next();
+            this.closeWebSocket();
+            this.clearReinsuranceCheckTimeout();
+        }
+        if (message === WebSocketStatus.troubledStatus) {
+            this.clearReinsuranceCheckTimeout();
+            this.closeWebSocket();
+        }
+    }
+    removeSubscription() {
+        this.webSocketSubscription?.unsubscribe();
+        this.webSocketReconnectionSubscription?.unsubscribe();
+    }
+}
+WebsocketStatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebsocketStatusService, deps: [{ token: i1.WebSocketFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+WebsocketStatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebsocketStatusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebsocketStatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.WebSocketFactory }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/payment/submit/request/submit-request.class.mjs

@@ -0,0 +1,24 @@
+import { XpsApiPartRequest } from '../../xps-api-part-request.abstract';
+import { TokenError } from '../../../exceptions-handling/errors/token-error.class';
+export class SubmitRequest extends XpsApiPartRequest {
+    constructor(parameters) {
+        super();
+        const { token, fields, form, dfpHash } = parameters;
+        if (token === null) {
+            throw new TokenError();
+        }
+        this.access_token = token;
+        if (dfpHash) {
+            this.xps_dfp_hash = dfpHash;
+        }
+        this.addXpsParameters(this.getFieldsValues(fields, form));
+    }
+    getFieldsValues(fields, form) {
+        return fields.reduce((xpsParams, field) => {
+            const formControl = form.get(field.name);
+            xpsParams[field.name] = formControl ? formControl.value : field?.value;
+            return xpsParams;
+        }, {});
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/payment/submit/response/submit-response.class.mjs

@@ -0,0 +1,31 @@
+import { XpsCommand } from '../../xps-comand.enum';
+import { FieldNames } from '../../field-names.enum';
+export class SubmitResponse {
+    constructor(parameters, responseNumber = 0) {
+        this.responseNumber = responseNumber;
+        /* Todo split into properties */
+        this.parameters = parameters;
+        this.fields = Object.keys(parameters.form).map((key) => parameters.form[key]);
+        if (parameters.onlineBanking) {
+            this.onlineBanking = {
+                url: parameters.onlineBanking.value,
+            };
+        }
+        this.isNeedRedirect =
+            parameters.currentCommand === XpsCommand.account ||
+                (parameters.currentCommand === XpsCommand.checkout &&
+                    Boolean(parameters.checkout));
+        this.buyData = parameters.buyData;
+        this.fixInvoice = this.fields.find((field) => field.name === FieldNames.fixInvoice)?.value;
+        this.signature = this.fields.find((field) => field.name === FieldNames.signature)?.value;
+        this.hasFatalErrors = parameters.textAll?.fatal;
+        this.userSession = parameters.userSession;
+        this.pid = parameters.pid;
+        this.errors = parameters.errors;
+        this.summary = parameters.summary;
+        this.title = parameters.title;
+        this.currentCommand = parameters.currentCommand;
+        this.messages = parameters.messages;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/payment/submit/submit.service.mjs

@@ -0,0 +1,78 @@
+import { Inject, Injectable } from '@angular/core';
+import { submitRequestFactoryToken, } from './request/submit-request.token';
+import { submitResponseFactoryToken, } from './response/submit-response.token';
+import { ResponseError } from '../../exceptions-handling/errors/response-error.class';
+import { UserBehaviourEventName } from '../../user-behaviour-analytics/user-behaviour-event-name.enum';
+import { userBehaviourEventTypes } from '../../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../settings/settings.service";
+import * as i2 from "../../device-finger-print/device-finger-print.service";
+import * as i3 from "../xps-api/xps-api.service";
+import * as i4 from "../../errors-mapping/xps-response-errors-mapping.service";
+import * as i5 from "../../encrypt-credit-card/encrypt-credit-card.service";
+import * as i6 from "../../user-behaviour-analytics/user-behaviour-analytics.service";
+export class SubmitService {
+    constructor(requestFactory, responseFactory, settingsService, deviceFingerPrintService, xpsApiService, xpsResponseErrorsMappingService, encryptCreditCardService, userBehaviourAnalyticsService) {
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.deviceFingerPrintService = deviceFingerPrintService;
+        this.xpsApiService = xpsApiService;
+        this.xpsResponseErrorsMappingService = xpsResponseErrorsMappingService;
+        this.encryptCreditCardService = encryptCreditCardService;
+        this.userBehaviourAnalyticsService = userBehaviourAnalyticsService;
+    }
+    // NB: Never add 'async' statement for this method!
+    // 'Async' statement wraps current promise into another.
+    // In this way two promises become unequal, that can broke XPS API requests logic.
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    request(fields, form) {
+        return (this.deviceFingerPrintService
+            .getHash()
+            // eslint-disable-next-line @typescript-eslint/promise-function-async
+            .then((dfpHash) => {
+            const requestParams = this.requestFactory({
+                token: this.settingsService.token,
+                fields,
+                form,
+                dfpHash,
+            });
+            const encryptedRequest = this.encryptCreditCardService.encryptCreditCard(requestParams);
+            return this.xpsApiService
+                .directPaymentRequest(encryptedRequest)
+                .then((xpsResponse) => {
+                const response = this.xpsResponseErrorsMappingService.mapErrors(xpsResponse);
+                this.fillUserSession(xpsResponse);
+                if (response.errors) {
+                    const logError = (error) => {
+                        this.userBehaviourAnalyticsService.send(UserBehaviourEventName.showErrorMessage, userBehaviourEventTypes.manual, { value: String(error.code), extraValue: error.message });
+                    };
+                    response.errors.forEach(logError);
+                }
+                return this.responseFactory(response);
+            })
+                .catch((error) => {
+                throw new ResponseError(error.message);
+            });
+        }));
+    }
+    fillUserSession(xpsResponse) {
+        this.userBehaviourAnalyticsService.fillUserSession({
+            ...xpsResponse,
+            fields: Object.keys(xpsResponse.form).map((key) => xpsResponse.form[key]),
+        });
+    }
+}
+SubmitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SubmitService, deps: [{ token: submitRequestFactoryToken }, { token: submitResponseFactoryToken }, { token: i1.SettingsService }, { token: i2.DeviceFingerPrintService }, { token: i3.XpsApiService }, { token: i4.XpsResponseErrorsMappingService }, { token: i5.EncryptCreditCardService }, { token: i6.UserBehaviourAnalyticsService }], target: i0.ɵɵFactoryTarget.Injectable });
+SubmitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SubmitService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SubmitService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [submitRequestFactoryToken]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [submitResponseFactoryToken]
+                }] }, { type: i1.SettingsService }, { type: i2.DeviceFingerPrintService }, { type: i3.XpsApiService }, { type: i4.XpsResponseErrorsMappingService }, { type: i5.EncryptCreditCardService }, { type: i6.UserBehaviourAnalyticsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"submit.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/payment/submit/submit.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Field } from '../field.interface';\nimport { Inject, Injectable } from '@angular/core';\nimport {\n  SubmitRequestFactory,\n  submitRequestFactoryToken,\n} from './request/submit-request.token';\nimport {\n  SubmitResponseFactory,\n  submitResponseFactoryToken,\n} from './response/submit-response.token';\nimport { SettingsService } from '../../settings/settings.service';\nimport { SubmitResponse } from './response/submit-response.class';\nimport { UntypedFormGroup } from '@angular/forms';\nimport { DeviceFingerPrintService } from '../../device-finger-print/device-finger-print.service';\nimport { ResponseError } from '../../exceptions-handling/errors/response-error.class';\nimport { XpsResponse } from '../xps-response.interface';\nimport { XpsApiService } from '../xps-api/xps-api.service';\nimport { EncryptCreditCardService } from '../../encrypt-credit-card/encrypt-credit-card.service';\nimport { SubmitRequest } from './request/submit-request.class';\nimport { XpsResponseErrorsMappingService } from '../../errors-mapping/xps-response-errors-mapping.service';\nimport { UserBehaviourEventName } from '../../user-behaviour-analytics/user-behaviour-event-name.enum';\nimport { userBehaviourEventTypes } from '../../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types';\nimport { UserBehaviourAnalyticsService } from '../../user-behaviour-analytics/user-behaviour-analytics.service';\n\n@Injectable({ providedIn: 'root' })\nexport class SubmitService {\n  public constructor(\n    @Inject(submitRequestFactoryToken)\n    private readonly requestFactory: SubmitRequestFactory,\n    @Inject(submitResponseFactoryToken)\n    private readonly responseFactory: SubmitResponseFactory,\n    private readonly settingsService: SettingsService,\n    private readonly deviceFingerPrintService: DeviceFingerPrintService,\n    private readonly xpsApiService: XpsApiService,\n    private readonly xpsResponseErrorsMappingService: XpsResponseErrorsMappingService,\n    private readonly encryptCreditCardService: EncryptCreditCardService,\n    private readonly userBehaviourAnalyticsService: UserBehaviourAnalyticsService\n  ) {}\n\n  // NB: Never add 'async' statement for this method!\n  // 'Async' statement wraps current promise into another.\n  // In this way two promises become unequal, that can broke XPS API requests logic.\n\n  // eslint-disable-next-line @typescript-eslint/promise-function-async\n  public request(\n    fields: Field[],\n    form: UntypedFormGroup\n  ): Promise<SubmitResponse> {\n    return (\n      this.deviceFingerPrintService\n        .getHash()\n        // eslint-disable-next-line @typescript-eslint/promise-function-async\n        .then((dfpHash) => {\n          const requestParams = this.requestFactory({\n            token: this.settingsService.token,\n            fields,\n            form,\n            dfpHash,\n          });\n\n          const encryptedRequest =\n            this.encryptCreditCardService.encryptCreditCard<SubmitRequest>(\n              requestParams\n            );\n\n          return this.xpsApiService\n            .directPaymentRequest(encryptedRequest)\n            .then((xpsResponse: XpsResponse) => {\n              const response =\n                this.xpsResponseErrorsMappingService.mapErrors(xpsResponse);\n\n              this.fillUserSession(xpsResponse);\n\n              if (response.errors) {\n                const logError = (error: {\n                  code: number;\n                  message: string;\n                }): void => {\n                  this.userBehaviourAnalyticsService.send(\n                    UserBehaviourEventName.showErrorMessage,\n                    userBehaviourEventTypes.manual,\n                    { value: String(error.code), extraValue: error.message }\n                  );\n                };\n\n                response.errors.forEach(logError);\n              }\n\n              return this.responseFactory(response);\n            })\n            .catch((error: Error) => {\n              throw new ResponseError(error.message);\n            });\n        })\n    );\n  }\n\n  private fillUserSession(xpsResponse: XpsResponse): void {\n    this.userBehaviourAnalyticsService.fillUserSession({\n      ...xpsResponse,\n      fields: Object.keys(xpsResponse.form).map(\n        (key: string): Field => (xpsResponse as XpsResponse).form[key]\n      ),\n    });\n  }\n}\n"]}

package/esm2020/lib/core/payment/sync/request/sync-request.class.mjs

@@ -0,0 +1,31 @@
+import { XpsApiPartRequest } from '../../xps-api-part-request.abstract';
+/* eslint-disable @typescript-eslint/naming-convention */
+export class SyncRequest extends XpsApiPartRequest {
+    constructor(parameters) {
+        super();
+        this.xps_fix_command = 'calculate';
+        this.access_token = parameters.token;
+        const fieldsValues = this.getFieldsValues(parameters.changedField, parameters.fields, parameters.form);
+        this.addXpsParameters({
+            ...fieldsValues,
+            change_element: parameters.changedField.name,
+        });
+    }
+    getFieldsValues(changedField, fields, form) {
+        const fieldsMap = this.getFieldsMap(fields);
+        return changedField?.javascript?.change.params.reduce((xpsParams, fieldName) => {
+            const formControl = form.get(fieldName);
+            const field = fieldsMap.get(fieldName);
+            if (formControl || field) {
+                xpsParams[fieldName] = formControl?.value ?? field?.value;
+            }
+            return xpsParams;
+        }, {});
+    }
+    getFieldsMap(fields) {
+        const map = new Map();
+        fields.forEach((field) => map.set(field.name, field));
+        return map;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy1yZXF1ZXN0LmNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGF5bWVudC1jbGllbnQtY29yZS9zcmMvbGliL2NvcmUvcGF5bWVudC9zeW5jL3JlcXVlc3Qvc3luYy1yZXF1ZXN0LmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXhFLHlEQUF5RDtBQUN6RCxNQUFNLE9BQU8sV0FBWSxTQUFRLGlCQUFpQjtJQUloRCxZQUFtQixVQUtsQjtRQUNDLEtBQUssRUFBRSxDQUFDO1FBUk0sb0JBQWUsR0FBRyxXQUFXLENBQUM7UUFVNUMsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO1FBRXJDLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQ3ZDLFVBQVUsQ0FBQyxZQUFZLEVBQ3ZCLFVBQVUsQ0FBQyxNQUFNLEVBQ2pCLFVBQVUsQ0FBQyxJQUFJLENBQ2hCLENBQUM7UUFFRixJQUFJLENBQUMsZ0JBQWdCLENBQUM7WUFDcEIsR0FBRyxZQUFZO1lBQ2YsY0FBYyxFQUFFLFVBQVUsQ0FBQyxZQUFZLENBQUMsSUFBSTtTQUM3QyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sZUFBZSxDQUNyQixZQUFtQixFQUNuQixNQUFlLEVBQ2YsSUFBc0I7UUFFdEIsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUM1QyxPQUFPLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQ25ELENBQUMsU0FBb0MsRUFBRSxTQUFpQixFQUFFLEVBQUU7WUFDMUQsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUN4QyxNQUFNLEtBQUssR0FBc0IsU0FBUyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUUxRCxJQUFJLFdBQVcsSUFBSSxLQUFLLEVBQUU7Z0JBQ3hCLFNBQVMsQ0FBQyxTQUFTLENBQUMsR0FBRyxXQUFXLEVBQUUsS0FBSyxJQUFJLEtBQUssRUFBRSxLQUFLLENBQUM7YUFDM0Q7WUFFRCxPQUFPLFNBQVMsQ0FBQztRQUNuQixDQUFDLEVBQ0QsRUFBRSxDQUNILENBQUM7SUFDSixDQUFDO0lBRU8sWUFBWSxDQUFDLE1BQWU7UUFDbEMsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLEVBQWlCLENBQUM7UUFDckMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDdEQsT0FBTyxHQUFHLENBQUM7SUFDYixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVbnR5cGVkRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgRmllbGQgfSBmcm9tICcuLi8uLi9maWVsZC5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgWHBzQXBpUGFydFJlcXVlc3QgfSBmcm9tICcuLi8uLi94cHMtYXBpLXBhcnQtcmVxdWVzdC5hYnN0cmFjdCc7XG5cbi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvbiAqL1xuZXhwb3J0IGNsYXNzIFN5bmNSZXF1ZXN0IGV4dGVuZHMgWHBzQXBpUGFydFJlcXVlc3Qge1xuICBwdWJsaWMgcmVhZG9ubHkgYWNjZXNzX3Rva2VuOiBzdHJpbmc7XG4gIHB1YmxpYyByZWFkb25seSB4cHNfZml4X2NvbW1hbmQgPSAnY2FsY3VsYXRlJztcblxuICBwdWJsaWMgY29uc3RydWN0b3IocGFyYW1ldGVyczoge1xuICAgIHRva2VuOiBzdHJpbmc7XG4gICAgY2hhbmdlZEZpZWxkOiBGaWVsZDtcbiAgICBmaWVsZHM6IEZpZWxkW107XG4gICAgZm9ybTogVW50eXBlZEZvcm1Hcm91cDtcbiAgfSkge1xuICAgIHN1cGVyKCk7XG5cbiAgICB0aGlzLmFjY2Vzc190b2tlbiA9IHBhcmFtZXRlcnMudG9rZW47XG5cbiAgICBjb25zdCBmaWVsZHNWYWx1ZXMgPSB0aGlzLmdldEZpZWxkc1ZhbHVlcyhcbiAgICAgIHBhcmFtZXRlcnMuY2hhbmdlZEZpZWxkLFxuICAgICAgcGFyYW1ldGVycy5maWVsZHMsXG4gICAgICBwYXJhbWV0ZXJzLmZvcm1cbiAgICApO1xuXG4gICAgdGhpcy5hZGRYcHNQYXJhbWV0ZXJzKHtcbiAgICAgIC4uLmZpZWxkc1ZhbHVlcyxcbiAgICAgIGNoYW5nZV9lbGVtZW50OiBwYXJhbWV0ZXJzLmNoYW5nZWRGaWVsZC5uYW1lLFxuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBnZXRGaWVsZHNWYWx1ZXMoXG4gICAgY2hhbmdlZEZpZWxkOiBGaWVsZCxcbiAgICBmaWVsZHM6IEZpZWxkW10sXG4gICAgZm9ybTogVW50eXBlZEZvcm1Hcm91cFxuICApOiB7IFtrZXk6IHN0cmluZ106IHVua25vd24gfSB7XG4gICAgY29uc3QgZmllbGRzTWFwID0gdGhpcy5nZXRGaWVsZHNNYXAoZmllbGRzKTtcbiAgICByZXR1cm4gY2hhbmdlZEZpZWxkPy5qYXZhc2NyaXB0Py5jaGFuZ2UucGFyYW1zLnJlZHVjZShcbiAgICAgICh4cHNQYXJhbXM6IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH0sIGZpZWxkTmFtZTogc3RyaW5nKSA9PiB7XG4gICAgICAgIGNvbnN0IGZvcm1Db250cm9sID0gZm9ybS5nZXQoZmllbGROYW1lKTtcbiAgICAgICAgY29uc3QgZmllbGQ6IEZpZWxkIHwgdW5kZWZpbmVkID0gZmllbGRzTWFwLmdldChmaWVsZE5hbWUpO1xuXG4gICAgICAgIGlmIChmb3JtQ29udHJvbCB8fCBmaWVsZCkge1xuICAgICAgICAgIHhwc1BhcmFtc1tmaWVsZE5hbWVdID0gZm9ybUNvbnRyb2w/LnZhbHVlID8/IGZpZWxkPy52YWx1ZTtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiB4cHNQYXJhbXM7XG4gICAgICB9LFxuICAgICAge31cbiAgICApO1xuICB9XG5cbiAgcHJpdmF0ZSBnZXRGaWVsZHNNYXAoZmllbGRzOiBGaWVsZFtdKTogTWFwPHN0cmluZywgRmllbGQ+IHtcbiAgICBjb25zdCBtYXAgPSBuZXcgTWFwPHN0cmluZywgRmllbGQ+KCk7XG4gICAgZmllbGRzLmZvckVhY2goKGZpZWxkKSA9PiBtYXAuc2V0KGZpZWxkLm5hbWUsIGZpZWxkKSk7XG4gICAgcmV0dXJuIG1hcDtcbiAgfVxufVxuIl19

package/esm2020/lib/core/payment/sync/response/sync-response.class.mjs

@@ -0,0 +1,17 @@
+export class SyncResponse {
+    constructor(changedField, response) {
+        this.error = null;
+        const fieldError = response?.errors?.find((error) => error.element_name === changedField.name);
+        if (fieldError) {
+            this.error = {
+                asyncError: {
+                    code: fieldError.code,
+                    message: fieldError.message,
+                },
+            };
+        }
+        this.fields = Object.keys(response.form).map((key) => response.form[key]);
+        this.parameters = response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/payment/sync/sync.service.mjs

@@ -0,0 +1,157 @@
+import { Inject, Injectable } from '@angular/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { EmitDataService } from '../emit-data.service.abstract';
+import { syncRequestFactoryToken, } from './request/sync-request.token';
+import { syncResponseFactoryToken, } from './response/sync-response.token';
+import { UserBehaviourEventName } from '../../user-behaviour-analytics/user-behaviour-event-name.enum';
+import { userBehaviourEventTypes } from '../../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types';
+import * as i0 from "@angular/core";
+import * as i1 from "../xps-api/xps-api.service";
+import * as i2 from "../actions/next-action.service";
+import * as i3 from "../../settings/settings.service";
+import * as i4 from "../../errors-mapping/xps-response-errors-mapping.service";
+import * as i5 from "../../encrypt-credit-card/encrypt-credit-card.service";
+import * as i6 from "../actions/show-errors/show-errors.action.class";
+import * as i7 from "../../user-behaviour-analytics/user-behaviour-analytics.service";
+export class SyncService extends EmitDataService {
+    constructor(requestFactory, responseFactory, xpsApiService, nextActionService, settingsService, xpsResponseErrorsMappingService, encryptCreditCardService, showErrorsActionCreator, userBehaviourAnalyticsService) {
+        super();
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.xpsApiService = xpsApiService;
+        this.nextActionService = nextActionService;
+        this.settingsService = settingsService;
+        this.xpsResponseErrorsMappingService = xpsResponseErrorsMappingService;
+        this.encryptCreditCardService = encryptCreditCardService;
+        this.showErrorsActionCreator = showErrorsActionCreator;
+        this.userBehaviourAnalyticsService = userBehaviourAnalyticsService;
+        this.prevFieldSyncStates = {};
+        this.form = new UntypedFormGroup({});
+        this.fields = [];
+        this.fieldSyncTimers = {};
+        this.fieldAsyncValidation = new Subject();
+    }
+    get fieldAsyncValidation$() {
+        return this.fieldAsyncValidation.asObservable();
+    }
+    setup(form, fields) {
+        this.reset();
+        this.form = form;
+        this.fields = fields;
+    }
+    reset() {
+        this.prevFieldSyncStates = {};
+        this.form = new UntypedFormGroup({});
+        this.fields = [];
+    }
+    async validate(field, delay = Number('750')) {
+        if (!this.isReadyField(field)) {
+            return Promise.resolve(null);
+        }
+        const control = this.form.get(field.name);
+        const value = control?.value;
+        const prevFieldState = this.getPrevFieldSyncState(field);
+        const isInitialValue = value === field.value && !prevFieldState;
+        if (isInitialValue) {
+            return Promise.resolve(null);
+        }
+        if (prevFieldState && value === prevFieldState.value) {
+            return Promise.resolve(prevFieldState.result).then((response) => {
+                return response?.error ?? null;
+            });
+        }
+        const updateFieldState = async () => {
+            const requestPromise = this.request(field);
+            this.setPrevFieldSyncState(field, value, requestPromise);
+            return requestPromise.then((response) => {
+                this.fieldAsyncValidation.next({
+                    value,
+                    field,
+                    response,
+                });
+                return response.error ?? null;
+            });
+        };
+        return new Promise((resolve) => {
+            if (delay) {
+                const timerId = setTimeout(() => {
+                    if (value !== control?.value) {
+                        return resolve(null);
+                    }
+                    void updateFieldState().then((errors) => resolve(errors));
+                }, delay);
+                this.resetFieldSyncTimer(field, Number(timerId));
+            }
+            else {
+                void updateFieldState().then((errors) => resolve(errors));
+            }
+        });
+    }
+    getSyncValidationErrors(field) {
+        const control = this.form.get(field.name);
+        return control?.errors ?? null;
+    }
+    async request(field) {
+        const requestParams = this.requestFactory({
+            token: this.settingsService.token,
+            changedField: field,
+            fields: this.fields,
+            form: this.form,
+        });
+        const encryptedRequest = this.encryptCreditCardService.encryptCreditCard(requestParams);
+        return this.xpsApiService
+            .directPaymentRequest(encryptedRequest)
+            .then((xpsResponse) => {
+            const response = this.xpsResponseErrorsMappingService.mapErrors(xpsResponse);
+            this.emitFormErrors(response);
+            this.emit(response);
+            return this.responseFactory(field, response);
+        });
+    }
+    isReadyField(field) {
+        const isSyncEnabled = !!field.javascript?.change;
+        const isExistsInForm = !!this.form?.get(field.name);
+        return isSyncEnabled && isExistsInForm;
+    }
+    getPrevFieldSyncState(field) {
+        return this.prevFieldSyncStates[field.name];
+    }
+    setPrevFieldSyncState(field, value, result) {
+        this.prevFieldSyncStates[field.name] = { value, result };
+    }
+    emitFormErrors(response) {
+        if (response.errors) {
+            const logError = (error) => {
+                this.userBehaviourAnalyticsService.send(UserBehaviourEventName.showErrorMessage, userBehaviourEventTypes.manual, { value: String(error.code), extraValue: error.message });
+            };
+            response.errors.forEach(logError);
+        }
+        const formErrors = response.errors?.filter((error) => !error.element_name);
+        if (formErrors?.length) {
+            this.nextActionService.emitFlowUpdates(this.showErrorsActionCreator.getActionData(formErrors));
+        }
+    }
+    resetFieldSyncTimer(field, timerId) {
+        const prevTimerId = this.fieldSyncTimers[field.name];
+        if (prevTimerId) {
+            clearTimeout(prevTimerId);
+        }
+        this.fieldSyncTimers[field.name] = timerId;
+    }
+}
+SyncService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, deps: [{ token: syncRequestFactoryToken }, { token: syncResponseFactoryToken }, { token: i1.XpsApiService }, { token: i2.NextActionService }, { token: i3.SettingsService }, { token: i4.XpsResponseErrorsMappingService }, { token: i5.EncryptCreditCardService }, { token: i6.ShowErrorsActionCreator }, { token: i7.UserBehaviourAnalyticsService }], target: i0.ɵɵFactoryTarget.Injectable });
+SyncService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [syncRequestFactoryToken]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [syncResponseFactoryToken]
+                }] }, { type: i1.XpsApiService }, { type: i2.NextActionService }, { type: i3.SettingsService }, { type: i4.XpsResponseErrorsMappingService }, { type: i5.EncryptCreditCardService }, { type: i6.ShowErrorsActionCreator }, { type: i7.UserBehaviourAnalyticsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/payment/sync/sync.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { UntypedFormGroup, ValidationErrors } from '@angular/forms';\nimport { Observable, Subject } from 'rxjs';\nimport { SettingsService } from '../../settings/settings.service';\nimport { EmitDataService } from '../emit-data.service.abstract';\nimport { Field } from '../field.interface';\nimport { XpsResponse } from '../xps-response.interface';\nimport { FieldSyncState } from './field-sync-state.interface';\nimport {\n  SyncRequestFactory,\n  syncRequestFactoryToken,\n} from './request/sync-request.token';\nimport { SyncResponse } from './response/sync-response.class';\nimport {\n  SyncResponseFactory,\n  syncResponseFactoryToken,\n} from './response/sync-response.token';\nimport { NextActionService } from '../actions/next-action.service';\nimport { ShowErrorsActionCreator } from '../actions/show-errors/show-errors.action.class';\nimport { XpsApiService } from '../xps-api/xps-api.service';\nimport { FieldAsyncValidation } from './field-async-validation.interface';\nimport { EncryptCreditCardService } from '../../encrypt-credit-card/encrypt-credit-card.service';\nimport { SyncRequest } from './request/sync-request.class';\nimport { XpsResponseErrorsMappingService } from '../../errors-mapping/xps-response-errors-mapping.service';\nimport { UserBehaviourAnalyticsService } from '../../user-behaviour-analytics/user-behaviour-analytics.service';\nimport { UserBehaviourEventName } from '../../user-behaviour-analytics/user-behaviour-event-name.enum';\nimport { userBehaviourEventTypes } from '../../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SyncService extends EmitDataService<XpsResponse> {\n  private prevFieldSyncStates: { [fieldName: string]: FieldSyncState } = {};\n  private form: UntypedFormGroup = new UntypedFormGroup({});\n  private fields: Field[] = [];\n  private fieldSyncTimers: { [fieldName: string]: number } = {};\n  private readonly fieldAsyncValidation = new Subject<FieldAsyncValidation>();\n\n  public constructor(\n    @Inject(syncRequestFactoryToken)\n    private readonly requestFactory: SyncRequestFactory,\n    @Inject(syncResponseFactoryToken)\n    private readonly responseFactory: SyncResponseFactory,\n    private readonly xpsApiService: XpsApiService,\n    private readonly nextActionService: NextActionService,\n    private readonly settingsService: SettingsService,\n    private readonly xpsResponseErrorsMappingService: XpsResponseErrorsMappingService,\n    private readonly encryptCreditCardService: EncryptCreditCardService,\n    private readonly showErrorsActionCreator: ShowErrorsActionCreator,\n    private readonly userBehaviourAnalyticsService: UserBehaviourAnalyticsService\n  ) {\n    super();\n  }\n\n  public get fieldAsyncValidation$(): Observable<FieldAsyncValidation> {\n    return this.fieldAsyncValidation.asObservable();\n  }\n\n  public setup(form: UntypedFormGroup, fields: Field[]): void {\n    this.reset();\n\n    this.form = form;\n    this.fields = fields;\n  }\n\n  public reset(): void {\n    this.prevFieldSyncStates = {};\n    this.form = new UntypedFormGroup({});\n    this.fields = [];\n  }\n\n  public async validate(\n    field: Field,\n    delay = Number('750')\n  ): Promise<ValidationErrors | null> {\n    if (!this.isReadyField(field)) {\n      return Promise.resolve(null);\n    }\n\n    const control = this.form.get(field.name);\n    const value = control?.value;\n    const prevFieldState = this.getPrevFieldSyncState(field);\n\n    const isInitialValue = value === field.value && !prevFieldState;\n\n    if (isInitialValue) {\n      return Promise.resolve(null);\n    }\n\n    if (prevFieldState && value === prevFieldState.value) {\n      return Promise.resolve(prevFieldState.result).then((response) => {\n        return response?.error ?? null;\n      });\n    }\n\n    const updateFieldState = async (): Promise<\n      string | ValidationErrors | null\n    > => {\n      const requestPromise = this.request(field);\n\n      this.setPrevFieldSyncState(field, value, requestPromise);\n\n      return requestPromise.then((response: SyncResponse) => {\n        this.fieldAsyncValidation.next({\n          value,\n          field,\n          response,\n        });\n\n        return response.error ?? null;\n      });\n    };\n\n    return new Promise((resolve) => {\n      if (delay) {\n        const timerId = setTimeout(() => {\n          if (value !== control?.value) {\n            return resolve(null);\n          }\n\n          void updateFieldState().then(\n            (errors: ValidationErrors | null | string) =>\n              resolve(errors as ValidationErrors)\n          );\n        }, delay);\n\n        this.resetFieldSyncTimer(field, Number(timerId));\n      } else {\n        void updateFieldState().then(\n          (errors: ValidationErrors | null | string) =>\n            resolve(errors as ValidationErrors)\n        );\n      }\n    });\n  }\n\n  public getSyncValidationErrors(field: Field): ValidationErrors | null {\n    const control = this.form.get(field.name);\n    return control?.errors ?? null;\n  }\n\n  protected async request(field: Field): Promise<SyncResponse> {\n    const requestParams = this.requestFactory({\n      token: this.settingsService.token,\n      changedField: field,\n      fields: this.fields,\n      form: this.form,\n    });\n\n    const encryptedRequest =\n      this.encryptCreditCardService.encryptCreditCard<SyncRequest>(\n        requestParams\n      );\n\n    return this.xpsApiService\n      .directPaymentRequest(encryptedRequest)\n      .then((xpsResponse: XpsResponse) => {\n        const response =\n          this.xpsResponseErrorsMappingService.mapErrors(xpsResponse);\n\n        this.emitFormErrors(response);\n        this.emit(response);\n        return this.responseFactory(field, response);\n      });\n  }\n\n  private isReadyField(field: Field): boolean {\n    const isSyncEnabled = !!field.javascript?.change;\n    const isExistsInForm = !!this.form?.get(field.name);\n\n    return isSyncEnabled && isExistsInForm;\n  }\n\n  private getPrevFieldSyncState(field: Field): FieldSyncState {\n    return this.prevFieldSyncStates[field.name];\n  }\n\n  private setPrevFieldSyncState(\n    field: Field,\n    value: unknown,\n    result: Promise<SyncResponse>\n  ): void {\n    this.prevFieldSyncStates[field.name] = { value, result };\n  }\n\n  private emitFormErrors(response: XpsResponse): void {\n    if (response.errors) {\n      const logError = (error: { code: number; message: string }): void => {\n        this.userBehaviourAnalyticsService.send(\n          UserBehaviourEventName.showErrorMessage,\n          userBehaviourEventTypes.manual,\n          { value: String(error.code), extraValue: error.message }\n        );\n      };\n\n      response.errors.forEach(logError);\n    }\n\n    const formErrors = response.errors?.filter((error) => !error.element_name);\n\n    if (formErrors?.length) {\n      this.nextActionService.emitFlowUpdates(\n        this.showErrorsActionCreator.getActionData(formErrors)\n      );\n    }\n  }\n\n  private resetFieldSyncTimer(field: Field, timerId: number): void {\n    const prevTimerId: number = this.fieldSyncTimers[field.name];\n\n    if (prevTimerId) {\n      clearTimeout(prevTimerId);\n    }\n\n    this.fieldSyncTimers[field.name] = timerId;\n  }\n}\n"]}