ngx-paypal-with-intent
Version:
Paypal integration for Angular 6, 7 and beyond
506 lines • 59.2 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('rxjs/operators')) :
typeof define === 'function' && define.amd ? define('ngx-paypal-with-intent', ['exports', '@angular/core', 'rxjs', 'rxjs/operators'], factory) :
(factory((global['ngx-paypal-with-intent'] = {}),global.ng.core,global.rxjs,global.rxjs.operators));
}(this, (function (exports,core,rxjs,operators) { 'use strict';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @enum {number} */
var PayPalFunding = {
Card: 0,
Credit: 1,
Elv: 2,
};
PayPalFunding[PayPalFunding.Card] = 'Card';
PayPalFunding[PayPalFunding.Credit] = 'Credit';
PayPalFunding[PayPalFunding.Elv] = 'Elv';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @enum {number} */
var PayPalIntegrationType = {
ClientSideREST: 0,
ServerSideREST: 1,
};
PayPalIntegrationType[PayPalIntegrationType.ClientSideREST] = 'ClientSideREST';
PayPalIntegrationType[PayPalIntegrationType.ServerSideREST] = 'ServerSideREST';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var NgxPaypalComponent = /** @class */ (function () {
function NgxPaypalComponent() {
/**
* Indicates if global configuration (provided via 'forRoot') is used
*/
this.useGlobalConfig = false;
/**
* Used for indicating delayed rendered if container is not yet ready in DOM
*/
this.registerPayPalScriptWhenContainerIsReady = false;
/**
* Polling interval if paypal script is pending
*/
this.defaultPollInterval = 50;
/**
* Polling will stop after polling reaches this number
*/
this.maximumPollWaitTime = 5000;
/**
* Name of the global variable where paypal is stored
*/
this.paypalWindowName = 'paypal';
/**
* Name of the global variable indicating that script was initiated (added to page)
*/
this.paypalWindowScriptInitiated = 'ngx-paypal-script-initiated';
/**
* PayPal integration script url
*/
this.paypalScriptUrl = 'https://www.paypalobjects.com/api/checkout.js';
this.payPalButtonContainerIdPrefix = 'ngx-paypal-button-container-';
this.ngUnsubscribe = new rxjs.Subject();
}
Object.defineProperty(NgxPaypalComponent.prototype, "payPalButtonContainerElem", {
set: /**
* @param {?} content
* @return {?}
*/ function (content) {
if (content) {
this._payPalButtonContainerElem = content;
}
},
enumerable: true,
configurable: true
});
/**
* @param {?} changes
* @return {?}
*/
NgxPaypalComponent.prototype.ngOnChanges = /**
* @param {?} changes
* @return {?}
*/
function (changes) {
// init when config once its available
if (this.config) {
this.initPayPal();
}
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
// register script if element is ready in dom
if (this.registerPayPalScriptWhenContainerIsReady && this._payPalButtonContainerElem) {
this.setupScript();
this.registerPayPalScriptWhenContainerIsReady = false;
}
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.ngUnsubscribe.next();
this.ngUnsubscribe.complete();
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.initPayPal = /**
* @return {?}
*/
function () {
// set unique paypal container button id
this.payPalButtonContainerId = "" + this.payPalButtonContainerIdPrefix + this.getPseudoUniqueNumber();
// check if paypal was already register and if so, don't add it to page again
if (!window[this.paypalWindowName]) {
// check if script is pending
if (window[this.paypalWindowScriptInitiated] === true) {
this.pollUntilScriptAvailable();
}
else {
// register script and set global flag
window[this.paypalWindowScriptInitiated] = true;
this.addPayPalScriptToPage();
}
}
else {
// just register payment
this.handleScriptRegistering();
}
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.getPseudoUniqueNumber = /**
* @return {?}
*/
function () {
return new Date().valueOf();
};
/**
* Used when there are multiple paypal components on the same page beacuse only 1 of them
* may register paypal script. The other has to be polling until paypal is available or component destroyed
*/
/**
* Used when there are multiple paypal components on the same page beacuse only 1 of them
* may register paypal script. The other has to be polling until paypal is available or component destroyed
* @return {?}
*/
NgxPaypalComponent.prototype.pollUntilScriptAvailable = /**
* Used when there are multiple paypal components on the same page beacuse only 1 of them
* may register paypal script. The other has to be polling until paypal is available or component destroyed
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var obs = rxjs.interval(this.defaultPollInterval)
.pipe(operators.takeUntil(this.ngUnsubscribe), operators.map(function (x) {
if (x >= _this.maximumPollWaitTime) {
console.warn("PayPal script was not loaded after '" + _this.maximumPollWaitTime + "' maximum polling time.");
obs.unsubscribe();
return;
}
// check if paypal script exists
if (window[_this.paypalWindowName]) {
// register script
_this.handleScriptRegistering();
// stop execution
obs.unsubscribe();
}
}))
.subscribe();
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.addPayPalScriptToPage = /**
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var script = document.createElement('script');
script.innerHTML = '';
script.src = this.paypalScriptUrl;
script.onload = function () { return _this.handleScriptRegistering(); };
script.async = true;
script.defer = true;
this.paypalScriptElem.nativeElement.appendChild(script);
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.handleScriptRegistering = /**
* @return {?}
*/
function () {
// check if container with requested id exists
// this is here because dynamically switching between components would cause PayPal to
// throw an error if the container already existed before
if (this._payPalButtonContainerElem && this._payPalButtonContainerElem.nativeElement &&
this._payPalButtonContainerElem.nativeElement.id === this.payPalButtonContainerId) {
// container is ready, setup script right away
this.setupScript();
}
else {
// container is not ready, delay registering until it is
this.registerPayPalScriptWhenContainerIsReady = true;
}
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.setupScript = /**
* @return {?}
*/
function () {
var _this = this;
// first clear container
if (!this._payPalButtonContainerElem) {
throw Error("Cannot setup script because paypal button container with id '" + this.payPalButtonContainerId + "' is not yet ready");
}
this._payPalButtonContainerElem.nativeElement.innerHTML = '';
if (!window[this.paypalWindowName]) {
throw Error('PayPal script is not available');
}
// render PayPal button as per their docs at
// https://developer.paypal.com/docs/integration/direct/express-checkout/integration-jsv4/add-paypal-button/
window[this.paypalWindowName].Button.render({
// set environment
env: this.config.environment.toString(),
// Show the buyer a 'Pay Now' button in the checkout flow
commit: this.config.commit,
// init client for client side integration
client: this.getClient(),
// set button config if available
style: this.config.button,
// set funding if available
funding: this.getFunding(),
// payment() is called when the button is clicked
payment: function (data, actions) {
if (_this.config.integrationType === PayPalIntegrationType.ServerSideREST) {
// client needs to create payment on server side
if (!_this.config.payment) {
throw Error("You need set up a create payment method and return\n PayPal's payment id when using server side integration");
}
// Paypal expects promise with payment id (string) to be returned
return _this.config.payment().toPromise()
.then(function (paymentId) {
return paymentId;
});
}
if (_this.config.integrationType === PayPalIntegrationType.ClientSideREST) {
if (!_this.config.transactions || !Array.isArray(_this.config.transactions) || _this.config.transactions.length <= 0) {
throw Error("You need to provide at least 1 transaction for client side integration");
}
/** @type {?} */
var experienceConfig = _this.config.experience;
return actions.payment.create({
payment: {
// Allow user to specifify intent, else use default 'sale'.
intent: _this.config.intent ? _this.config.intent : 'sale',
transactions: _this.config.transactions
},
experience: {
input_fields: {
no_shipping: (experienceConfig && experienceConfig.noShipping) ? 1 : 0
},
presentation: {
brand_name: (experienceConfig && experienceConfig.brandName) ? experienceConfig.brandName : null,
logo_image: (experienceConfig && experienceConfig.logoImage) ? experienceConfig.logoImage : null,
locale_code: (experienceConfig && experienceConfig.localeCode) ? experienceConfig.localeCode : null
}
}
});
}
},
// onAuthorize() is called when the buyer approves the payment
onAuthorize: function (data, actions) {
if (_this.config.integrationType === PayPalIntegrationType.ServerSideREST) {
// client needs to server to execute the payment
if (!_this.config.onAuthorize) {
throw Error("You need set up an execute method when using server side integration");
}
// Paypal expects promise
return _this.config.onAuthorize(data, actions).toPromise();
}
if (_this.config.integrationType === PayPalIntegrationType.ClientSideREST) {
// Make a call to the REST api to execute the payment
return actions.payment.execute().then(function () {
if (!_this.config.onPaymentComplete) {
throw Error("You should provide some callback when payment is finished when using client side integration");
}
_this.config.onPaymentComplete(data, actions);
});
}
},
onError: function (err) {
if (_this.config.onError) {
_this.config.onError(err);
}
},
onCancel: function (data, actions) {
if (_this.config.onCancel) {
_this.config.onCancel(data, actions);
}
},
onClick: function () {
if (_this.config.onClick) {
_this.config.onClick();
}
},
validate: function (actions) {
if (_this.config.validate) {
_this.config.validate(actions);
}
}
}, "#" + this.payPalButtonContainerId);
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.getClient = /**
* @return {?}
*/
function () {
if (this.config.integrationType === PayPalIntegrationType.ClientSideREST) {
if (!this.config.client) {
throw Error("You need to setup client information when using client side integration");
}
return {
production: this.config.client.production,
sandbox: this.config.client.sandbox
};
}
return undefined;
};
/**
* @return {?}
*/
NgxPaypalComponent.prototype.getFunding = /**
* @return {?}
*/
function () {
var _this = this;
// resolve funding to use paypal's properties
if (!this.config.funding) {
// no funding provided
return undefined;
}
/** @type {?} */
var allowed = [];
/** @type {?} */
var disallowed = [];
if (this.config.funding.allowed) {
this.config.funding.allowed.forEach(function (type) {
allowed.push(_this.mapFundingType(type));
});
}
if (this.config.funding.disallowed) {
this.config.funding.disallowed.forEach(function (type) {
disallowed.push(_this.mapFundingType(type));
});
}
return {
allowed: allowed,
disallowed: disallowed
};
};
/**
* @param {?} type
* @return {?}
*/
NgxPaypalComponent.prototype.mapFundingType = /**
* @param {?} type
* @return {?}
*/
function (type) {
if (type === PayPalFunding.Card) {
return paypal.FUNDING.CARD;
}
if (type === PayPalFunding.Credit) {
return paypal.FUNDING.CREDIT;
}
if (type === PayPalFunding.Elv) {
return paypal.FUNDING.ELV;
}
throw Error("Unsupported funding type '" + type + "'");
};
NgxPaypalComponent.decorators = [
{ type: core.Component, args: [{
changeDetection: core.ChangeDetectionStrategy.OnPush,
selector: 'ngx-paypal',
template: "\n <div #payPalScriptElem></div>\n <div #payPalButtonContainerElem [id]=\"payPalButtonContainerId\"></div>\n "
}] }
];
/** @nocollapse */
NgxPaypalComponent.ctorParameters = function () { return []; };
NgxPaypalComponent.propDecorators = {
config: [{ type: core.Input }],
useGlobalConfig: [{ type: core.Input }],
paypalScriptElem: [{ type: core.ViewChild, args: ['payPalScriptElem',] }],
payPalButtonContainerElem: [{ type: core.ViewChild, args: ['payPalButtonContainerElem',] }]
};
return NgxPaypalComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var NgxPayPalModule = /** @class */ (function () {
function NgxPayPalModule() {
}
NgxPayPalModule.decorators = [
{ type: core.NgModule, args: [{
imports: [],
declarations: [
NgxPaypalComponent,
],
exports: [
NgxPaypalComponent,
]
},] }
];
return NgxPayPalModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @enum {string} */
var PayPalEnvironment = {
Sandbox: 'sandbox',
Production: 'production',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var PayPalConfig = /** @class */ (function () {
function PayPalConfig(integrationType, environment, config) {
this.integrationType = integrationType;
this.environment = environment;
/**
* Show 'Pay Now' button config
*/
this.commit = true;
/**
* Set the intent of the payment.
*/
this.intent = 'sale';
Object.assign(this, config);
}
return PayPalConfig;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
exports.NgxPayPalModule = NgxPayPalModule;
exports.PayPalEnvironment = PayPalEnvironment;
exports.PayPalFunding = PayPalFunding;
exports.PayPalIntegrationType = PayPalIntegrationType;
exports.PayPalConfig = PayPalConfig;
exports.NgxPaypalComponent = NgxPaypalComponent;
exports.ɵa = NgxPaypalComponent;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-paypal-with-intent.umd.js.map","sources":["ng://ngx-paypal-with-intent/lib/models/paypal-funding.ts","ng://ngx-paypal-with-intent/lib/models/paypal-integration.ts","ng://ngx-paypal-with-intent/lib/components/paypal-component.ts","ng://ngx-paypal-with-intent/lib/ngx-paypal.module.ts","ng://ngx-paypal-with-intent/lib/models/paypal-environment.ts","ng://ngx-paypal-with-intent/lib/models/paypal-models.ts"],"sourcesContent":["export enum PayPalFunding {\n    Card,\n    Credit,\n    Elv\n}\n","export enum PayPalIntegrationType {\n    ClientSideREST,\n    ServerSideREST,\n}\n","import {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    Input,\n    OnChanges,\n    OnDestroy,\n    SimpleChanges,\n    ViewChild,\n} from '@angular/core';\nimport { interval, Subject } from 'rxjs';\nimport { map, takeUntil } from 'rxjs/operators';\n\nimport { PayPalFunding } from '../models/paypal-funding';\nimport { PayPalIntegrationType } from '../models/paypal-integration';\nimport { IPaypalClient, IPayPalPaymentCompleteData, PayPalConfig } from '../models/paypal-models';\n\n/**\n * Global variable where PayPal is loaded to\n */\ndeclare var paypal: any;\n\n@Component({\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    selector: 'ngx-paypal',\n    template: `\n    <div #payPalScriptElem></div>\n    <div #payPalButtonContainerElem [id]=\"payPalButtonContainerId\"></div>\n    `\n})\nexport class NgxPaypalComponent implements OnChanges, AfterViewInit, OnDestroy {\n\n    /**\n     * Configuration for paypal.\n     */\n    @Input() config: PayPalConfig;\n\n    /**\n     * Indicates if global configuration (provided via 'forRoot') is used\n     */\n    @Input() useGlobalConfig = false;\n\n    /**\n     * Container for paypal script\n     */\n    @ViewChild('payPalScriptElem') paypalScriptElem: ElementRef;\n\n    /**\n     * Used for indicating delayed rendered if container is not yet ready in DOM\n     */\n    private registerPayPalScriptWhenContainerIsReady = false;\n\n    /**\n     * Holds current container element\n     */\n    private _payPalButtonContainerElem?: ElementRef;\n    @ViewChild('payPalButtonContainerElem') set payPalButtonContainerElem(content: ElementRef) {\n        if (content) {\n            this._payPalButtonContainerElem = content;\n        }\n    }\n\n    /**\n     * Polling interval if paypal script is pending\n     */\n    private readonly defaultPollInterval = 50;\n\n    /**\n     * Polling will stop after polling reaches this number\n     */\n    private readonly maximumPollWaitTime = 5000;\n\n    /**\n    * Name of the global variable where paypal is stored\n    */\n    private readonly paypalWindowName = 'paypal';\n\n    /**\n     * Name of the global variable indicating that script was initiated (added to page)\n     */\n    private readonly paypalWindowScriptInitiated = 'ngx-paypal-script-initiated';\n\n    /**\n     * PayPal integration script url\n     */\n    private readonly paypalScriptUrl = 'https://www.paypalobjects.com/api/checkout.js';\n\n    /**\n     * Id of the element where PayPal button will be rendered\n     */\n    public payPalButtonContainerId?: string;\n\n    private readonly payPalButtonContainerIdPrefix = 'ngx-paypal-button-container-';\n\n    private readonly ngUnsubscribe: Subject<void> = new Subject<void>();\n\n    constructor(\n    ) {\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        // init when config once its available\n        if (this.config) {\n            this.initPayPal();\n        }\n    }\n\n    ngAfterViewInit(): void {\n        // register script if element is ready in dom\n        if (this.registerPayPalScriptWhenContainerIsReady && this._payPalButtonContainerElem) {\n            this.setupScript();\n            this.registerPayPalScriptWhenContainerIsReady = false;\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.ngUnsubscribe.next();\n        this.ngUnsubscribe.complete();\n    }\n\n    private initPayPal(): void {\n        // set unique paypal container button id\n        this.payPalButtonContainerId = `${this.payPalButtonContainerIdPrefix}${this.getPseudoUniqueNumber()}`;\n        // check if paypal was already register and if so, don't add it to page again\n        if (!window[this.paypalWindowName]) {\n            // check if script is pending\n            if (window[this.paypalWindowScriptInitiated] === true) {\n                this.pollUntilScriptAvailable();\n            } else {\n                // register script and set global flag\n                window[this.paypalWindowScriptInitiated] = true;\n                this.addPayPalScriptToPage();\n            }\n\n        } else {\n            // just register payment\n            this.handleScriptRegistering();\n        }\n    }\n\n    private getPseudoUniqueNumber(): number {\n        return new Date().valueOf();\n    }\n\n    /**\n     * Used when there are multiple paypal components on the same page beacuse only 1 of them\n     * may register paypal script. The other has to be polling until paypal is available or component destroyed\n     */\n    private pollUntilScriptAvailable(): void {\n        const obs = interval(this.defaultPollInterval)\n            .pipe(\n                takeUntil(this.ngUnsubscribe),\n                map((x) => {\n                    if (x >= this.maximumPollWaitTime) {\n                        console.warn(`PayPal script was not loaded after '${this.maximumPollWaitTime}' maximum polling time.`);\n                        obs.unsubscribe();\n                        return;\n                    }\n\n                    // check if paypal script exists\n                    if (window[this.paypalWindowName]) {\n                        // register script\n                        this.handleScriptRegistering();\n\n                        // stop execution\n                        obs.unsubscribe();\n                    }\n                })\n            )\n            .subscribe();\n    }\n\n    private addPayPalScriptToPage(): void {\n        const script = document.createElement('script');\n        script.innerHTML = '';\n        script.src = this.paypalScriptUrl;\n        script.onload = () => this.handleScriptRegistering();\n        script.async = true;\n        script.defer = true;\n\n        this.paypalScriptElem.nativeElement.appendChild(script);\n    }\n\n    private handleScriptRegistering(): void {\n        // check if container with requested id exists\n        // this is here because dynamically switching between components would cause PayPal to\n        // throw an error if the container already existed before\n        if (this._payPalButtonContainerElem && this._payPalButtonContainerElem.nativeElement &&\n            this._payPalButtonContainerElem.nativeElement.id === this.payPalButtonContainerId) {\n            // container is ready, setup script right away\n            this.setupScript();\n        } else {\n            // container is not ready, delay registering until it is\n            this.registerPayPalScriptWhenContainerIsReady = true;\n        }\n    }\n\n    private setupScript(): void {\n        // first clear container\n        if (!this._payPalButtonContainerElem) {\n            throw Error(`Cannot setup script because paypal button container with id '${this.payPalButtonContainerId}' is not yet ready`);\n        }\n\n        this._payPalButtonContainerElem.nativeElement.innerHTML = '';\n\n        if (!window[this.paypalWindowName]) {\n            throw Error('PayPal script is not available');\n        }\n\n        // render PayPal button as per their docs at\n        // https://developer.paypal.com/docs/integration/direct/express-checkout/integration-jsv4/add-paypal-button/\n        window[this.paypalWindowName].Button.render({\n            // set environment\n            env: this.config.environment.toString(),\n\n            // Show the buyer a 'Pay Now' button in the checkout flow\n            commit: this.config.commit,\n\n            // init client for client side integration\n            client: this.getClient(),\n\n            // set button config if available\n            style: this.config.button,\n\n            // set funding if available\n            funding: this.getFunding(),\n\n            // payment() is called when the button is clicked\n            payment: (data, actions) => {\n                if (this.config.integrationType === PayPalIntegrationType.ServerSideREST) {\n                    // client needs to create payment on server side\n                    if (!this.config.payment) {\n                        throw Error(`You need set up a create payment method and return\n                            PayPal's payment id when using server side integration`);\n                    }\n\n                    // Paypal expects promise with payment id (string) to be returned\n                    return this.config.payment().toPromise()\n                        .then(paymentId => {\n                            return paymentId;\n                        });\n                }\n\n                if (this.config.integrationType === PayPalIntegrationType.ClientSideREST) {\n                    if (!this.config.transactions || !Array.isArray(this.config.transactions) || this.config.transactions.length <= 0) {\n                        throw Error(`You need to provide at least 1 transaction for client side integration`);\n                    }\n\n                    const experienceConfig = this.config.experience;\n                    return actions.payment.create({\n                        payment: {\n                            // Allow user to specifify intent, else use default 'sale'.\n                            intent: this.config.intent ? this.config.intent : 'sale',\n                            transactions: this.config.transactions\n                        },\n                        experience: {\n                            input_fields: {\n                                no_shipping: (experienceConfig && experienceConfig.noShipping) ? 1 : 0\n                            },\n                            presentation: {\n                                brand_name: (experienceConfig && experienceConfig.brandName) ? experienceConfig.brandName : null,\n                                logo_image: (experienceConfig && experienceConfig.logoImage) ? experienceConfig.logoImage : null,\n                                locale_code: (experienceConfig && experienceConfig.localeCode) ? experienceConfig.localeCode : null\n                            }\n                        }\n                    });\n                }\n            },\n\n            // onAuthorize() is called when the buyer approves the payment\n            onAuthorize: (data: IPayPalPaymentCompleteData, actions: any) => {\n                if (this.config.integrationType === PayPalIntegrationType.ServerSideREST) {\n                    // client needs to server to execute the payment\n                    if (!this.config.onAuthorize) {\n                        throw Error(`You need set up an execute method when using server side integration`);\n                    }\n\n                    // Paypal expects promise\n                    return this.config.onAuthorize(data, actions).toPromise();\n                }\n\n                if (this.config.integrationType === PayPalIntegrationType.ClientSideREST) {\n                    // Make a call to the REST api to execute the payment\n                    return actions.payment.execute().then(() => {\n                        if (!this.config.onPaymentComplete) {\n                            throw Error(`You should provide some callback when payment is finished when using client side integration`);\n                        }\n                        this.config.onPaymentComplete(data, actions);\n                    });\n                }\n            },\n\n            onError: (err) => {\n                if (this.config.onError) {\n                    this.config.onError(err);\n                }\n            },\n\n            onCancel: (data, actions) => {\n                if (this.config.onCancel) {\n                    this.config.onCancel(data, actions);\n                }\n            },\n            onClick: () => {\n                if (this.config.onClick) {\n                    this.config.onClick();\n                }\n            },\n            validate: (actions) => {\n                if (this.config.validate) {\n                    this.config.validate(actions);\n                }\n            }\n        }, `#${this.payPalButtonContainerId}`);\n    }\n\n    private getClient(): IPaypalClient | undefined {\n        if (this.config.integrationType === PayPalIntegrationType.ClientSideREST) {\n            if (!this.config.client) {\n                throw Error(`You need to setup client information when using client side integration`);\n            }\n\n            return {\n                production: this.config.client.production,\n                sandbox: this.config.client.sandbox\n            };\n        }\n\n        return undefined;\n    }\n\n    private getFunding(): {\n        allowed: any[],\n        disallowed: any[]\n    } | undefined {\n        // resolve funding to use paypal's properties\n        if (!this.config.funding) {\n            // no funding provided\n            return undefined;\n        }\n\n        const allowed: any[] = [];\n        const disallowed: any[] = [];\n\n        if (this.config.funding.allowed) {\n            this.config.funding.allowed.forEach(type => {\n                allowed.push(this.mapFundingType(type));\n            });\n        }\n\n        if (this.config.funding.disallowed) {\n            this.config.funding.disallowed.forEach(type => {\n                disallowed.push(this.mapFundingType(type));\n            });\n        }\n\n        return {\n            allowed: allowed,\n            disallowed: disallowed\n        };\n    }\n\n    private mapFundingType(type: PayPalFunding): any {\n        if (type === PayPalFunding.Card) {\n            return paypal.FUNDING.CARD;\n        }\n        if (type === PayPalFunding.Credit) {\n            return paypal.FUNDING.CREDIT;\n        }\n        if (type === PayPalFunding.Elv) {\n            return paypal.FUNDING.ELV;\n        }\n        throw Error(`Unsupported funding type '${type}'`);\n    }\n}\n\n","import { NgModule } from '@angular/core';\n\nimport { NgxPaypalComponent } from './components/paypal-component';\n\n@NgModule({\n  imports: [\n  ],\n  declarations: [\n    NgxPaypalComponent,\n  ],\n  exports: [\n    NgxPaypalComponent,\n  ]\n})\nexport class NgxPayPalModule {\n}\n\n\n","export enum PayPalEnvironment {\n    Sandbox = 'sandbox',\n    Production = 'production'\n}\n","import { Observable } from 'rxjs';\n\nimport { PayPalFunding } from './paypal-funding';\nimport { PayPalEnvironment } from './paypal-environment';\nimport { PayPalIntegrationType } from './paypal-integration';\n\nexport class PayPalConfig {\n\n    /**\n     * Show 'Pay Now' button config\n     */\n    public commit = true;\n\n    /**\n     * Set the intent of the payment.\n     */\n    public intent = 'sale';\n\n    /**\n     * Called to create new payment for server side integration\n     */\n    public payment?: () => Observable<string>;\n\n    /**\n     * Called to execute payment for server side integration\n     */\n    public onAuthorize?: (data: IPayPalPaymentCompleteData, actions: any) => Observable<void>;\n\n    /**\n     * Client tokens for client side integration\n     */\n    public client?: IPaypalClient;\n\n    /**\n     * Array of transaction, required for client side integration\n     */\n    public transactions?: IPayPalTransaction[];\n\n    /**\n     * Payment Experience configurations\n     */\n    public experience?: IPayPalExperience;\n\n    /**\n     * Called for client side integration when payment is executed\n     */\n    public onPaymentComplete?: (data: IPayPalPaymentCompleteData, actions: any) => void;\n\n    /**\n     * Button configuration\n     */\n    public button?: IPayPalButtonStyle;\n\n    /**\n     * Paypal funding configuration\n     */\n    public funding?: IPayPalFunding;\n\n    /**\n     * Called when PayPal experiences an error\n     */\n    public onError?: (err: any) => void;\n\n    /**\n     * This handler will be called for every click on the PayPal button\n     */\n    public onClick?: () => void;\n\n    /**\n     * Called when user cancels payment\n     */\n    public onCancel?: (data: IPayPalCancelPayment, actions: any) => void;\n\n    /**\n     * Can be used to validation as can be seen here: https://developer.paypal.com/demo/checkout/#/pattern/validation\n     */\n    public validate?: (actions: any) => void;\n\n    constructor(\n        /**\n         * Type of the integration\n         */\n        public integrationType: PayPalIntegrationType,\n        /**\n         * Environment\n         */\n        public environment: PayPalEnvironment,\n        config: {\n            onError?: (err: any) => void,\n            onClick?: () => void,\n            validate?: (actions: any) => void;\n            onCancel?: (data: IPayPalCancelPayment, actions: any) => void,\n            payment?: () => Observable<string>,\n            intent?: string,\n            onAuthorize?: (data: IPayPalPaymentCompleteData, actions: any) => Observable<void>,\n            client?: IPaypalClient,\n            onPaymentComplete?: (data: IPayPalPaymentCompleteData, actions: any) => void,\n            transactions?: IPayPalTransaction[],\n            note_to_payer?: string;\n            experience?: IPayPalExperience,\n            commit?: boolean,\n            button?: IPayPalButtonStyle,\n            funding?: IPayPalFunding\n        }) {\n        Object.assign(this, config);\n    }\n}\n\nexport interface IPayPalPaymentCompleteData {\n    intent: string;\n    orderID: string;\n    payerID: string;\n    paymentID: string;\n    paymentToken: string;\n    returnUrl: string;\n}\n\nexport interface IPayPalCancelPayment {\n    data: IPayPalCancelPaymentData;\n    actions: any;\n}\n\nexport interface IPayPalCancelPaymentData {\n    billingID: string;\n    cancelUrl: string;\n    intent: string;\n    paymentID: string;\n    paymentToken: string;\n}\n\nexport interface IPaypalClient {\n    sandbox?: string;\n    production?: string;\n}\n\nexport interface IPayPalTransaction {\n    amount: IPayPalAmount;\n    description?: string;\n    custom?: string;\n    payment_options?: IPayPalTransactionPaymentOptions;\n    invoice_number?: string;\n    soft_descriptor?: string;\n    item_list?: IPayPalTransactionItemList;\n}\n\nexport interface IPayPalTransactionItemList {\n    items?: IPayPalTransactionItem[];\n    shipping_address?: IPayPalTransactionShippingAddress;\n}\n\nexport interface IPayPalTransactionItem {\n    name: string;\n    currency: string;\n    price: number;\n    quantity: number;\n\n    description?: string;\n    tax?: number;\n    sku?: string;\n}\n\nexport interface IPayPalAmount {\n    total: number;\n    currency: string;\n    details?: IPayPalAmountDetails;\n}\n\nexport interface IPayPalTransactionShippingAddress {\n    recipient_name: string;\n    line1: string;\n    line2?: string;\n    city: string;\n    country_code: string;\n    postal_code: string;\n    phone: string;\n    state: string;\n}\n\nexport interface IPayPalAmountDetails {\n    subtotal: number;\n    tax: number;\n    shipping: number;\n    handling_fee: number;\n    shipping_discount: number;\n    insurance: number;\n}\n\nexport interface IPayPalTransactionPaymentOptions {\n    allowed_payment_method?: string;\n}\n\nexport interface IPayPalExperience {\n    /** Indicates whether PayPal displays shipping address fields on the experience pages */\n    noShipping?: boolean;\n    /** A label that overrides the business name in the PayPal account on the PayPal pages. Max length: 127 characters. */\n    brandName?: string;\n    /** URL to the logo image (gif, jpg, or png). The image's maximum width is 190 pixels and maximum height is 60 pixels. */\n    logoImage?: string;\n    /** Locale in which to display PayPal page */\n    localeCode?: string;\n}\n\nexport interface IPayPalButtonStyle {\n    label?: 'checkout' | 'pay' | 'buynow' | 'paypal';\n    size?: 'small' | 'medium' | 'large' | 'responsive';\n    shape?: 'pill' | 'rect';\n    color?: 'gold' | 'blue' | 'silver' | 'black';\n    layout?: 'horizontal' | 'vertical';\n    tagline?: false;\n    fundingicons?: boolean;\n    branding?: boolean;\n}\n\nexport interface IPayPalFunding {\n    allowed: PayPalFunding[];\n    disallowed: PayPalFunding[];\n}\n\n"],"names":["Subject","interval","takeUntil","map","Component","ChangeDetectionStrategy","Input","ViewChild","NgModule"],"mappings":"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"}