@xsolla/payment-client-core 0.6.0 → 0.7.0

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

@@ -13,7 +13,7 @@ import { CommonModule } from '@angular/common';
 import { provideTranslateHttpLoader } from '@ngx-translate/http-loader';
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const PAYMENT_CLIENT_CORE_VERSION = '0.6.0';
+const PAYMENT_CLIENT_CORE_VERSION = '0.7.0';
 
 class TranslateHelper {
     static init(service) {
@@ -1605,6 +1605,7 @@ var UserBehaviourEventName;
     UserBehaviourEventName["googlePayHandleSuccessfulPayment"] = "google-pay-handle-successful-payment";
     // Instant flow
     UserBehaviourEventName["sysInstantFlowOpen"] = "sys-instant_flow-open";
+    UserBehaviourEventName["sysInstantFlowData"] = "sys-instant_flow-data";
 })(UserBehaviourEventName || (UserBehaviourEventName = {}));
 
 const userBehaviourEventTypes = {
@@ -7463,30 +7464,34 @@ class DfpCollectService {
         this.formName = 'formDFP';
     }
     collectDfpStatus(threeDsForm) {
-        if (threeDsForm.waitCallback) {
-            this.openIframeWithPostRequest(threeDsForm, false);
-        }
-        else {
-            this.openIframeWithPostRequest(threeDsForm, true);
-        }
-    }
-    /*
-     * This method create invisible iframe with required params and after that it submit form in iframe
-     * */
-    openIframeWithPostRequest(threeDsForm, isNeedNotifyAfterLoad) {
         this.window.document.getElementById(this.iframeName)?.remove();
         this.window.document.getElementById(this.formName)?.remove();
+        /*
+         * waitCallback only suppresses the onload notification — DFP completion arrives via a
+         * server-side callback instead.
+         */
+        const isNeedNotifyAfterLoad = !threeDsForm.waitCallback;
+        /*
+         * providerHostedDfp (e.g. GPayments) means the provider hosts the DFP page: load the URL
+         * directly as the iframe src. Every other provider — Credorax, Assist — needs the legacy
+         * EMV 3DS Method POST below, because that POST is what tells the ACS where to send its
+         * DFP notification.
+         */
+        if (threeDsForm.providerHostedDfp) {
+            this.createIframe(isNeedNotifyAfterLoad, threeDsForm.threeDSTrXid, threeDsForm.threeDSMethod);
+            return;
+        }
         this.createIframe(isNeedNotifyAfterLoad, threeDsForm.threeDSTrXid);
         this.postFormToIframe(threeDsForm.threeDSMethod, threeDsForm.threeDSMethodData);
     }
     /*
      * isNeedNotifyAfterLoad is need to send notification of dft to server
      * */
-    createIframe(isNeedNotifyAfterLoad, threeDsTrXid) {
+    createIframe(isNeedNotifyAfterLoad, threeDsTrXid, src = 'about:blank') {
         const attributes = {
             name: this.iframeName,
             id: this.iframeName,
-            src: 'about:blank',
+            src,
             style: 'display:none',
         };
         const iFrame = this.window.document.createElement('iframe');
@@ -7612,6 +7617,7 @@ class ThreeDs20Service {
         this.latestDfpParameters = null;
         this.notifyDfpTimerId = 'notify-dfp';
         this.notifyDfpTimeoutMs = 10000;
+        this.providerHostedDfpNotifyDfpTimeoutMs = 20000;
         this.statusThreeDsTimerId = 'status-three-ds';
         this.statusThreeDsTimeoutMs = 180000;
     }
@@ -7622,7 +7628,9 @@ class ThreeDs20Service {
         this.clearLatestDfpParameters();
         this.reinsuranceCheckService.addTimer({
             id: this.notifyDfpTimerId,
-            timeoutMs: this.notifyDfpTimeoutMs,
+            timeoutMs: threeDsForm.providerHostedDfp
+                ? this.providerHostedDfpNotifyDfpTimeoutMs
+                : this.notifyDfpTimeoutMs,
             callback: () => {
                 const threeDsTransactionId = this.latestDfpParameters?.threeDSTrXid ?? threeDsForm.threeDSTrXid;
                 this.notifyDfpStatusService.request(threeDsTransactionId, false);
@@ -10657,6 +10665,86 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: [windowToken]
                 }] }, { type: LoggerService }, { type: PaymentSystemProcessingService }, { type: GooglePayCheckoutPaymentService }, { type: GooglePayInstantPaymentService }, { type: i0.Injector }] });
 
+var InstantFlowCheckName;
+(function (InstantFlowCheckName) {
+    InstantFlowCheckName["toggle"] = "toggle";
+    InstantFlowCheckName["partnerDomain"] = "partner_domain";
+    InstantFlowCheckName["certificates"] = "certificates";
+    InstantFlowCheckName["backendInstantData"] = "backend_instant_data";
+})(InstantFlowCheckName || (InstantFlowCheckName = {}));
+
+var InstantFlowCheckState;
+(function (InstantFlowCheckState) {
+    InstantFlowCheckState["passed"] = "passed";
+    InstantFlowCheckState["skipped"] = "skipped";
+})(InstantFlowCheckState || (InstantFlowCheckState = {}));
+
+class InstantFlowChecksCollector {
+    constructor() {
+        this.checks = {};
+        this.hasFailedChecks = false;
+    }
+    add(name, error) {
+        this.checks[name] = error ?? InstantFlowCheckState.passed;
+        if (error) {
+            this.hasFailedChecks = true;
+        }
+    }
+    skip(name) {
+        this.checks[name] = InstantFlowCheckState.skipped;
+    }
+    isPassing() {
+        return !this.hasFailedChecks;
+    }
+    getResult() {
+        return {
+            allowed: !this.hasFailedChecks,
+            checks: { ...this.checks },
+        };
+    }
+}
+
+var GooglePayInstantFlowCheckErrors;
+(function (GooglePayInstantFlowCheckErrors) {
+    GooglePayInstantFlowCheckErrors["TOGGLE_TURNED_OFF"] = "TOGGLE_TURNED_OFF";
+    GooglePayInstantFlowCheckErrors["INSTANT_DATA_MISSING"] = "INSTANT_DATA_MISSING";
+})(GooglePayInstantFlowCheckErrors || (GooglePayInstantFlowCheckErrors = {}));
+
+class GooglePayInstantFlowCheckService {
+    constructor(settingsService, paymentService) {
+        this.settingsService = settingsService;
+        this.paymentService = paymentService;
+    }
+    getInstantFlowChecks() {
+        const collector = new InstantFlowChecksCollector();
+        collector.add(InstantFlowCheckName.toggle, this.checkIntegrationToggle());
+        collector.add(InstantFlowCheckName.backendInstantData, this.checkBackendInstantData());
+        return collector.getResult();
+    }
+    // an unset flag is not a refusal: it leaves the instant flow decision to the backend
+    checkIntegrationToggle() {
+        return this.settingsService.isGooglePayInstantFlowEnabled === false
+            ? GooglePayInstantFlowCheckErrors.TOGGLE_TURNED_OFF
+            : null;
+    }
+    checkBackendInstantData() {
+        const hasInstantData = this.paymentService
+            .getFields()
+            .some((field) => field.name === FieldNames.googlePayInitData);
+        return hasInstantData
+            ? null
+            : GooglePayInstantFlowCheckErrors.INSTANT_DATA_MISSING;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GooglePayInstantFlowCheckService, deps: [{ token: SettingsService }, { token: PaymentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GooglePayInstantFlowCheckService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GooglePayInstantFlowCheckService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: SettingsService }, { type: PaymentService }] });
+
 var ApplePayIntegrationType;
 (function (ApplePayIntegrationType) {
     ApplePayIntegrationType["redirect"] = "redirect";
@@ -11235,6 +11323,126 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: [windowToken]
                 }] }, { type: SummaryFinanceDetailsAdapterService }, { type: BraintreeHandler }, { type: CheckoutHandler }, { type: ApplePayParamsBuilderService }, { type: LoggerService }, { type: ApplePaySdkService }, { type: ApplePayExternalWindowCommunicationService }, { type: SettingsService }] });
 
+var InstantFlowCheckErrors;
+(function (InstantFlowCheckErrors) {
+    InstantFlowCheckErrors["TOGGLE_TURNED_OFF"] = "TOGGLE_TURNED_OFF";
+    InstantFlowCheckErrors["PARTNER_DOMAIN_MISSING"] = "PARTNER_DOMAIN_MISSING";
+    InstantFlowCheckErrors["PARTNER_DOMAIN_WRONG_FORMAT"] = "PARTNER_DOMAIN_WRONG_FORMAT";
+    InstantFlowCheckErrors["CERTIFICATES_MISSING"] = "CERTIFICATES_MISSING";
+    InstantFlowCheckErrors["CERTIFICATES_CHECK_FAILED"] = "CERTIFICATES_CHECK_FAILED";
+})(InstantFlowCheckErrors || (InstantFlowCheckErrors = {}));
+
+class ApplePayInstantFlowCheckService {
+    constructor(secureApiClient, settingsService, loggerService) {
+        this.secureApiClient = secureApiClient;
+        this.settingsService = settingsService;
+        this.loggerService = loggerService;
+        this.checkPromise = null;
+    }
+    async isInstantFlowAvailable() {
+        this.checkPromise ??= this.performInstantFlowChecks();
+        return this.checkPromise;
+    }
+    async performInstantFlowChecks() {
+        const partnerDomain = this.settingsService.topLevelDomain ?? '';
+        const collector = new InstantFlowChecksCollector();
+        collector.add(InstantFlowCheckName.toggle, this.checkIntegrationToggle());
+        collector.add(InstantFlowCheckName.partnerDomain, this.checkPartnerDomain(partnerDomain));
+        // will skip request, if check failed
+        if (collector.isPassing()) {
+            collector.add(InstantFlowCheckName.certificates, await this.checkAppleCertificates(partnerDomain));
+        }
+        else {
+            collector.skip(InstantFlowCheckName.certificates);
+        }
+        const result = collector.getResult();
+        if (!result.allowed) {
+            this.loggerService.info(new TaggedMessage('ApplePay - instant flow is unavailable', [MessageTags.HEADLESS_UI], { partnerDomain, checks: result.checks }));
+        }
+        return result;
+    }
+    checkIntegrationToggle() {
+        return this.settingsService.isApplePayInstantFlowEnabled
+            ? null
+            : InstantFlowCheckErrors.TOGGLE_TURNED_OFF;
+    }
+    checkPartnerDomain(partnerDomain) {
+        if (!partnerDomain) {
+            return InstantFlowCheckErrors.PARTNER_DOMAIN_MISSING;
+        }
+        if (partnerDomain.includes('://')) {
+            return InstantFlowCheckErrors.PARTNER_DOMAIN_WRONG_FORMAT;
+        }
+        return null;
+    }
+    async checkAppleCertificates(partnerDomain) {
+        const request = this.secureApiClient.post(`instant_pay_flow_checker/apple_pay?access_token=${this.settingsService.token}`, {
+            certificate_domain: partnerDomain,
+        }, {
+            headers: new HttpHeaders().set('Content-Type', 'application/json; charset=utf-8'),
+            responseType: 'json',
+        });
+        try {
+            const response = await lastValueFrom(request);
+            return response.isCertificatesExist
+                ? null
+                : InstantFlowCheckErrors.CERTIFICATES_MISSING;
+        }
+        catch (error) {
+            this.loggerService.info(new TaggedMessage('ApplePay - instant flow certificates check failed', [MessageTags.HEADLESS_UI], {
+                partnerDomain,
+                message: error instanceof Error ? error.message : error,
+            }));
+            return InstantFlowCheckErrors.CERTIFICATES_CHECK_FAILED;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ApplePayInstantFlowCheckService, deps: [{ token: SecureApiClient }, { token: SettingsService }, { token: LoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ApplePayInstantFlowCheckService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ApplePayInstantFlowCheckService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: SecureApiClient }, { type: SettingsService }, { type: LoggerService }] });
+
+const clientSideCheckNames = new Set([
+    InstantFlowCheckName.partnerDomain,
+]);
+class InstantFlowAnalyticsService {
+    constructor(userBehaviourAnalyticsService) {
+        this.userBehaviourAnalyticsService = userBehaviourAnalyticsService;
+    }
+    sendInstantFlowData(instanceId, trigger, result) {
+        this.userBehaviourAnalyticsService.send(UserBehaviourEventName.sysInstantFlowData, userBehaviourEventTypes.manual, {
+            value: result.allowed,
+            dimension1: trigger,
+            dimension2: this.isSupportedByClient(result.checks) ? '1' : '0',
+            extraValue: JSON.stringify(result.checks),
+            instanceId,
+        });
+    }
+    isSupportedByClient(checks) {
+        return Object.entries(checks).every(([name, state]) => !clientSideCheckNames.has(name) ||
+            state === InstantFlowCheckState.passed ||
+            state === InstantFlowCheckState.skipped);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InstantFlowAnalyticsService, deps: [{ token: UserBehaviourAnalyticsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InstantFlowAnalyticsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InstantFlowAnalyticsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: UserBehaviourAnalyticsService }] });
+
+var InstantFlowTrigger;
+(function (InstantFlowTrigger) {
+    InstantFlowTrigger["paymentForm"] = "0";
+    InstantFlowTrigger["topButton"] = "1";
+})(InstantFlowTrigger || (InstantFlowTrigger = {}));
+
 /*
  * Public API Surface of core-library
  */
@@ -11243,5 +11451,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ApplePayCartService, ApplePayService, CoreLibraryModule, CoreLibraryService, CreditCardTypes, ErrorTags, FieldNames, GooglePayService, LoggerService, MessageTags, PAYMENT_CLIENT_CORE_VERSION, PaymentSystemProcessingService, TaggedError, TaggedMessage, americanExpressMethodId, cardsWith3ds, creditCardPaymentMethodId, isCreditCardSettingsGuard, maestroPaymentMethodId, masterCardAndVisaPaymentMethodId, specialCards, userBehaviourEventTypes };
+export { ApplePayCartService, ApplePayInstantFlowCheckService, ApplePayService, CoreLibraryModule, CoreLibraryService, CreditCardTypes, ErrorTags, FieldNames, GooglePayInstantFlowCheckErrors, GooglePayInstantFlowCheckService, GooglePayService, InstantFlowAnalyticsService, InstantFlowCheckErrors, InstantFlowCheckName, InstantFlowCheckState, InstantFlowChecksCollector, InstantFlowTrigger, LoggerService, MessageTags, PAYMENT_CLIENT_CORE_VERSION, PaymentSystemProcessingService, TaggedError, TaggedMessage, americanExpressMethodId, applePayId, barzahlenPay, cardsWith3ds, creditCardPaymentMethodId, googlePay, isCreditCardSettingsGuard, maestroPaymentMethodId, masterCardAndVisaPaymentMethodId, naverPay, specialCards, userBehaviourEventTypes, venmoPay, vkPay };
 //# sourceMappingURL=xsolla-payment-client-core.mjs.map