ngx-paypal-with-intent
Version:
Paypal integration for Angular 6, 7 and beyond
458 lines • 46.5 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
import { ChangeDetectionStrategy, Component, ElementRef, Input, ViewChild, } from '@angular/core';
import { interval, Subject } from 'rxjs';
import { map, takeUntil } from 'rxjs/operators';
import { PayPalFunding } from '../models/paypal-funding';
import { PayPalIntegrationType } from '../models/paypal-integration';
import { PayPalConfig } from '../models/paypal-models';
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 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 = interval(this.defaultPollInterval)
.pipe(takeUntil(this.ngUnsubscribe), 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: Component, args: [{
changeDetection: 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: Input }],
useGlobalConfig: [{ type: Input }],
paypalScriptElem: [{ type: ViewChild, args: ['payPalScriptElem',] }],
payPalButtonContainerElem: [{ type: ViewChild, args: ['payPalButtonContainerElem',] }]
};
return NgxPaypalComponent;
}());
export { NgxPaypalComponent };
if (false) {
/**
* Configuration for paypal.
* @type {?}
*/
NgxPaypalComponent.prototype.config;
/**
* Indicates if global configuration (provided via 'forRoot') is used
* @type {?}
*/
NgxPaypalComponent.prototype.useGlobalConfig;
/**
* Container for paypal script
* @type {?}
*/
NgxPaypalComponent.prototype.paypalScriptElem;
/**
* Used for indicating delayed rendered if container is not yet ready in DOM
* @type {?}
*/
NgxPaypalComponent.prototype.registerPayPalScriptWhenContainerIsReady;
/**
* Holds current container element
* @type {?}
*/
NgxPaypalComponent.prototype._payPalButtonContainerElem;
/**
* Polling interval if paypal script is pending
* @type {?}
*/
NgxPaypalComponent.prototype.defaultPollInterval;
/**
* Polling will stop after polling reaches this number
* @type {?}
*/
NgxPaypalComponent.prototype.maximumPollWaitTime;
/**
* Name of the global variable where paypal is stored
* @type {?}
*/
NgxPaypalComponent.prototype.paypalWindowName;
/**
* Name of the global variable indicating that script was initiated (added to page)
* @type {?}
*/
NgxPaypalComponent.prototype.paypalWindowScriptInitiated;
/**
* PayPal integration script url
* @type {?}
*/
NgxPaypalComponent.prototype.paypalScriptUrl;
/**
* Id of the element where PayPal button will be rendered
* @type {?}
*/
NgxPaypalComponent.prototype.payPalButtonContainerId;
/** @type {?} */
NgxPaypalComponent.prototype.payPalButtonContainerIdPrefix;
/** @type {?} */
NgxPaypalComponent.prototype.ngUnsubscribe;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paypal-component.js","sourceRoot":"ng://ngx-paypal-with-intent/","sources":["lib/components/paypal-component.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EAEH,uBAAuB,EACvB,SAAS,EACT,UAAU,EACV,KAAK,EAIL,SAAS,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAA6C,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAOlG;IA0EI;;;;QAxDS,oBAAe,GAAG,KAAK,CAAC;;;;QAUzB,6CAAwC,GAAG,KAAK,CAAC;;;;QAexC,wBAAmB,GAAG,EAAE,CAAC;;;;QAKzB,wBAAmB,GAAG,IAAI,CAAC;;;;QAK3B,qBAAgB,GAAG,QAAQ,CAAC;;;;QAK5B,gCAA2B,GAAG,6BAA6B,CAAC;;;;QAK5D,oBAAe,GAAG,+CAA+C,CAAC;QAOlE,kCAA6B,GAAG,8BAA8B,CAAC;QAE/D,kBAAa,GAAkB,IAAI,OAAO,EAAQ,CAAC;IAIpE,CAAC;IA1CD,sBAA4C,yDAAyB;;;;;QAArE,UAAsE,OAAmB;YACrF,IAAI,OAAO,EAAE;gBACT,IAAI,CAAC,0BAA0B,GAAG,OAAO,CAAC;aAC7C;QACL,CAAC;;;OAAA;;;;;IAwCD,wCAAW;;;;IAAX,UAAY,OAAsB;QAC9B,sCAAsC;QACtC,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,IAAI,CAAC,UAAU,EAAE,CAAC;SACrB;IACL,CAAC;;;;IAED,4CAAe;;;IAAf;QACI,6CAA6C;QAC7C,IAAI,IAAI,CAAC,wCAAwC,IAAI,IAAI,CAAC,0BAA0B,EAAE;YAClF,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,wCAAwC,GAAG,KAAK,CAAC;SACzD;IACL,CAAC;;;;IAED,wCAAW;;;IAAX;QACI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;;;;IAEO,uCAAU;;;IAAlB;QACI,wCAAwC;QACxC,IAAI,CAAC,uBAAuB,GAAG,KAAG,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC,qBAAqB,EAAI,CAAC;QACtG,6EAA6E;QAC7E,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE;YAChC,6BAA6B;YAC7B,IAAI,MAAM,CAAC,IAAI,CAAC,2BAA2B,CAAC,KAAK,IAAI,EAAE;gBACnD,IAAI,CAAC,wBAAwB,EAAE,CAAC;aACnC;iBAAM;gBACH,sCAAsC;gBACtC,MAAM,CAAC,IAAI,CAAC,2BAA2B,CAAC,GAAG,IAAI,CAAC;gBAChD,IAAI,CAAC,qBAAqB,EAAE,CAAC;aAChC;SAEJ;aAAM;YACH,wBAAwB;YACxB,IAAI,CAAC,uBAAuB,EAAE,CAAC;SAClC;IACL,CAAC;;;;IAEO,kDAAqB;;;IAA7B;QACI,OAAO,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IAED;;;OAGG;;;;;;IACK,qDAAwB;;;;;IAAhC;QAAA,iBAsBC;;YArBS,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,mBAAmB,CAAC;aACzC,IAAI,CACD,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,UAAC,CAAC;YACF,IAAI,CAAC,IAAI,KAAI,CAAC,mBAAmB,EAAE;gBAC/B,OAAO,CAAC,IAAI,CAAC,yCAAuC,KAAI,CAAC,mBAAmB,4BAAyB,CAAC,CAAC;gBACvG,GAAG,CAAC,WAAW,EAAE,CAAC;gBAClB,OAAO;aACV;YAED,gCAAgC;YAChC,IAAI,MAAM,CAAC,KAAI,CAAC,gBAAgB,CAAC,EAAE;gBAC/B,kBAAkB;gBAClB,KAAI,CAAC,uBAAuB,EAAE,CAAC;gBAE/B,iBAAiB;gBACjB,GAAG,CAAC,WAAW,EAAE,CAAC;aACrB;QACL,CAAC,CAAC,CACL;aACA,SAAS,EAAE;IACpB,CAAC;;;;IAEO,kDAAqB;;;IAA7B;QAAA,iBASC;;YARS,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC;QAC/C,MAAM,CAAC,SAAS,GAAG,EAAE,CAAC;QACtB,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC;QAClC,MAAM,CAAC,MAAM,GAAG,cAAM,OAAA,KAAI,CAAC,uBAAuB,EAAE,EAA9B,CAA8B,CAAC;QACrD,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;QACpB,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;QAEpB,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5D,CAAC;;;;IAEO,oDAAuB;;;IAA/B;QACI,8CAA8C;QAC9C,sFAAsF;QACtF,yDAAyD;QACzD,IAAI,IAAI,CAAC,0BAA0B,IAAI,IAAI,CAAC,0BAA0B,CAAC,aAAa;YAChF,IAAI,CAAC,0BAA0B,CAAC,aAAa,CAAC,EAAE,KAAK,IAAI,CAAC,uBAAuB,EAAE;YACnF,8CAA8C;YAC9C,IAAI,CAAC,WAAW,EAAE,CAAC;SACtB;aAAM;YACH,wDAAwD;YACxD,IAAI,CAAC,wCAAwC,GAAG,IAAI,CAAC;SACxD;IACL,CAAC;;;;IAEO,wCAAW;;;IAAnB;QAAA,iBAqHC;QApHG,wBAAwB;QACxB,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE;YAClC,MAAM,KAAK,CAAC,kEAAgE,IAAI,CAAC,uBAAuB,uBAAoB,CAAC,CAAC;SACjI;QAED,IAAI,CAAC,0BAA0B,CAAC,aAAa,CAAC,SAAS,GAAG,EAAE,CAAC;QAE7D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE;YAChC,MAAM,KAAK,CAAC,gCAAgC,CAAC,CAAC;SACjD;QAED,4CAA4C;QAC5C,4GAA4G;QAC5G,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;;YAExC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE;;YAGvC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;;YAG1B,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE;;YAGxB,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;;YAGzB,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE;;YAG1B,OAAO,EAAE,UAAC,IAAI,EAAE,OAAO;gBACnB,IAAI,KAAI,CAAC,MAAM,CAAC,eAAe,KAAK,qBAAqB,CAAC,cAAc,EAAE;oBACtE,gDAAgD;oBAChD,IAAI,CAAC,KAAI,CAAC,MAAM,CAAC,OAAO,EAAE;wBACtB,MAAM,KAAK,CAAC,wIAC+C,CAAC,CAAC;qBAChE;oBAED,iEAAiE;oBACjE,OAAO,KAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE;yBACnC,IAAI,CAAC,UAAA,SAAS;wBACX,OAAO,SAAS,CAAC;oBACrB,CAAC,CAAC,CAAC;iBACV;gBAED,IAAI,KAAI,CAAC,MAAM,CAAC,eAAe,KAAK,qBAAqB,CAAC,cAAc,EAAE;oBACtE,IAAI,CAAC,KAAI,CAAC,MAAM,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,KAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE;wBAC/G,MAAM,KAAK,CAAC,wEAAwE,CAAC,CAAC;qBACzF;;wBAEK,gBAAgB,GAAG,KAAI,CAAC,MAAM,CAAC,UAAU;oBAC/C,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC;wBAC1B,OAAO,EAAE;;4BAEL,MAAM,EAAE,KAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;4BACxD,YAAY,EAAE,KAAI,CAAC,MAAM,CAAC,YAAY;yBACzC;wBACD,UAAU,EAAE;4BACR,YAAY,EAAE;gCACV,WAAW,EAAE,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;6BACzE;4BACD,YAAY,EAAE;gCACV,UAAU,EAAE,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;gCAChG,UAAU,EAAE,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;gCAChG,WAAW,EAAE,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI;6BACtG;yBACJ;qBACJ,CAAC,CAAC;iBACN;YACL,CAAC;;YAGD,WAAW,EAAE,UAAC,IAAgC,EAAE,OAAY;gBACxD,IAAI,KAAI,CAAC,MAAM,CAAC,eAAe,KAAK,qBAAqB,CAAC,cAAc,EAAE;oBACtE,gDAAgD;oBAChD,IAAI,CAAC,KAAI,CAAC,MAAM,CAAC,WAAW,EAAE;wBAC1B,MAAM,KAAK,CAAC,sEAAsE,CAAC,CAAC;qBACvF;oBAED,yBAAyB;oBACzB,OAAO,KAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;iBAC7D;gBAED,IAAI,KAAI,CAAC,MAAM,CAAC,eAAe,KAAK,qBAAqB,CAAC,cAAc,EAAE;oBACtE,qDAAqD;oBACrD,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC;wBAClC,IAAI,CAAC,KAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE;4BAChC,MAAM,KAAK,CAAC,8FAA8F,CAAC,CAAC;yBAC/G;wBACD,KAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;oBACjD,CAAC,CAAC,CAAC;iBACN;YACL,CAAC;YAED,OAAO,EAAE,UAAC,GAAG;gBACT,IAAI,KAAI,CAAC,MAAM,CAAC,OAAO,EAAE;oBACrB,KAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;iBAC5B;YACL,CAAC;YAED,QAAQ,EAAE,UAAC,IAAI,EAAE,OAAO;gBACpB,IAAI,KAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;oBACtB,KAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;iBACvC;YACL,CAAC;YACD,OAAO,EAAE;gBACL,IAAI,KAAI,CAAC,MAAM,CAAC,OAAO,EAAE;oBACrB,KAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;iBACzB;YACL,CAAC;YACD,QAAQ,EAAE,UAAC,OAAO;gBACd,IAAI,KAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;oBACtB,KAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;iBACjC;YACL,CAAC;SACJ,EAAE,MAAI,IAAI,CAAC,uBAAyB,CAAC,CAAC;IAC3C,CAAC;;;;IAEO,sCAAS;;;IAAjB;QACI,IAAI,IAAI,CAAC,MAAM,CAAC,eAAe,KAAK,qBAAqB,CAAC,cAAc,EAAE;YACtE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;gBACrB,MAAM,KAAK,CAAC,yEAAyE,CAAC,CAAC;aAC1F;YAED,OAAO;gBACH,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU;gBACzC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO;aACtC,CAAC;SACL;QAED,OAAO,SAAS,CAAC;IACrB,CAAC;;;;IAEO,uCAAU;;;IAAlB;QAAA,iBA6BC;QAzBG,6CAA6C;QAC7C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;YACtB,sBAAsB;YACtB,OAAO,SAAS,CAAC;SACpB;;YAEK,OAAO,GAAU,EAAE;;YACnB,UAAU,GAAU,EAAE;QAE5B,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE;YAC7B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,UAAA,IAAI;gBACpC,OAAO,CAAC,IAAI,CAAC,KAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC;SACN;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE;YAChC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,UAAA,IAAI;gBACvC,UAAU,CAAC,IAAI,CAAC,KAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;YAC/C,CAAC,CAAC,CAAC;SACN;QAED,OAAO;YACH,OAAO,EAAE,OAAO;YAChB,UAAU,EAAE,UAAU;SACzB,CAAC;IACN,CAAC;;;;;IAEO,2CAAc;;;;IAAtB,UAAuB,IAAmB;QACtC,IAAI,IAAI,KAAK,aAAa,CAAC,IAAI,EAAE;YAC7B,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;SAC9B;QACD,IAAI,IAAI,KAAK,aAAa,CAAC,MAAM,EAAE;YAC/B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;SAChC;QACD,IAAI,IAAI,KAAK,aAAa,CAAC,GAAG,EAAE;YAC5B,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;SAC7B;QACD,MAAM,KAAK,CAAC,+BAA6B,IAAI,MAAG,CAAC,CAAC;IACtD,CAAC;;gBA/VJ,SAAS,SAAC;oBACP,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,QAAQ,EAAE,YAAY;oBACtB,QAAQ,EAAE,wHAGT;iBACJ;;;;;yBAMI,KAAK;kCAKL,KAAK;mCAKL,SAAS,SAAC,kBAAkB;4CAW5B,SAAS,SAAC,2BAA2B;;IA8T1C,yBAAC;CAAA,AAhWD,IAgWC;SAxVY,kBAAkB;;;;;;IAK3B,oCAA8B;;;;;IAK9B,6CAAiC;;;;;IAKjC,8CAA4D;;;;;IAK5D,sEAAyD;;;;;IAKzD,wDAAgD;;;;;IAUhD,iDAA0C;;;;;IAK1C,iDAA4C;;;;;IAK5C,8CAA6C;;;;;IAK7C,yDAA6E;;;;;IAK7E,6CAAmF;;;;;IAKnF,qDAAwC;;IAExC,2DAAgF;;IAEhF,2CAAoE","sourcesContent":["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"]}