@xsolla/payment-client-core 0.0.1 → 0.0.3-1

package/fesm2015/xsolla-payment-client-core.mjs

@@ -1,37 +1,603 @@
+import { __awaiter } from 'tslib';
 import * as i0 from '@angular/core';
-import { Injectable, Component, NgModule } from '@angular/core';
+import { InjectionToken, Injectable, Inject, NgModule } from '@angular/core';
+import { firstValueFrom, lastValueFrom, map, throwError } from 'rxjs';
+import * as i1 from '@angular/common/http';
+import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { catchError } from 'rxjs/operators';
+import * as i1$1 from '@angular/router';
+
+class AppError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+
+class EmptyUtilsResponseError extends AppError {
+    constructor() {
+        super('Utils response is empty or not requested. Check your token.');
+    }
+}
+
+const windowToken = new InjectionToken('window');
+
+const defaultApiUrl = 'https://secure.xsolla.com/paystation2/api/';
+const sandboxApiUrl = 'https://sandbox-secure.xsolla.com/paystation2/api/';
+
+class SecureApiClient {
+    constructor(httpClient, window) {
+        this.httpClient = httpClient;
+        this.window = window;
+        this.isSandboxMode = false;
+    }
+    setSandboxMode(isSandboxMode) {
+        this.isSandboxMode = isSandboxMode;
+    }
+    get(url, options) {
+        return this.httpClient.get(`${this.baseUrl}${url}`, options);
+    }
+    post(url, body, options) {
+        return this.httpClient.post(`${this.baseUrl}${url}`, body, options);
+    }
+    patch(url, body, options) {
+        return this.httpClient.patch(`${this.baseUrl}${url}`, body, options);
+    }
+    put(url, body, options) {
+        return this.httpClient.put(`${this.baseUrl}${url}`, body, options);
+    }
+    delete(url, options) {
+        return this.httpClient.delete(`${this.baseUrl}${url}`, options);
+    }
+    get baseUrl() {
+        let predefinedBaseUrl = null;
+        try {
+            predefinedBaseUrl = this.window.localStorage.getItem('devApiUrl');
+        }
+        catch (e) {
+            console.warn('localStorage is not available');
+        }
+        if (predefinedBaseUrl) {
+            return predefinedBaseUrl;
+        }
+        return this.isSandboxMode ? sandboxApiUrl : defaultApiUrl;
+    }
+}
+SecureApiClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, deps: [{ token: i1.HttpClient }, { token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+SecureApiClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [windowToken]
+                    }] }];
+    } });
+
+class SettingsService {
+    get project() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.project;
+    }
+    get purchase() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.purchase;
+    }
+    get settings() {
+        var _a, _b;
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        if ((_a = this.response) === null || _a === void 0 ? void 0 : _a.purchase_external_id) {
+            return Object.assign(Object.assign({}, this.response.settings), { purchase_external_id: this.response.purchase_external_id });
+        }
+        return (_b = this.response) === null || _b === void 0 ? void 0 : _b.settings;
+    }
+    get user() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.user;
+    }
+    get utilsResponse() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response;
+    }
+    get isEmpty() {
+        return !this.response;
+    }
+    get token() {
+        return this._token;
+    }
+    get hasResponse() {
+        return !!this.response;
+    }
+    constructor(secureApi) {
+        this.secureApi = secureApi;
+        this.isInitialized = false;
+        this._token = '';
+        this.sandboxMode = false;
+    }
+    init(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!configuration.token) {
+                return Promise.reject('token is missing');
+            }
+            this._token = configuration.token;
+            this.sandboxMode = !!configuration.sandbox;
+            yield this.sendRequest(this.token);
+            this.isInitialized = true;
+        });
+    }
+    isSandboxMode() {
+        return this.sandboxMode;
+    }
+    sendRequest(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new HttpParams().set('access_token', token);
+            this.secureApi.setSandboxMode(this.isSandboxMode());
+            this.response = yield firstValueFrom(this.secureApi.get('utils', { params }));
+        });
+    }
+}
+SettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, deps: [{ token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: SecureApiClient }]; } });
+
+class CountryService {
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.userDefinedCountry = null;
+    }
+    setCountry(country) {
+        this.userDefinedCountry = country;
+    }
+    getCountry() {
+        var _a;
+        return (_a = this.userDefinedCountry) !== null && _a !== void 0 ? _a : this.getTokenCountry();
+    }
+    getTokenCountry() {
+        return this.settingsService.user.country.value;
+    }
+}
+CountryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+CountryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: SettingsService }]; } });
+
+class ResponseError extends AppError {
+    constructor(message) {
+        super('Response failed' + (message ? `: "${message}".` : '.'));
+    }
+}
+
+var BooleanNumber;
+(function (BooleanNumber) {
+    BooleanNumber[BooleanNumber["false"] = 0] = "false";
+    BooleanNumber[BooleanNumber["true"] = 1] = "true";
+})(BooleanNumber || (BooleanNumber = {}));
+
+class PaymentMethodsResponse {
+    constructor(paymentMethods) {
+        this.especial = paymentMethods.especial.map((method) => this.mapPaymentMethod(method));
+        this.top = paymentMethods.top.map((method) => this.mapPaymentMethod(method));
+        this.remained = paymentMethods.remained.map((method) => this.mapPaymentMethod(method));
+        this.remainedCount = {
+            total: paymentMethods.remained_count.total,
+            visible: paymentMethods.remained_count.visible,
+        };
+    }
+    mapPaymentMethod(method) {
+        return {
+            id: method.id,
+            rank: method.rank,
+            name: method.name,
+            aliases: method.aliases,
+            categories: method.cat,
+            isVisible: method.is_visible,
+            recommended: method.recommended === BooleanNumber.true,
+            enabledSaveAccount: method.enabled_save_account,
+            iconName: method.switch_icon_name,
+        };
+    }
+}
+
+const paymentMethodsResponseFactoryToken = new InjectionToken('PaymentMethodsResponse');
+const paymentMethodsResponseFactoryProvider = {
+    provide: paymentMethodsResponseFactoryToken,
+    useValue: (...args) => new PaymentMethodsResponse(...args),
+};
+
+class PaymentMethodsService {
+    constructor(responseFactory, settingsService, countryService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'remained_payment_methods';
+        this.cache = new Map();
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request();
+            return response.remained;
+        });
+    }
+    getQuickMethods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request();
+            return response.especial;
+        });
+    }
+    request() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+                country: this.countryService.getCountry(),
+            };
+            const cacheKey = JSON.stringify(requestParams);
+            if (!this.cache.has(cacheKey)) {
+                this.cache.set(cacheKey, lastValueFrom(this.secureApi
+                    .post(this.apiRoute, new URLSearchParams(Object.assign({}, requestParams)), {
+                    headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                    responseType: 'json',
+                })
+                    .pipe(map((response) => this.responseFactory(response.payment_methods)))).catch((error) => {
+                    throw new ResponseError(error.message);
+                }));
+            }
+            // @ts-expect-error the map already has the cache with key
+            return this.cache.get(cacheKey);
+        });
+    }
+}
+PaymentMethodsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, deps: [{ token: paymentMethodsResponseFactoryToken }, { token: SettingsService }, { token: CountryService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentMethodsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [paymentMethodsResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: CountryService }, { type: SecureApiClient }];
+    } });
+
+class SavedMethodsResponse {
+    constructor(savedMethods) {
+        this.list = savedMethods.list.map((method) => this.mapSavedMethod(method));
+    }
+    mapSavedMethod(method) {
+        return {
+            currency: method.currency,
+            form: method.form,
+            id: method.id,
+            isSelected: method.isSelected,
+            isBabkaPay: method.is_babka_pay,
+            name: method.name,
+            pid: method.pid,
+            psName: method.psName,
+            recurrentType: method.recurrent_type,
+            replaced: method.replaced,
+            type: method.type,
+            cardExpiryDate: method.card_expiry_date,
+            iconName: method.switch_icon_name,
+            partner: method.partner,
+        };
+    }
+}
+
+const savedMethodsResponseFactoryToken = new InjectionToken('SavedMethodsResponse');
+const savedMethodsResponseFactoryProvider = {
+    provide: savedMethodsResponseFactoryToken,
+    useValue: (...args) => new SavedMethodsResponse(...args),
+};
+
+class SavedMethodsService {
+    constructor(responseFactory, settingsService, countryService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'savedmethods';
+        this.cache = new Map();
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request();
+            return response.list;
+        });
+    }
+    request() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+            };
+            const cacheKey = JSON.stringify(requestParams);
+            if (!this.cache.has(cacheKey)) {
+                this.cache.set(cacheKey, lastValueFrom(this.secureApi
+                    .post(this.apiRoute, new URLSearchParams(Object.assign({}, requestParams)), {
+                    headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                    responseType: 'json',
+                })
+                    .pipe(map((response) => this.responseFactory(response)))).catch((error) => {
+                    throw new ResponseError(error.message);
+                }));
+            }
+            // @ts-expect-error the map already has the cache with key
+            return this.cache.get(cacheKey);
+        });
+    }
+}
+SavedMethodsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavedMethodsService, deps: [{ token: savedMethodsResponseFactoryToken }, { token: SettingsService }, { token: CountryService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SavedMethodsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavedMethodsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavedMethodsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [savedMethodsResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: CountryService }, { type: SecureApiClient }];
+    } });
+
+class UserBalanceResponse {
+    constructor(userBalance) {
+        var _a, _b;
+        this.isEnoughUserBalance = (_a = userBalance.is_enough_user_balance) !== null && _a !== void 0 ? _a : false;
+        this.isEnoughUserRecurrentBalance =
+            (_b = userBalance.is_enough_user_recurrent_balance) !== null && _b !== void 0 ? _b : false;
+    }
+}
+
+const userBalanceResponseFactoryToken = new InjectionToken('UserBalanceResponse');
+const userBalanceResponseFactoryProvider = {
+    provide: userBalanceResponseFactoryToken,
+    useValue: (...args) => new UserBalanceResponse(...args),
+};
+
+class UserBalanceService {
+    constructor(responseFactory, settingsService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'balance/sufficiency';
+        this.cache = new Map();
+    }
+    getUserBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request();
+        });
+    }
+    request() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+            };
+            const cacheKey = JSON.stringify(requestParams);
+            if (!this.cache.has(cacheKey)) {
+                this.cache.set(cacheKey, lastValueFrom(this.secureApi
+                    .post(this.apiRoute, new URLSearchParams(Object.assign({}, requestParams)), {
+                    headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                    responseType: 'json',
+                })
+                    .pipe(map((response) => this.responseFactory(response)))).catch((error) => {
+                    throw new ResponseError(error.message);
+                }));
+            }
+            // @ts-expect-error the map already has the cache with key
+            return this.cache.get(cacheKey);
+        });
+    }
+}
+UserBalanceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserBalanceService, deps: [{ token: userBalanceResponseFactoryToken }, { token: SettingsService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+UserBalanceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserBalanceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserBalanceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [userBalanceResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: SecureApiClient }];
+    } });
+
+class RefundPolicyService {
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.defaultVersionId = 2;
+        this.defaultUrl = 'https://xsolla.com/refund-policy-ps';
+    }
+    get url() {
+        var _a, _b, _c, _d;
+        if (!this.settingsService.token) {
+            return 'https://xsolla.com/refundpolicy/en-us';
+        }
+        const language = (_a = this.settingsService.user.local) !== null && _a !== void 0 ? _a : 'en';
+        const versionId = (_c = (_b = this.settingsService.project.refundPolicySettings) === null || _b === void 0 ? void 0 : _b.policy_version_id) !== null && _c !== void 0 ? _c : this.defaultVersionId;
+        const countryIso = (_d = this.settingsService.user.country.value) !== null && _d !== void 0 ? _d : '';
+        const projectId = this.settingsService.project.id;
+        return `${this.defaultUrl}?policy_version_id=${versionId}&language=${language}&country=${countryIso}&project_id=${projectId}`;
+    }
+}
+RefundPolicyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RefundPolicyService, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+RefundPolicyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RefundPolicyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RefundPolicyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: SettingsService }]; } });
+
+class LegalService {
+    get isJapanUser() {
+        var _a;
+        return ((_a = this.settingsService.user) === null || _a === void 0 ? void 0 : _a.local) === 'ja';
+    }
+    constructor(settingsService, refundPolicyService) {
+        this.settingsService = settingsService;
+        this.refundPolicyService = refundPolicyService;
+        this.sctlPolicyUrl = 'https://xsolla.com/sctl';
+    }
+    getLegalComponentConfig() {
+        return {
+            isJapanUser: this.isJapanUser,
+            refundPolicyUrl: this.refundPolicyService.url,
+            sctlPolicyUrl: this.sctlPolicyUrl,
+        };
+    }
+}
+LegalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: LegalService, deps: [{ token: SettingsService }, { token: RefundPolicyService }], target: i0.ɵɵFactoryTarget.Injectable });
+LegalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: LegalService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: LegalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: SettingsService }, { type: RefundPolicyService }]; } });
 
 class CoreLibraryService {
+    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, legalService) {
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.paymentMethodsService = paymentMethodsService;
+        this.savedMethodsService = savedMethodsService;
+        this.userBalanceService = userBalanceService;
+        this.legalService = legalService;
+        this.paymentMethods = {
+            getList: () => __awaiter(this, void 0, void 0, function* () { return this.paymentMethodsService.getList(); }),
+            getQuickMethods: () => __awaiter(this, void 0, void 0, function* () { return this.paymentMethodsService.getQuickMethods(); }),
+            getSavedMethods: () => __awaiter(this, void 0, void 0, function* () { return this.savedMethodsService.getList(); }),
+            getUserBalance: () => __awaiter(this, void 0, void 0, function* () { return this.userBalanceService.getUserBalance(); }),
+        };
+    }
+    init(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.settingsService.init(configuration);
+        });
+    }
+    setCountry(country) {
+        this.countryService.setCountry(country);
+    }
+    getLegalComponentConfig() {
+        return this.legalService.getLegalComponentConfig();
+    }
 }
-CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }, { token: SavedMethodsService }, { token: UserBalanceService }, { token: LegalService }], target: i0.ɵɵFactoryTarget.Injectable });
 CoreLibraryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }] });
+        }], ctorParameters: function () { return [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: LegalService }]; } });
 
-class CoreLibraryComponent {
+class HttpError extends AppError {
+    constructor(error, req) {
+        var _a;
+        super(error.message);
+        this.RESTRICTED_KEYS_REGEXP = new RegExp('.*(card_number|number|cvv|cvn|month|year|cardholdername|client_data|dfp|password).*', 'i');
+        this.httpErrorData = {
+            request: {
+                url: req.url,
+                method: req.method,
+                headers: req.headers,
+            },
+            response: {
+                status: error.status,
+                headers: error.headers,
+            },
+        };
+        if (req.body) {
+            this.httpErrorData.request.data = this.cleanPersonalData(req.body);
+        }
+        if (error.statusText) {
+            const errorData = error.error;
+            this.httpErrorData.response.data = {
+                statusText: error.statusText,
+                errors: (_a = errorData === null || errorData === void 0 ? void 0 : errorData.errors) !== null && _a !== void 0 ? _a : [],
+            };
+        }
+    }
+    getHttpErrorData() {
+        return this.httpErrorData;
+    }
+    cleanPersonalData(data) {
+        return Object.entries(data).reduce((acc, [key, val]) => {
+            return Object.assign(Object.assign({}, acc), { [key]: this.RESTRICTED_KEYS_REGEXP.test(key) ? '***' : val });
+        }, {});
+    }
 }
-CoreLibraryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-CoreLibraryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: CoreLibraryComponent, selector: "x-payment-client-core", ngImport: i0, template: ` <p>core-library works!</p> `, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'x-payment-client-core', template: ` <p>core-library works!</p> ` }]
-        }] });
+
+class HttpExceptionsInterceptor {
+    constructor(router) {
+        this.router = router;
+    }
+    intercept(req, next) {
+        return next.handle(req).pipe(catchError((error) => {
+            return throwError(() => new HttpError(error, req));
+        }));
+    }
+}
+HttpExceptionsInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpExceptionsInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Router }]; } });
 
 class CoreLibraryModule {
 }
 CoreLibraryModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CoreLibraryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, declarations: [CoreLibraryComponent], exports: [CoreLibraryComponent] });
-CoreLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule });
+CoreLibraryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, imports: [HttpClientModule] });
+CoreLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, providers: [
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: HttpExceptionsInterceptor,
+            multi: true,
+        },
+        { provide: windowToken, useValue: window },
+        paymentMethodsResponseFactoryProvider,
+        savedMethodsResponseFactoryProvider,
+        userBalanceResponseFactoryProvider,
+    ], imports: [HttpClientModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [CoreLibraryComponent],
-                    imports: [],
-                    exports: [CoreLibraryComponent],
+                    imports: [HttpClientModule],
+                    providers: [
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: HttpExceptionsInterceptor,
+                            multi: true,
+                        },
+                        { provide: windowToken, useValue: window },
+                        paymentMethodsResponseFactoryProvider,
+                        savedMethodsResponseFactoryProvider,
+                        userBalanceResponseFactoryProvider,
+                    ],
                 }]
         }] });
 
@@ -43,5 +609,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CoreLibraryComponent, CoreLibraryModule, CoreLibraryService };
+export { CoreLibraryModule, CoreLibraryService };
 //# sourceMappingURL=xsolla-payment-client-core.mjs.map