@xsolla/payment-client-core 0.2.7 → 0.2.8

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

@@ -564,6 +564,7 @@ var FieldNames;
     FieldNames["sum"] = "sum";
     FieldNames["out"] = "out";
     FieldNames["tinkoffDisclaimer"] = "ps.tinkoff.disclaimer";
+    FieldNames["omnibusDirective"] = "omnibus_directive";
 })(FieldNames || (FieldNames = {}));
 
 class SubmitResponse {
@@ -741,14 +742,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
 
 const vkPay = 3496;
 const googlePay = 3431;
-const applePay = 3175;
+const applePayId = 3175;
 const barzahlenPay = 1679;
 const naverPay = 3563;
 const venmoPay = 3636;
 
 const pagesRoutes = new Map([
     [vkPay, '/payment/external-pages/vk-pay'],
-    [applePay, '/payment/external-pages/apple-pay'],
+    [applePayId, '/payment/external-pages/apple-pay'],
     [barzahlenPay, '/payment/external-pages/barzahlen-pay'],
     [naverPay, '/payment/external-pages/naver-pay'],
     [venmoPay, '/payment/external-pages/venmo-pay'],
@@ -5373,6 +5374,15 @@ class PaymentService {
     get formFieldsStatus$() {
         return this.formFieldsStatusSubject.asObservable().pipe(filter$1(Boolean));
     }
+    get paymentForm$() {
+        return this._paymentForm$.asObservable();
+    }
+    get formResponse$() {
+        return this._formResponse$.asObservable();
+    }
+    get formResponseValue() {
+        return this._formResponse$.getValue();
+    }
     constructor(initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, controlConfigService, threeDsService, formMessagesService, settingsService, countryService) {
         this.initializeService = initializeService;
         this.submitService = submitService;
@@ -5394,7 +5404,9 @@ class PaymentService {
         this.fields = [];
         this.destroy$ = new Subject();
         this.formDestroy$ = new Subject();
+        this._paymentForm$ = new BehaviorSubject(null);
         this.formFieldsStatusSubject = new BehaviorSubject(null);
+        this._formResponse$ = new BehaviorSubject(null);
         this.isSavingMethodMode = false;
     }
     async initialize(config) {
@@ -5403,6 +5415,7 @@ class PaymentService {
         this.listenFinanceDetails();
         this.config = config;
         this.data = await this.initializeService.request(config);
+        this.emitFormResponse(this.data);
         this.fields = this.getFields();
         this.form = this.formService.createForm(this.fields);
         this.updatePidConfig();
@@ -5425,6 +5438,7 @@ class PaymentService {
         this.isSavingMethodMode = this.fields.some(({ name, value }) => name === 'savePsAccountOnly' && value === "1" /* XpsBoolean.true */);
         const submitResponse = await this.submitService.request(this.fields, this.form);
         this.data = submitResponse;
+        this.emitFormResponse(this.data);
         if (!this.isSavingMethodMode) {
             this.emitFinanceDetails(submitResponse.summary);
         }
@@ -5529,6 +5543,30 @@ class PaymentService {
         }
         this.emitFormFieldsStatus(this.form);
     }
+    addExtraField(name, value) {
+        const isHaveField = this.fields.find((field) => {
+            return field.name === name;
+        });
+        if (isHaveField) {
+            this.fields = this.fields.map((field) => {
+                if (field.name === name) {
+                    field.value = value;
+                }
+                return field;
+            });
+            return;
+        }
+        const field = {
+            name: name,
+            value: value,
+            title: '',
+            type: 'text',
+            example: '',
+            isMandatory: "1" /* XpsBoolean.true */,
+            isVisible: "0" /* XpsBoolean.false */,
+        };
+        this.fields.push(field);
+    }
     destroy() {
         this.data = null;
         this.financeDetails = null;
@@ -5568,6 +5606,7 @@ class PaymentService {
             .subscribe((response) => {
             this.emitFinanceDetails(response.summary);
             this.emitFormMessages(response.messages);
+            this.emitFormResponse(response);
         });
         this.syncService.fieldAsyncValidation$
             .pipe(takeUntil(this.destroy$))
@@ -5586,7 +5625,10 @@ class PaymentService {
     listenFormStatusChanges(form) {
         form.statusChanges
             .pipe(takeUntil(this.formDestroy$))
-            .subscribe(() => this.emitFormFieldsStatus(form));
+            .subscribe((status) => {
+            this.emitFormFieldsStatus(form);
+            this._paymentForm$.next(status);
+        });
     }
     /*
      * in case the form pid changes despite the one passed during initialization
@@ -5597,6 +5639,19 @@ class PaymentService {
             this.config.paymentMethodId = currentPid;
         }
     }
+    emitFormResponse(data) {
+        let type;
+        if (data instanceof InitializeResponse) {
+            type = 'initialize';
+        }
+        else if (data instanceof SubmitResponse) {
+            type = 'submit';
+        }
+        else {
+            type = 'sync';
+        }
+        this._formResponse$.next({ type, data, token: this.settingsService.token });
+    }
 }
 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: CreditCardStateService }, { token: NextActionService }, { token: ControlConfigService }, { token: ThreeDsService }, { token: FormMessagesService }, { token: SettingsService }, { token: CountryService }], target: i0.ɵɵFactoryTarget.Injectable });
 PaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, providedIn: 'root' });
@@ -6071,6 +6126,7 @@ class CoreLibraryService {
                 formMessages$: this.formMessagesService.data$,
                 getFormStatus: () => this.paymentService.form?.status,
             },
+            addExtraField: (name, value) => this.paymentService.addExtraField(name, value),
         };
     }
     getCreditCardService() {
@@ -6099,6 +6155,15 @@ class CoreLibraryService {
     getUserBalanceValue() {
         return this.userBalanceService.getUserBalanceValue();
     }
+    get paymentForm$() {
+        return this.paymentService.paymentForm$;
+    }
+    get formResponse$() {
+        return this.paymentService.formResponse$;
+    }
+    get formResponseValue() {
+        return this.paymentService.formResponseValue;
+    }
 }
 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: PaymentConfigService }, { token: PaymentService }, { token: DeviceFingerPrintService }, { token: FinanceDetailsService }, { token: LegalService }, { token: StatusService }, { token: NextActionService }, { token: CreditCardService }, { token: CreditCardStateService }, { token: FormMessagesService }, { token: EditSavedMethodsService }, { token: GooglePayService }, { token: PaymentSystemProcessingService }], target: i0.ɵɵFactoryTarget.Injectable });
 CoreLibraryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, providedIn: 'root' });
@@ -6330,6 +6395,779 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                 }]
         }] });
 
+const applePayVersion = 3;
+
+const agreementsGroup = [
+    FieldNames.termsAndConditions,
+    FieldNames.termsAndConditionsHtcEula,
+    FieldNames.termsAndConditionsAtariTc,
+    FieldNames.termsAndConditionsAtariPp,
+    FieldNames.termsAndConditionsRolandEula,
+    FieldNames.termsAndConditionsRobloxEula,
+    FieldNames.termsAndConditionsOnzenga,
+    FieldNames.take2Taxes,
+    FieldNames.rockstarTaxes,
+    FieldNames.omnibusDirective,
+];
+
+var ApplePayErrors;
+(function (ApplePayErrors) {
+    ApplePayErrors["paymentError"] = "paymentError";
+    ApplePayErrors["deviceIsNotCapableError"] = "deviceIsNotCapableError";
+})(ApplePayErrors || (ApplePayErrors = {}));
+
+const unknownValue = 'unknown';
+const browsers = [
+    {
+        sentName: 'Mozilla Firefox',
+        shortName: 'Firefox',
+        regexpBrowserNameWithVersion: '(Firefox)\\/(.+)',
+    },
+    {
+        sentName: 'Samsung Internet',
+        shortName: 'SamsungBrowser',
+        regexpBrowserNameWithVersion: '(SamsungBrowser)\\/(.+)\\s',
+    },
+    {
+        sentName: 'Opera',
+        shortName: 'Opera',
+        regexpBrowserNameWithVersion: '(Opera)\\/(.+)',
+    },
+    {
+        sentName: 'Opera',
+        shortName: 'Opera',
+        regexpBrowserNameWithVersion: '(OPR)\\/(.+)',
+    },
+    {
+        sentName: 'Microsoft Edge (Legacy)',
+        shortName: 'MSEdge-legacy',
+        regexpBrowserNameWithVersion: '(Edge)\\/(.+)',
+    },
+    {
+        sentName: 'Microsoft Edge (Chromium)',
+        shortName: 'MSEdge',
+        regexpBrowserNameWithVersion: '(Edg)\\/(.+)',
+    },
+    {
+        sentName: 'Google Chrome or Chromium',
+        shortName: 'Chrome',
+        regexpBrowserNameWithVersion: '(Chrome)\\/(.+)\\s',
+    },
+    {
+        sentName: 'Apple Safari',
+        shortName: 'Safari',
+        regexpBrowserNameWithVersion: '(Safari)\\/(.+)',
+    },
+];
+
+var Device;
+(function (Device) {
+    Device["mobile"] = "mobile";
+    Device["desktop"] = "desktop";
+})(Device || (Device = {}));
+
+const osList = [
+    {
+        name: 'Windows XP',
+        regExp: 'Windows XP',
+    },
+    {
+        name: 'Windows XP',
+        regExp: 'Windows NT 5.1|Windows NT5.1',
+    },
+    {
+        name: 'Windows Vista',
+        regExp: 'Windows NT 6.0',
+    },
+    {
+        name: 'Windows 7',
+        regExp: 'Windows NT 6.1',
+    },
+    {
+        name: 'Windows 8',
+        regExp: 'Windows NT 6.2',
+    },
+    {
+        name: 'Windows 8.1',
+        regExp: 'Windows NT 6.3',
+    },
+    {
+        name: 'Windows 10',
+        regExp: 'Windows NT 10.0',
+    },
+    {
+        name: 'Windows CE',
+        regExp: 'Windows CE',
+    },
+    {
+        name: 'iPhone',
+        regExp: 'iphone',
+    },
+    {
+        name: 'iPod',
+        regExp: 'ipod',
+    },
+    {
+        name: 'iPad',
+        regExp: 'ipad',
+    },
+    {
+        name: 'Android',
+        regExp: 'Android ([0-9]{1,2}.[0-9]{1,2}.?[0-9]{0,3})',
+    },
+    {
+        name: 'Android',
+        regExp: 'Android',
+    },
+    {
+        name: 'Android',
+        regExp: 'android',
+    },
+    {
+        name: 'BlackBerry',
+        regExp: 'blackberry',
+    },
+    {
+        name: 'Mobile',
+        regExp: 'webos',
+    },
+    {
+        name: 'Nintendo WiiU',
+        regExp: 'Nintendo WiiU',
+    },
+    {
+        name: 'Xbox One S',
+        regExp: 'XBOX_ONE_ED',
+    },
+    {
+        name: 'Xbox One',
+        regExp: 'Xbox; Xbox One',
+    },
+    {
+        name: 'PlayStation',
+        regExp: 'PlayStation',
+    },
+    {
+        name: 'Windows',
+        regExp: '(win)([0-9]{1,2}\\.[0-9x]{1,2})',
+    },
+    {
+        name: 'Windows',
+        regExp: '(windows)([0-9x]{2})',
+    },
+    {
+        name: 'Windows',
+        regExp: '(windows)([0-9]{1,2}\\.[0-9]{1,2})',
+    },
+    {
+        name: 'Windows',
+        regExp: 'win32',
+    },
+    {
+        name: 'Java',
+        regExp: '(java)([0-9]{1,2}\\.[0-9]{1,2}\\.[0-9]{1,2})',
+    },
+    {
+        name: 'Solaris',
+        regExp: '(Solaris)([0-9]{1,2}\\.[0-9x]{1,2}){0,1}',
+    },
+    {
+        name: 'Unix',
+        regExp: 'unix',
+    },
+    {
+        name: 'Mac OS X',
+        regExp: 'Mac OS X',
+    },
+    {
+        name: 'Mac OS',
+        regExp: '(mac|Macintosh)',
+    },
+    {
+        name: 'SunOS',
+        regExp: '(sunos)([0-9]{1,2}\\.[0-9]{1,2}){0,1}',
+    },
+    {
+        name: 'BeOS',
+        regExp: '(beos)([0-9]{1,2}\\.[0-9]{1,2}){0,1}',
+    },
+    {
+        name: 'RISC OS',
+        regExp: '(risc os)([0-9]{1,2}\\.[0-9]{1,2})',
+    },
+    {
+        name: 'FreeBSD',
+        regExp: 'freebsd',
+    },
+    {
+        name: 'OpenBSD',
+        regExp: 'openbsd',
+    },
+    {
+        name: 'NetBSD',
+        regExp: 'netbsd',
+    },
+    {
+        name: 'IRIX',
+        regExp: 'irix',
+    },
+    {
+        name: 'Plan9',
+        regExp: 'plan9',
+    },
+    {
+        name: 'OSF',
+        regExp: 'osf',
+    },
+    {
+        name: 'AIX',
+        regExp: 'aix',
+    },
+    {
+        name: 'GNU Hurd',
+        regExp: 'GNU Hurd',
+    },
+    {
+        name: 'Linux - Fedora',
+        regExp: '(fedora)',
+    },
+    {
+        name: 'Linux - Kubuntu',
+        regExp: '(kubuntu)',
+    },
+    {
+        name: 'Linux - Ubuntu',
+        regExp: '(ubuntu)',
+    },
+    {
+        name: 'Linux - Debian',
+        regExp: '(debian)',
+    },
+    {
+        name: 'Linux - CentOS',
+        regExp: '(CentOS)',
+    },
+    {
+        name: 'Linux - Mandriva',
+        regExp: '(Mandriva).([0-9]{1,3}(\\.[0-9]{1,3})?(\\.[0-9]{1,3})?)',
+    },
+    {
+        name: 'Linux - SUSE',
+        regExp: '(SUSE).([0-9]{1,3}(\\.[0-9]{1,3})?(\\.[0-9]{1,3})?)',
+    },
+    {
+        name: 'Linux - Slackware (Dropline GNOME)',
+        regExp: '(Dropline)',
+    },
+    {
+        name: 'Linux - ASPLinux',
+        regExp: '(ASPLinux)',
+    },
+    {
+        name: 'Linux - Red Hat',
+        regExp: '(Red Hat)',
+    },
+    {
+        name: 'Linux',
+        regExp: '(linux)',
+    },
+    {
+        name: 'AmigaOS',
+        regExp: '(amigaos)([0-9]{1,2}\\.[0-9]{1,2})',
+    },
+    {
+        name: 'AmigaOS',
+        regExp: 'amiga-aweb',
+    },
+    {
+        name: 'Amiga',
+        regExp: 'amiga',
+    },
+    {
+        name: 'PalmOS',
+        regExp: 'AvantGo',
+    },
+    {
+        name: 'WebTV',
+        regExp: '(webtv)/([0-9]{1,2}\\.[0-9]{1,2})',
+    },
+    {
+        name: 'Dreamcast OS',
+        regExp: 'Dreamcast',
+    },
+    {
+        name: 'Windows',
+        regExp: 'wget',
+    },
+    {
+        name: 'Unknown',
+        regExp: 'Java',
+    },
+    {
+        name: 'Windows',
+        regExp: '(msie)([0-9]{1,2}.[0-9]{1,2})',
+    },
+    {
+        name: 'Unix',
+        regExp: 'libwww-perl',
+    },
+    {
+        name: 'Windows CE',
+        regExp: 'UP.Browser',
+    },
+    {
+        name: 'Windows',
+        regExp: 'NetAnts',
+    },
+];
+
+class UserAgentService {
+    constructor(window) {
+        this.window = window;
+        this._browserName = null;
+        this._browserVersion = null;
+        this._browserApp = null;
+        this._platform = null;
+        this._os = null;
+        this.getUserPlatform();
+        this.getBrowserInformation();
+        this.getOsInformation();
+    }
+    get browserVersion() {
+        return this._browserVersion;
+    }
+    get browserApp() {
+        return this._browserApp;
+    }
+    get platform() {
+        if (this._platform === unknownValue) {
+            return this.osType;
+        }
+        return this._platform;
+    }
+    get userAgent() {
+        return this.window.navigator.userAgent;
+    }
+    get browserDescription() {
+        if (this.browserName === unknownValue || this.browserName === null) {
+            return this.userAgent;
+        }
+        return this.browserName;
+    }
+    get isSafari() {
+        return this._browserName === 'Apple Safari';
+    }
+    get iOsVersion() {
+        if (this.osType !== 'ios') {
+            return null;
+        }
+        const version = /OS (\d+)_(\d+)_?(\d+)?/.exec(this.window.navigator.appVersion);
+        return version ? `${version[1]}.${version[2]}.${version[3] ?? 0}` : null;
+    }
+    get browserInfo() {
+        const browserInfo = {
+            name: this.browserDescription,
+            [this.browserApp?.toLowerCase() ?? unknownValue]: true,
+            version: this.browserVersion,
+            [this.browserEngine.toLowerCase()]: true,
+            ui_version: this.isMobileDevice ? Device.mobile : Device.desktop,
+            os: this.os,
+        };
+        if (this.isMobileDevice) {
+            browserInfo.mobile = true;
+        }
+        if (this.osType) {
+            // @ts-expect-error index is string
+            browserInfo[this.osType.toLowerCase()] = true;
+        }
+        if (this.window.navigator.platform?.includes('iPhone')) {
+            browserInfo.iphone = true;
+        }
+        if (this.window.navigator.platform?.includes('iPod')) {
+            browserInfo.ipod = true;
+        }
+        if (this.window.navigator.platform?.includes('iPad')) {
+            browserInfo.ipad = true;
+            browserInfo.tablet = true;
+        }
+        if (this.isAndroid) {
+            browserInfo.android = true;
+        }
+        return browserInfo;
+    }
+    get isMobileDevice() {
+        const deviceAgents = [
+            'Android',
+            'webOS',
+            'iPhone',
+            'iPad',
+            'iPod',
+            'BlackBerry',
+            'IEMobile',
+            'Opera Mini',
+            'Mobile',
+            'Tablet',
+            'Kindle',
+            'Playbook',
+            'Silk',
+            'Puffin',
+            'CriOS',
+        ];
+        return new RegExp(deviceAgents.join('|'), 'i').test(this.userAgent);
+    }
+    get isIosAndNotIpad() {
+        return ['iPhone', 'iPod'].includes(this.window.navigator.platform);
+    }
+    getUserPlatform() {
+        const experimentalPlatformApi = this.window.navigator?.userAgentData;
+        const platform = experimentalPlatformApi?.platform ??
+            this.window?.navigator?.platform ??
+            unknownValue;
+        this._platform = platform.toLowerCase();
+    }
+    getBrowserInformation() {
+        for (const browser of browsers) {
+            const browserRegExp = new RegExp(browser.regexpBrowserNameWithVersion);
+            const browserNameWithVersion = browserRegExp.exec(this.userAgent);
+            if (browserNameWithVersion !== null) {
+                this._browserName = browser.sentName;
+                this._browserApp = browser.shortName;
+                this._browserVersion = browserNameWithVersion[2];
+                break;
+            }
+            this._browserName = unknownValue;
+            this._browserApp = unknownValue;
+            this._browserVersion = unknownValue;
+        }
+    }
+    getOsInformation() {
+        for (const os of osList) {
+            const osRegExp = new RegExp(os.regExp);
+            const osName = osRegExp.exec(this.userAgent);
+            if (osName !== null) {
+                this._os = os.name;
+                break;
+            }
+            this._os = unknownValue;
+        }
+    }
+    get browserName() {
+        return this._browserName;
+    }
+    get isAndroid() {
+        return /Android\s+([\d.]+)/.test(this.userAgent);
+    }
+    get isXbox() {
+        return /xbox/i.test(this.userAgent);
+    }
+    get isLinux() {
+        return /linux/i.test(this.userAgent);
+    }
+    get isWindows() {
+        return /windows/i.test(this.userAgent);
+    }
+    get browserEngine() {
+        const engines = new Map([
+            ['Firefox', 'Gecko'],
+            ['Safari', 'Webkit'],
+            ['MSEdge-legacy', 'EdgeHTML'],
+            ['Chrome', 'Blink'],
+            ['Opera', 'Blink'],
+            ['MSEdge', 'Blink'],
+            ['SamsungBrowser', 'Blink'],
+        ]);
+        return engines.get(this.browserApp) ?? unknownValue;
+    }
+    get os() {
+        return this._os;
+    }
+    get osType() {
+        if (['iPhone', 'iPod', 'iPad'].includes(this.window.navigator.platform)) {
+            return 'ios';
+        }
+        if (this.window.navigator.platform?.includes('MacIntel')) {
+            return 'mac';
+        }
+        if (this.isXbox) {
+            return 'xbox';
+        }
+        if (this.isWindows) {
+            return 'windows';
+        }
+        if (this.isAndroid) {
+            return 'android';
+        }
+        if (this.isLinux) {
+            return 'linux';
+        }
+        return null;
+    }
+}
+UserAgentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserAgentService, deps: [{ token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+UserAgentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserAgentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserAgentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }]; } });
+
+class ApplePayService {
+    get paymentParameters() {
+        return this.applePayParams;
+    }
+    get payment$() {
+        return this.payment.asObservable();
+    }
+    get error$() {
+        return this.error.asObservable();
+    }
+    get integrationType$() {
+        return this.integrationType.asObservable();
+    }
+    constructor(window, userAgentService, summaryFinanceDetailsAdapterService) {
+        this.window = window;
+        this.userAgentService = userAgentService;
+        this.summaryFinanceDetailsAdapterService = summaryFinanceDetailsAdapterService;
+        this.agreementFieldsNames = agreementsGroup;
+        this.payment = new Subject();
+        this.error = new Subject();
+        this.integrationType = new Subject();
+        this.paymentClient = null;
+        this.applePayParams = null;
+        this.order = null;
+        this.api = this.loadBraintree();
+    }
+    setApplePayParams(data) {
+        const formFields = data?.paymentForm?.fields;
+        const summary = data?.paymentForm?.summary;
+        if (!formFields || !summary) {
+            return;
+        }
+        const fields = formFields.reduce((acc, field) => {
+            if (this.agreementFieldsNames.includes(field.name) &&
+                field.isVisible === '1') {
+                acc[field.name] = field.title;
+            }
+            else {
+                acc[field.name] = field.value;
+            }
+            return acc;
+        }, {});
+        const agreements = this.agreementFieldsNames
+            .map((fieldName) => fields[fieldName])
+            .filter(Boolean);
+        this.applePayParams = {
+            tokenKey: this.getAppleToken(formFields),
+            totalLabel: fields['label_applePay'] ?? '',
+            totalAmount: this.getTotalAmount(summary),
+            currencyCode: this.getTotalCurrency(summary),
+            countryCode: fields['countryCode'] ?? '',
+            merchantCapabilities: this.getJsonValueFromField(fields, 'merchantCapabilities'),
+            supportedNetworks: this.getJsonValueFromField(fields, 'supportedNetworks'),
+            agreements: agreements,
+        };
+    }
+    async initLibrary(tokenKey) {
+        try {
+            const api = await this.api;
+            const clientInstance = await api.client.create({
+                authorization: tokenKey,
+            });
+            this.paymentClient = await api.applePay.create({
+                client: clientInstance,
+            });
+        }
+        catch (error) {
+            console.error('apple pay: initialize failed', error);
+        }
+        this.emitIntegrationType();
+        if (!this.paymentClient ||
+            (!this.isDeviceCapable() && !this.userAgentService.isSafari)) {
+            this.emitError(ApplePayErrors.deviceIsNotCapableError);
+        }
+    }
+    redirectToPaymentPage(parameters, token) {
+        const route = pagesRoutes.get(applePayId);
+        if (!route) {
+            return;
+        }
+        const query = new URLSearchParams({
+            ...parameters,
+            merchantCapabilities: JSON.stringify(parameters.merchantCapabilities),
+            supportedNetworks: JSON.stringify(parameters.supportedNetworks),
+            token,
+            agreements: JSON.stringify(parameters.agreements),
+        });
+        if (this.order) {
+            query.append('order', this.order);
+        }
+        const url = `${route}?${query.toString()}`;
+        return url;
+    }
+    setOrder(data) {
+        const summary = data?.paymentForm?.summary;
+        if (!summary) {
+            return;
+        }
+        const financeDetails = this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);
+        if (financeDetails?.purchase && financeDetails?.finance) {
+            const cartItems = financeDetails.cartItems;
+            this.order = cartItems?.reduce((curr, item) => {
+                if (curr) {
+                    return curr + `; ${item.title}`;
+                }
+                return curr + item.title;
+            }, '');
+        }
+    }
+    proceedCheckout(parameters) {
+        if (!parameters) {
+            return;
+        }
+        if (!this.paymentClient || !this.isDeviceCapable()) {
+            console.warn('apple pay: device is not capable', this.paymentClient);
+            this.emitError(ApplePayErrors.deviceIsNotCapableError);
+            return;
+        }
+        try {
+            const paymentRequest = this.paymentClient.createPaymentRequest({
+                total: {
+                    label: parameters.totalLabel,
+                    amount: parameters.totalAmount,
+                },
+                currencyCode: parameters.currencyCode,
+                countryCode: parameters.countryCode,
+                merchantCapabilities: parameters.merchantCapabilities,
+                supportedNetworks: parameters.supportedNetworks,
+            });
+            const session = new this.window.ApplePaySession(applePayVersion, paymentRequest);
+            session.onvalidatemerchant = (event) => {
+                console.info('apple pay: merchant validation', event);
+                this.paymentClient
+                    ?.performValidation({
+                    validationURL: event.validationURL,
+                    displayName: parameters?.totalLabel,
+                })
+                    .then((merchantSession) => {
+                    session.completeMerchantValidation(merchantSession);
+                })
+                    .catch((error) => {
+                    console.error('apple pay: merchant validation error', error);
+                    session.abort();
+                });
+            };
+            session.onpaymentauthorized = (event) => {
+                console.info('apple pay: payment authorization', event);
+                this.paymentClient
+                    ?.tokenize({
+                    token: event.payment.token,
+                })
+                    .then((authorizationResponse) => {
+                    this.payment.next(authorizationResponse?.nonce ?? '');
+                    session.completePayment(this.window.ApplePaySession.STATUS_SUCCESS);
+                })
+                    .catch((error) => {
+                    console.error('apple pay: payment authorization error', error);
+                    session.completePayment(this.window.ApplePaySession.STATUS_FAILURE);
+                });
+            };
+            session.oncancel = (event) => {
+                this.emitError(ApplePayErrors.paymentError);
+                console.error('apple pay: user cancel payment', event);
+            };
+            session.begin();
+        }
+        catch (error) {
+            console.error('apple pay: checkout error', error);
+            this.emitError(ApplePayErrors.paymentError);
+        }
+    }
+    isDeviceCapable() {
+        try {
+            return Boolean(this.window.ApplePaySession?.supportsVersion(applePayVersion) &&
+                this.window.ApplePaySession?.canMakePayments());
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    getTokenNonceFieldData(tokenNonce) {
+        const name = FieldNames.tokenApplePay;
+        const value = btoa(tokenNonce);
+        return { name, value };
+    }
+    updateApplePayParams(data) {
+        const summary = data?.summary;
+        if (!this.applePayParams || !summary) {
+            return;
+        }
+        this.applePayParams.totalAmount = this.getTotalAmount(summary);
+        this.applePayParams.currencyCode = this.getTotalCurrency(summary);
+    }
+    async loadBraintree() {
+        const api = await import('braintree-web');
+        return api;
+    }
+    getAppleToken(formFields) {
+        const appleTokenField = formFields.find((field) => {
+            return field.name === 'token_key';
+        });
+        if (!appleTokenField) {
+            return '';
+        }
+        return appleTokenField.value;
+    }
+    getTotalAmount(summary) {
+        const finance = summary?.finance;
+        const total = finance?.grand_total?.amount ?? finance?.total.amount;
+        return total?.toString() ?? '';
+    }
+    getTotalCurrency(summary) {
+        const finance = summary?.finance;
+        return finance?.grand_total?.currency ?? finance?.total?.currency ?? '';
+    }
+    getJsonValueFromField(fields, fieldName) {
+        const field = fields[fieldName];
+        try {
+            return field ? JSON.parse(field) : undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    emitError(error) {
+        this.error.next(error);
+    }
+    emitIntegrationType() {
+        let integrationType;
+        if (this.paymentClient && this.isDeviceCapable()) {
+            integrationType = 'sdk';
+        }
+        else if (this.userAgentService.isSafari) {
+            integrationType = 'redirect';
+        }
+        else {
+            integrationType = 'none';
+        }
+        this.integrationType.next(integrationType);
+    }
+}
+ApplePayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ApplePayService, deps: [{ token: windowToken }, { token: UserAgentService }, { token: SummaryFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApplePayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ApplePayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ApplePayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: UserAgentService }, { type: SummaryFinanceDetailsAdapterService }]; } });
+
 /*
  * Public API Surface of core-library
  */
@@ -6338,5 +7176,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CoreLibraryModule, CoreLibraryService };
+export { ApplePayService, CoreLibraryModule, CoreLibraryService };
 //# sourceMappingURL=xsolla-payment-client-core.mjs.map