@xsolla/payment-client-core 0.0.9 → 0.0.10-1

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

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Inject, isDevMode, NgModule } from '@angular/core';
-import { firstValueFrom, lastValueFrom, map, BehaviorSubject, Subject, filter as filter$1, takeUntil, skip, throwError } from 'rxjs';
+import { firstValueFrom, lastValueFrom, map, Subject, BehaviorSubject, filter as filter$1, takeUntil, skip, throwError } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
 import { UntypedFormGroup, Validators, UntypedFormControl, ReactiveFormsModule } from '@angular/forms';
@@ -454,11 +454,14 @@ class InitializeService {
         this.settingsService = settingsService;
         this.countryService = countryService;
         this.apiRoute = 'directpayment';
+        // TODO PAYMENTS-15743: replace with new refer id for headless core
+        this.ps4ReferId = '22';
     }
     async request(config) {
         const requestParams = {
             access_token: this.settingsService.token,
             pid: String(config.paymentMethodId),
+            refer: this.ps4ReferId,
             country: this.countryService.getCountry(),
             returnUrl: config.returnUrl,
         };
@@ -856,6 +859,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                     args: [submitResponseFactoryToken]
                 }] }, { type: SettingsService }, { type: DeviceFingerPrintService }, { type: SecureApiClient }]; } });
 
+class EmitDataService {
+    constructor() {
+        this.dataSubject = new Subject();
+        this.data$ = this.dataSubject.asObservable();
+    }
+    emit(data) {
+        this.dataSubject.next(data);
+    }
+}
+
 class XpsRequest {
     addXpsParameters(parameters) {
         for (const key in parameters) {
@@ -920,8 +933,9 @@ const syncResponseFactoryProvider = {
     useValue: (...args) => new SyncResponse(...args),
 };
 
-class SyncService {
+class SyncService extends EmitDataService {
     constructor(requestFactory, responseFactory, secureApi, settingsService) {
+        super();
         this.requestFactory = requestFactory;
         this.responseFactory = responseFactory;
         this.secureApi = secureApi;
@@ -961,6 +975,14 @@ class SyncService {
             return response.rewritableError ?? null;
         });
     }
+    getSyncValidationErrors(field) {
+        const control = this.form.get(field.name);
+        if (!control) {
+            return null;
+        }
+        const rewritableError = control.errors?.rewritableError;
+        return rewritableError ? { message: rewritableError.message } : null;
+    }
     async request(field) {
         const requestParams = this.requestFactory({
             token: this.settingsService.token,
@@ -972,6 +994,7 @@ class SyncService {
             headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
             responseType: 'json',
         })).then((response) => {
+            this.emit(response);
             return this.responseFactory(field, response);
         });
     }
@@ -1058,7 +1081,7 @@ class Converter {
         return config;
     }
     convertToFormControl(field) {
-        return new UntypedFormControl(this.getValue(field), this.getValidators(field), this.getAsyncValidators(field));
+        return new UntypedFormControl(this.getValue(field), this.getValidators(field));
     }
     getValidators(field) {
         const validators = [];
@@ -1077,9 +1100,6 @@ class Converter {
         }
         return validators;
     }
-    getAsyncValidators(field) {
-        return async () => this.syncService.validate(field);
-    }
     createDefaultControlConfig(controlConfigClass, field) {
         const config = new controlConfigClass();
         this.copyCommonOptions(config, field);
@@ -1164,8 +1184,8 @@ class ZipConverter extends Converter {
         const validators = super
             .getValidators(field)
             .concat([
-            convert(Validators.minLength(minLength), 'Enter at least ${minLength} characters'),
-            convert(Validators.maxLength(maxLength), 'Enter no more than ${maxLength} characters'),
+            convert(Validators.minLength(minLength), `Enter at least ${minLength} characters`),
+            convert(Validators.maxLength(maxLength), `Enter no more than ${maxLength} characters`),
         ]);
         if (this.isUsCountry) {
             validators.push(convert(restrictedValueValidator('00000'), 'Enter a valid ZIP code'));
@@ -2401,25 +2421,295 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: StatusRequestService }, { type: ListenStatusService }, { type: NextActionService }]; } });
 
+/**
+ * default image for purchase item is set on Publisher Account side.
+ * for purchase checkout items the image url is converted into base64 string.
+ * to determine default image fixed templates are used
+ */
+const defaultImagePatterns = [
+    /^data:image\/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAAAAADmVT4XAAACMUlEQVR4Ae3YgYqdMBSE4fP/,
+    /virtual_item_default_image/,
+];
+
+function extractMoneyCurrency(money, allowZero = true) {
+    return {
+        amount: money?.amount ?? (allowZero ? 0 : null),
+        currency: money?.currency ?? '',
+    };
+}
+function createPriceOrUndefined(amount, currency) {
+    return amount !== undefined && amount !== null
+        ? {
+            amount,
+            currency,
+        }
+        : undefined;
+}
+
+class FinanceDetails {
+    get shouldShowZeroIndirectTaxRate() {
+        return !!(this.finance?.vat?.visible || this.finance?.vat_user?.visible);
+    }
+    get isSalesTaxes() {
+        return !!(this.finance?.sales_tax?.amount || this.finance?.sales_tax_user?.amount);
+    }
+    constructor(parameters) {
+        this.purchase = parameters.purchase;
+        this.finance = parameters.finance;
+    }
+    getFormattedPurchaseForCart() {
+        const checkouts = this.purchase.checkout_items?.map((item) => {
+            return {
+                imgSrc: item.image_url,
+                hasDefaultImg: this.isDefaultImage(item.image_url),
+                title: item.name,
+                price: extractMoneyCurrency(item, false),
+                priceBeforeDiscount: createPriceOrUndefined(item.amount_before_discount, item.currency),
+                quantity: item.quantity,
+                description: item.description,
+                tax: this.getTaxForItem(item.indirect_tax_rate),
+                isBonus: item.is_bonus,
+            };
+        });
+        const virtualCurrencies = this.purchase.virtual_currency?.map((item) => {
+            return {
+                imgSrc: item.image_url,
+                hasDefaultImg: this.isDefaultImage(item.image_url),
+                title: `${item.quantity} ${item.name}`,
+                price: extractMoneyCurrency(item),
+                description: item.description,
+                isBonus: item.is_bonus,
+            };
+        });
+        const virtualItems = this.purchase.virtual_items?.map((item) => {
+            return {
+                imgSrc: item.image_url,
+                hasDefaultImg: this.isDefaultImage(item.image_url),
+                title: item.name,
+                price: extractMoneyCurrency(item),
+                description: item.description,
+                quantity: item.quantity,
+                isBonus: item.is_bonus,
+            };
+        });
+        let checkoutArray = undefined;
+        if (this.purchase.checkout) {
+            checkoutArray = [
+                {
+                    title: this.purchase.checkout.description
+                        ? this.purchase.checkout.description
+                        : 'In-game purchase',
+                    price: extractMoneyCurrency(this.purchase.checkout),
+                    isBonus: this.purchase.checkout.is_bonus ?? false,
+                },
+            ];
+        }
+        return [
+            ...(checkouts ?? []),
+            ...(virtualCurrencies ?? []),
+            ...(virtualItems ?? []),
+            ...(checkoutArray ?? []),
+        ];
+    }
+    getFormattedPricingForCart() {
+        // subtotal details fields
+        const subtotalDetailsSorting = [
+            {
+                key: 'discount',
+                title: 'Discount',
+            },
+            {
+                key: 'fee',
+                title: 'Payment system fee',
+            },
+            {
+                key: 'user_balance',
+                title: 'Balance',
+            },
+        ];
+        return {
+            subtotal: {
+                title: 'Subtotal',
+                money: createPriceOrUndefined(this.finance.sub_total.amount, this.finance.sub_total.currency),
+            },
+            subtotalPayment: {
+                title: '',
+                money: createPriceOrUndefined(this.finance.sub_total.payment_amount, this.finance.sub_total.payment_currency),
+            },
+            total: {
+                title: 'Total',
+                money: extractMoneyCurrency(this.finance.total),
+            },
+            totalDetails: this.getTaxesForTotalDetails(),
+            subtotalDetails: [
+                ...subtotalDetailsSorting.map((sorting) => {
+                    const field = this.finance[sorting.key];
+                    if (field) {
+                        return {
+                            ...sorting,
+                            money: {
+                                amount: sorting.key === 'discount' && field.amount
+                                    ? -field.amount
+                                    : field.amount,
+                                currency: field.currency,
+                            },
+                        };
+                    }
+                    return sorting;
+                }),
+                ...this.getTaxesForSubtotalDetails(),
+            ],
+        };
+    }
+    getPaymentCountry() {
+        return this.finance?.payment_country.iso;
+    }
+    getTaxForItem(indirectTaxRate) {
+        if (indirectTaxRate ||
+            (this.shouldShowZeroIndirectTaxRate && indirectTaxRate === 0)) {
+            if (this.isSalesTaxes) {
+                return {
+                    content: `Sales tax ${indirectTaxRate}%`,
+                };
+            }
+            if (this.isIndia()) {
+                return {
+                    content: `GST ${indirectTaxRate}%`,
+                };
+            }
+            if (this.isGhana()) {
+                return {
+                    content: 'VAT, NHIL, GETFund Levy, and Covid-19 Levy',
+                };
+            }
+            return {
+                content: `VAT ${indirectTaxRate}%`,
+            };
+        }
+        return null;
+    }
+    getTaxesForSubtotalDetails() {
+        const ret = [];
+        // subtotal. VAT %p
+        if (this.finance.vat_user &&
+            (this.finance?.vat_user?.amount ?? this.finance?.vat_user?.visible)) {
+            ret.push({
+                key: 'vat_user',
+                title: this.getVatLabelForSubtotalDetails(),
+                money: extractMoneyCurrency(this.finance.vat_user),
+            });
+        }
+        if (this.finance.sales_tax_user?.amount) {
+            ret.push({
+                key: 'sales_tax_user',
+                title: 'Sales tax',
+                money: extractMoneyCurrency(this.finance.sales_tax_user),
+            });
+        }
+        return ret;
+    }
+    getVatLabelForSubtotalDetails() {
+        if (this.isIndia()) {
+            return `GST ${this.finance.vat_user?.percent ?? ''}%`;
+        }
+        if (this.isGhana()) {
+            return `VAT, NHIL, GETFund Levy, and Covid-19 Levy`;
+        }
+        return `VAT ${this.finance.vat_user?.percent ?? ''}%`;
+    }
+    getTaxesForTotalDetails() {
+        const ret = [];
+        // for totalDetails. VAT
+        if ((this.finance?.vat?.amount || this.finance?.vat?.visible) &&
+            !this.finance?.vat_user?.amount) {
+            ret.push({
+                key: 'vat',
+                title: this.getVatLabelForTotalDetails(),
+                money: extractMoneyCurrency(this.finance.vat),
+            });
+        }
+        if (this.finance?.sales_tax?.amount &&
+            !this.finance?.sales_tax_user?.amount) {
+            ret.push({
+                key: 'sales_tax',
+                title: 'Sales tax included',
+                money: extractMoneyCurrency(this.finance.sales_tax),
+            });
+        }
+        return ret;
+    }
+    getVatLabelForTotalDetails() {
+        if (this.isIndia()) {
+            return `Including ${this.finance.vat.percent}% GST`;
+        }
+        if (this.isGhana()) {
+            return 'Including VAT, NHIL, GETFund Levy, and Covid-19 Levy';
+        }
+        return `Including ${this.finance.vat.percent}% VAT`;
+    }
+    isIndia() {
+        return this.finance?.payment_country.iso === 'IN';
+    }
+    isGhana() {
+        return this.finance?.payment_country.iso === 'GH';
+    }
+    isDefaultImage(url) {
+        return defaultImagePatterns.some((regex) => regex.test(url));
+    }
+}
+
+const financeDetailsResponseFactoryToken = new InjectionToken('FinanceDetails');
+const financeDetailsResponseFactoryProvider = {
+    provide: financeDetailsResponseFactoryToken,
+    useValue: (...args) => new FinanceDetails(...args),
+};
+
+class FinanceDetailsService extends EmitDataService {
+    constructor(responseFactory) {
+        super();
+        this.responseFactory = responseFactory;
+    }
+    emit(summary) {
+        if (summary) {
+            super.emit(this.responseFactory(summary));
+        }
+    }
+}
+FinanceDetailsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FinanceDetailsService, deps: [{ token: financeDetailsResponseFactoryToken }], target: i0.ɵɵFactoryTarget.Injectable });
+FinanceDetailsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FinanceDetailsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FinanceDetailsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [financeDetailsResponseFactoryToken]
+                }] }]; } });
+
 class PaymentService {
-    constructor(initializeService, submitService, syncService, formService, statusService, nextActionService, controlConfigService) {
+    constructor(initializeService, submitService, syncService, formService, statusService, financeDetailsService, nextActionService, controlConfigService) {
         this.initializeService = initializeService;
         this.submitService = submitService;
         this.syncService = syncService;
         this.formService = formService;
         this.statusService = statusService;
+        this.financeDetailsService = financeDetailsService;
         this.nextActionService = nextActionService;
         this.controlConfigService = controlConfigService;
         this.form = null;
         this.data = null;
+        this.financeDetails = null;
         this.fields = [];
+        this.destroy$ = new Subject();
     }
     async initialize(config) {
+        this.destroy$ = new Subject();
+        this.listenFinanceDetails();
         this.config = config;
         this.data = await this.initializeService.request(config);
         this.fields = this.getFields();
         this.form = this.formService.createForm(this.fields);
-        this.syncService.setup(this.form, this.fields);
+        this.emitFinanceDetails(this.data.paymentForm?.summary);
+        this.setupSyncService(this.form, this.fields);
         return this.fields;
     }
     async submit() {
@@ -2427,19 +2717,24 @@ class PaymentService {
             throw new Error('form is empty!');
         }
         const submitResponse = await this.submitService.request(this.fields, this.form);
+        this.emitFinanceDetails(submitResponse.summary);
         return this.nextActionService.getNextAction(submitResponse);
     }
     getFields() {
         return this.data?.paymentForm?.fields ?? [];
     }
     async validate(field) {
+        const syncErrors = this.syncService.getSyncValidationErrors(field);
+        if (syncErrors) {
+            return Promise.resolve(syncErrors);
+        }
         return this.syncService.validate(field);
     }
     runThreeDs() {
         throw new Error('Method not implemented.');
     }
     getFinanceDetails() {
-        throw new Error('Method not implemented.');
+        return this.financeDetails;
     }
     async getStatus(params) {
         return this.statusService.getStatus({
@@ -2454,15 +2749,36 @@ class PaymentService {
         const formControl = this.form?.get(name);
         formControl?.setValue(value);
     }
+    destroy() {
+        this.data = null;
+        this.financeDetails = null;
+        this.form = null;
+        this.fields = [];
+        this.destroy$.next();
+    }
+    emitFinanceDetails(summary) {
+        this.financeDetailsService.emit(summary);
+    }
+    setupSyncService(form, fields) {
+        this.syncService.setup(form, fields);
+        this.syncService.data$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((response) => this.emitFinanceDetails(response.summary));
+    }
+    listenFinanceDetails() {
+        this.financeDetailsService.data$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((financeDetails) => (this.financeDetails = financeDetails));
+    }
 }
-PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, deps: [{ token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: NextActionService }, { token: ControlConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, deps: [{ token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: FinanceDetailsService }, { token: NextActionService }, { token: ControlConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
 PaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: NextActionService }, { type: ControlConfigService }]; } });
+        }], ctorParameters: function () { return [{ type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: FinanceDetailsService }, { type: NextActionService }, { type: ControlConfigService }]; } });
 
 class RefundPolicyService {
     constructor(settingsService) {
@@ -2567,7 +2883,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         }], ctorParameters: function () { return [{ type: SettingsService }, { type: RefundPolicyService }, { type: SecureConnectionService }, { type: DisclaimerService }]; } });
 
 class CoreLibraryService {
-    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentService, deviceFingerPrintService, legalService, nextActionService) {
+    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentService, deviceFingerPrintService, financeDetailsService, legalService, nextActionService) {
         this.settingsService = settingsService;
         this.countryService = countryService;
         this.paymentMethodsService = paymentMethodsService;
@@ -2575,6 +2891,7 @@ class CoreLibraryService {
         this.userBalanceService = userBalanceService;
         this.paymentService = paymentService;
         this.deviceFingerPrintService = deviceFingerPrintService;
+        this.financeDetailsService = financeDetailsService;
         this.legalService = legalService;
         this.nextActionService = nextActionService;
         this.paymentMethods = {
@@ -2601,6 +2918,7 @@ class CoreLibraryService {
             runThreeDs: () => this.paymentService.runThreeDs(),
             getStatus: async (params) => this.paymentService.getStatus(params),
             flowUpdates$: this.nextActionService.flowUpdates$,
+            financeDetailsUpdates$: this.financeDetailsService.data$,
             form: {
                 getControlConfig: (field) => this.paymentService.getFieldConfig(field),
                 changeFieldValue: (name, value) => this.paymentService.changeFieldValue(name, value),
@@ -2611,14 +2929,14 @@ class CoreLibraryService {
         return this.legalService.getLegalComponentConfig();
     }
 }
-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: PaymentService }, { token: DeviceFingerPrintService }, { token: LegalService }, { token: NextActionService }], 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: PaymentService }, { token: DeviceFingerPrintService }, { token: FinanceDetailsService }, { token: LegalService }, { token: NextActionService }], 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: PaymentService }, { type: DeviceFingerPrintService }, { type: LegalService }, { type: NextActionService }]; } });
+        }], ctorParameters: function () { return [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: PaymentService }, { type: DeviceFingerPrintService }, { type: FinanceDetailsService }, { type: LegalService }, { type: NextActionService }]; } });
 
 class HttpError extends AppError {
     constructor(error, req) {
@@ -2723,6 +3041,7 @@ CoreLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", versi
         statusResponseFactoryProvider,
         checkStatusRequestFactoryProvider,
         checkStatusResponseFactoryProvider,
+        financeDetailsResponseFactoryProvider,
         {
             provide: nextActionsToken,
             useValue: nextActions,
@@ -2752,6 +3071,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                         statusResponseFactoryProvider,
                         checkStatusRequestFactoryProvider,
                         checkStatusResponseFactoryProvider,
+                        financeDetailsResponseFactoryProvider,
                         {
                             provide: nextActionsToken,
                             useValue: nextActions,