ngx-paypal-with-intent
Version:
Paypal integration for Angular 6, 7 and beyond
495 lines • 55.2 kB
JavaScript
import { ChangeDetectionStrategy, Component, Input, ViewChild, NgModule } from '@angular/core';
import { interval, Subject } from 'rxjs';
import { map, takeUntil } from 'rxjs/operators';
/**
* @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 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
*/
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({
// Allow user to specifify intent, else use default 'sale'.
intent: _this.config.intent ? _this.config.intent : 'sale',
payment: {
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;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var NgxPayPalModule = /** @class */ (function () {
function NgxPayPalModule() {
}
NgxPayPalModule.decorators = [
{ type: 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
*/
/**
* @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
*/
export { NgxPayPalModule, PayPalEnvironment, PayPalFunding, PayPalIntegrationType, PayPalConfig, NgxPaypalComponent, NgxPaypalComponent as ɵa };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-paypal.js.map","sources":["ng://ngx-paypal/lib/models/paypal-funding.ts","ng://ngx-paypal/lib/models/paypal-integration.ts","ng://ngx-paypal/lib/models/paypal-models.ts","ng://ngx-paypal/lib/components/paypal-component.ts","ng://ngx-paypal/lib/ngx-paypal.module.ts","ng://ngx-paypal/lib/models/paypal-environment.ts"],"sourcesContent":["export enum PayPalFunding {\n    Card,\n    Credit,\n    Elv\n}\n","export enum PayPalIntegrationType {\n    ClientSideREST,\n    ServerSideREST,\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            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","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                        // Allow user to specifify intent, else use default 'sale'.\n                        intent: this.config.intent ? this.config.intent : 'sale',\n                        payment: {\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"],"names":[],"mappings":"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"}