@fat-zebra/sdk 1.0.6 → 1.2.1

package/dist/hpp/hpp.js

@@ -0,0 +1,186 @@
+import * as bridge from '../shared/bridge-client';
+import { LocalStorageAccessTokenKey } from '../shared/constants';
+import { emit, on } from '../shared/event-manager';
+import { PostMessageClient } from '../shared/post-message-client';
+import { BridgeEvent, PublicEvent, } from '../shared/types';
+import * as util from '../shared/util';
+const HPP_DEFAULT_OPTIONS = {
+    enableSca: false,
+    hideButton: false,
+    tokenizeOnly: false,
+};
+class Hpp {
+    constructor(config) {
+        this.paymentIntent = config.paymentIntent;
+        this.customer = config.customer;
+        this.username = config.username;
+        this.sca = config.sca;
+        this.test = config.test;
+        this.version = config.version || 2;
+        this.postMessageClient = new PostMessageClient({
+            channel: 'sca',
+            target: this.iframe
+        });
+    }
+    load(config) {
+        this.hppOptions = config.options;
+        this.headless = bridge.load(process.env.PAYNOW_BRIDGE_URL);
+        this.iframe = document.createElement('iframe');
+        document.getElementById(config.containerId).appendChild(this.iframe);
+        this.headless.onload = () => {
+            this.iframe.onload = () => {
+                this.setCrossFramesEventListeners();
+                this.setPublicEventListeners();
+            };
+        };
+        const payNowUrl = this.getPayNowUrl(config.options);
+        this.iframe.setAttribute("src", payNowUrl);
+    }
+    purchase() {
+        const message = {
+            channel: 'sca',
+            subject: BridgeEvent.TRIGGER_PAYNOW_BUTTON,
+            data: {}
+        };
+        this.iframe.contentWindow.postMessage(message, '*');
+    }
+    getPayNowUrl(options) {
+        const { payment } = this.paymentIntent;
+        const base = [
+            process.env.PAYNOW_BASE_URL,
+            'sdk',
+            this.version == 3 ? 'v3' : null,
+            this.username,
+            payment.reference,
+            payment.currency,
+            payment.amount,
+            this.paymentIntent.verification
+        ].filter(part => part).join('/');
+        let queryString;
+        if (options) {
+            const _options = Object.assign(Object.assign({}, HPP_DEFAULT_OPTIONS), options);
+            queryString = Object.keys(_options).map(key => util.toSnakeCase(key) + '=' + _options[key]).join('&');
+        }
+        let searchParams = new URLSearchParams(queryString);
+        if (payment.hide_card_holder) {
+            searchParams.append('hide_card_holder', 'true');
+        }
+        return queryString ? `${base}?${searchParams.toString()}` : `${base}`;
+    }
+    setCrossFramesEventListeners() {
+        const handlers = {};
+        handlers[BridgeEvent.TOKENIZE_CARD_RESPONSE] = (data) => {
+            var _a;
+            if (data.errors) {
+                emit(PublicEvent.TOKENIZATION_ERROR, {
+                    message: 'Card tokenization failed.',
+                    errors: data.errors,
+                    data: null,
+                });
+                return;
+            }
+            else {
+                emit(PublicEvent.TOKENIZATION_SUCCESS, {
+                    message: 'Card tokenization success.',
+                    data: {
+                        token: data.token
+                    }
+                });
+            }
+            // Required for payment later
+            this.cardToken = data.token;
+            // Halt entire HPP operation
+            if (this.hppOptions.tokenizeOnly)
+                return;
+            if (this.hppOptions.enableSca) {
+                this.sca.run({
+                    cardToken: data.token,
+                    customer: this.customer,
+                    paymentIntent: this.paymentIntent,
+                    bin: data.bin,
+                    challengeWindowSize: (_a = this.hppOptions) === null || _a === void 0 ? void 0 : _a.challengeWindowSize,
+                });
+            }
+            else {
+                this.createPurchase();
+            }
+        };
+        handlers[BridgeEvent.CREATE_PAYMENT_RESPONSE] = (data) => {
+            const transactionPayload = {
+                transactionId: data.transaction_id,
+                responseCode: data.response_code,
+                message: data.message,
+                amount: data.amount,
+                currency: data.currency,
+                reference: data.reference,
+                cardNumber: data.card_number,
+                cardHolder: data.card_holder,
+                cardExpiry: data.card_expiry,
+                cardType: data.card_type,
+                verification: data.v,
+            };
+            if (data.errors) {
+                emit(PublicEvent.PAYMENT_ERROR, {
+                    message: 'Payment failed.',
+                    errors: data.errors,
+                    data: transactionPayload,
+                });
+            }
+            else {
+                emit(PublicEvent.PAYMENT_SUCCESS, {
+                    message: 'Payment successful.',
+                    data: transactionPayload,
+                });
+            }
+        };
+        handlers[BridgeEvent.FORM_VALIDATION_ERROR] = (data) => {
+            emit(PublicEvent.FORM_VALIDATION_ERROR, {
+                message: "Form was not valid",
+                errors: data.full_error_messages,
+                data: data.errors,
+            });
+        };
+        handlers[BridgeEvent.FORM_VALIDATION_SUCCESS] = (data) => {
+            emit(PublicEvent.FORM_VALIDATION_SUCCESS, {
+                message: "Form was valid",
+                data: null,
+            });
+        };
+        handlers[BridgeEvent.BIN_LOOKUP] = (data) => {
+            emit(PublicEvent.BIN_LOOKUP, {
+                message: "BIN Lookup complete",
+                data: data,
+            });
+        };
+        this.postMessageClient.setEventListeners(handlers);
+    }
+    setPublicEventListeners() {
+        const handler = (event) => {
+            const threedsData = event.detail.data;
+            const extra = util.toObjectWithSnakeCaseKeys(threedsData);
+            this.createPurchase(extra);
+        };
+        on(PublicEvent.SCA_SUCCESS, handler);
+    }
+    createPurchase(extra = null) {
+        const message = {
+            channel: 'sca',
+            subject: BridgeEvent.CREATE_PAYMENT_REQUEST,
+            data: {
+                access_token: window.localStorage.getItem(LocalStorageAccessTokenKey),
+                amount: this.paymentIntent.payment.amount,
+                card_token: this.cardToken,
+                currency: this.paymentIntent.payment.currency,
+                hide_card_holder: this.paymentIntent.payment.hide_card_holder,
+                hash: this.paymentIntent.verification,
+                invoice: this.paymentIntent.payment.reference,
+                test: this.test,
+            }
+        };
+        if (extra) {
+            message.data.extra = extra;
+        }
+        this.headless.contentWindow.postMessage(message, '*');
+    }
+}
+export { Hpp, HPP_DEFAULT_OPTIONS, };

package/dist/hpp/index.d.ts

@@ -0,0 +1,2 @@
+export { Hpp } from './hpp';
+export type { HppLoadParams } from './hpp';

package/dist/hpp/index.js

@@ -0,0 +1 @@
+export { Hpp } from './hpp';

package/dist/index.d.ts

@@ -1,2 +1,5 @@
-import { Payment, PaymentIntent, VerificationConfig, Handlers, PublicEvent } from "./shared/types";
-export { type Payment, type PaymentIntent, type VerificationConfig, type Handlers, PublicEvent, };
+import "ts-polyfill";
+import "custom-event-polyfill";
+import { type PaymentIntent, type Payment, type PublicEvent, type PaymentConfig, type Handlers } from "./shared/types";
+export type { PaymentIntent, Payment, PaymentConfig, Handlers };
+export { PublicEvent };

package/dist/index.js

@@ -1,2 +1,6 @@
-import { PublicEvent } from "./shared/types";
-export { PublicEvent, };
+import "ts-polyfill";
+import "custom-event-polyfill";
+import { FatZebra } from "./main";
+if (typeof window !== "undefined") {
+    window.FatZebra = FatZebra;
+}