@osovitny/anatoly 3.17.67 → 3.17.69

package/esm2022/lib/payments/PayPal/components/paypal.component.mjs

@@ -0,0 +1,317 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny vadim@osovitny.com
+    Anatoly Osovitny anatoly@osovitny.com
+
+  Created:
+    14 Jun 2024
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, } from "@angular/core";
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/paypal-script.service";
+const _c0 = ["payPalButtonContainer"];
+export class PayPalComponent {
+    set payPalButtonContainer(content) {
+        this.payPalButtonContainerElem = content;
+    }
+    constructor(paypalScriptService, cdr, ngZone) {
+        this.paypalScriptService = paypalScriptService;
+        this.cdr = cdr;
+        this.ngZone = ngZone;
+        /**
+         * If enabled, paypal SDK script will be loaded. Useful if you want to have multiple PayPal components on the same page
+         * sharing base configuration. In such a case only a single component may register script.
+         */
+        this.registerScript = true;
+        /**
+         * Emitted when paypal script is loaded
+         */
+        this.scriptLoaded = new EventEmitter();
+        this.ngUnsubscribe = new Subject();
+        /**
+         * Flag that indicates if paypal should be initialized (required for handling script load events and availability of DOM element)
+         */
+        this.initializePayPal = true;
+    }
+    ngOnChanges(changes) {
+        if (!this.payPalButtonContainerId) {
+            this.payPalButtonContainerId = this.generateElementId();
+        }
+        // first time config setup
+        const config = this.config;
+        //const name = 'PayPalConfig';
+        if (changes['config'].isFirstChange()) {
+            if (config && this.registerScript) {
+                this.initPayPalScript(config, (payPal) => {
+                    // store reference to paypal global script
+                    this.payPal = payPal;
+                    this.doPayPalCheck();
+                });
+            }
+        }
+        // changes to config
+        if (!changes['config'].isFirstChange()) {
+            this.reinitialize(config);
+        }
+    }
+    ngOnDestroy() {
+        this.paypalScriptService.destroyPayPalScript();
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    ngAfterViewInit() {
+        this.doPayPalCheck();
+    }
+    customInit(payPal) {
+        this.payPal = payPal;
+        this.doPayPalCheck();
+    }
+    reinitialize(config) {
+        this.config = config;
+        this.payPal = undefined;
+        this.paypalScriptService.destroyPayPalScript();
+        this.payPalButtonContainerId = this.generateElementId();
+        this.initializePayPal = true;
+        if (this.payPalButtonContainerElem) {
+            try {
+                while (this.payPalButtonContainerElem.nativeElement.firstChild) {
+                    this.payPalButtonContainerElem.nativeElement.removeChild(this.payPalButtonContainerElem.nativeElement.firstChild);
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+        this.cdr.detectChanges();
+        if (this.config) {
+            if (!this.payPal) {
+                this.initPayPalScript(this.config, (payPal) => {
+                    // store reference to paypal global script
+                    this.payPal = payPal;
+                    this.doPayPalCheck();
+                });
+            }
+            else {
+                this.doPayPalCheck();
+            }
+        }
+    }
+    doPayPalCheck() {
+        if (this.initializePayPal &&
+            this.config &&
+            this.payPal &&
+            this.payPalButtonContainerElem) {
+            // make sure that id is also set
+            if (this.payPalButtonContainerElem.nativeElement.id) {
+                this.initializePayPal = false;
+                this.initPayPal(this.config, this.payPal);
+            }
+        }
+    }
+    initPayPalScript(config, initPayPal) {
+        this.paypalScriptService.registerPayPalScript({
+            clientId: config.clientId,
+            locale: config.advanced?.locale,
+            commit: config.advanced && config.advanced.commit
+                ? config.advanced.commit
+                : undefined,
+            currency: config.currency,
+            vault: config.vault,
+            intent: config.intent,
+            funding: config.fundingSource != undefined || config.fundingSource != null ? true : false,
+            extraParams: config.advanced && config.advanced.extraQueryParams
+                ? config.advanced.extraQueryParams
+                : [],
+        }, (paypal) => {
+            this.scriptLoaded.next(paypal);
+            initPayPal(paypal);
+        });
+    }
+    generateElementId() {
+        return `ngx-captcha-id-${this.generateGuid()}`;
+    }
+    initPayPal(config, paypal) {
+        // Running outside angular zone prevents infinite ngDoCheck lifecycle calls
+        this.ngZone.runOutsideAngular(() => {
+            // https://developer.paypal.com/docs/checkout/integrate/#2-add-the-paypal-script-to-your-web-page
+            const createOrder = (data, actions) => {
+                return this.ngZone.run(() => {
+                    if (config.createOrderOnClient && config.createOrderOnServer) {
+                        throw Error(`Both 'createOrderOnClient' and 'createOrderOnServer' are defined.
+                    Please choose one or the other.`);
+                    }
+                    if (!config.createOrderOnClient && !config.createOrderOnServer) {
+                        throw Error(`Neither 'createOrderOnClient' or 'createOrderOnServer' are defined.
+                    Please define one of these to create order.`);
+                    }
+                    if (config.createOrderOnClient) {
+                        return actions.order.create(config.createOrderOnClient(data));
+                    }
+                    if (config.createOrderOnServer) {
+                        return config.createOrderOnServer(data);
+                    }
+                    throw Error(`Invalid state for 'createOrder'.`);
+                });
+            };
+            const createSubscription = (data, actions) => {
+                return this.ngZone.run(() => {
+                    if (config.createSubscriptionOnClient) {
+                        return actions.subscription.create(config.createSubscriptionOnClient(data));
+                    }
+                    return;
+                });
+            };
+            const onShippingChange = (data, actions) => {
+                return this.ngZone.run(() => {
+                    if (config.onShippingChange) {
+                        return config.onShippingChange(data, actions);
+                    }
+                });
+            };
+            const buttonsConfig = {
+                style: config.style,
+                fundingSource: undefined,
+                onApprove: (data, actions) => {
+                    return this.ngZone.run(() => {
+                        if (config.onApprove) {
+                            config.onApprove(data, actions);
+                        }
+                        // capture on server
+                        if (config.authorizeOnServer) {
+                            return config.authorizeOnServer(data, actions);
+                        }
+                        // capture on client
+                        const onClientAuthorization = config.onClientAuthorization;
+                        if (onClientAuthorization) {
+                            actions.order
+                                .capture()
+                                .then((details) => {
+                                this.ngZone.run(() => {
+                                    onClientAuthorization(details);
+                                });
+                            });
+                        }
+                    });
+                },
+                onError: (error) => {
+                    this.ngZone.run(() => {
+                        if (config.onError) {
+                            config.onError(error);
+                        }
+                    });
+                },
+                onCancel: (data, actions) => {
+                    this.ngZone.run(() => {
+                        if (config.onCancel) {
+                            config.onCancel(data, actions);
+                        }
+                    });
+                },
+                onClick: (data, actions) => {
+                    this.ngZone.run(() => {
+                        if (config.onClick) {
+                            config.onClick(data, actions);
+                        }
+                    });
+                },
+                onInit: (data, actions) => {
+                    this.ngZone.run(() => {
+                        if (config.onInit) {
+                            config.onInit(data, actions);
+                        }
+                    });
+                },
+                // Add the functions if they've been created in the config object
+                // The API only allows one of the two to be set
+                ...((config.createOrderOnClient || config.createOrderOnServer) && {
+                    createOrder,
+                }),
+                ...(config.createSubscriptionOnClient && { createSubscription }),
+                // The onShippingChange callback cannot be used with subscriptions
+                // so we only add it if it is set
+                ...(config.onShippingChange && { onShippingChange }),
+            };
+            let fundSource = undefined;
+            switch (config.fundingSource) {
+                case "PAYPAL":
+                    fundSource = paypal.FUNDING.PAYPAL;
+                    break;
+                case "CARD":
+                    fundSource = paypal.FUNDING.CARD;
+                    break;
+                case "PAYLATER":
+                    fundSource = paypal.FUNDING.PAYLATER;
+                    break;
+                case "CREDIT":
+                    fundSource = paypal.FUNDING.CREDIT;
+                    break;
+                case "VENMO":
+                    fundSource = paypal.FUNDING.VENMO;
+                    break;
+                default:
+                    break;
+            }
+            if (fundSource != undefined) {
+                buttonsConfig.fundingSource = fundSource;
+                if (config.fundingSource !== "PAYPAL")
+                    delete buttonsConfig.style?.color;
+            }
+            paypal.Buttons(buttonsConfig).render(`#${this.payPalButtonContainerId}`);
+        });
+    }
+    generateGuid() {
+        let d = new Date().getTime(), d2 = (performance && performance.now && performance.now() * 1000) || 0;
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            let r = Math.random() * 16;
+            if (d > 0) {
+                r = (d + r) % 16 | 0;
+                d = Math.floor(d / 16);
+            }
+            else {
+                r = (d2 + r) % 16 | 0;
+                d2 = Math.floor(d2 / 16);
+            }
+            return (c == "x" ? r : (r & 0x7) | 0x8).toString(16);
+        });
+    }
+    static { this.ɵfac = function PayPalComponent_Factory(t) { return new (t || PayPalComponent)(i0.ɵɵdirectiveInject(i1.PayPalScriptService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.NgZone)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PayPalComponent, selectors: [["anatoly-paypal"]], viewQuery: function PayPalComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.payPalButtonContainer = _t.first);
+        } }, inputs: { config: "config", registerScript: "registerScript" }, outputs: { scriptLoaded: "scriptLoaded" }, features: [i0.ɵɵNgOnChangesFeature], decls: 2, vars: 1, consts: [[3, "id"], ["payPalButtonContainer", ""]], template: function PayPalComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "div", 0, 1);
+        } if (rf & 2) {
+            i0.ɵɵproperty("id", ctx.payPalButtonContainerId);
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PayPalComponent, [{
+        type: Component,
+        args: [{
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                selector: "anatoly-paypal",
+                template: `
+    <div #payPalButtonContainer [id]="payPalButtonContainerId"></div>
+  `,
+            }]
+    }], () => [{ type: i1.PayPalScriptService }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }], { config: [{
+            type: Input
+        }], registerScript: [{
+            type: Input
+        }], scriptLoaded: [{
+            type: Output
+        }], payPalButtonContainer: [{
+            type: ViewChild,
+            args: ["payPalButtonContainer", { static: false }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PayPalComponent, { className: "PayPalComponent", filePath: "lib\\payments\\PayPal\\components\\paypal.component.ts", lineNumber: 58 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paypal.component.js","sourceRoot":"","sources":["../../../../../../../projects/anatoly/src/lib/payments/PayPal/components/paypal.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n<file>\r\n  Project:\r\n    @osovitny/anatoly\r\n\r\n  Authors:\r\n    Vadim Osovitny vadim@osovitny.com\r\n    Anatoly Osovitny anatoly@osovitny.com\r\n\r\n  Created:\r\n    14 Jun 2024\r\n\r\n  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.\r\n</file>\r\n*/\r\n\r\nimport {\r\n  AfterViewInit,\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Input,\r\n  NgZone,\r\n  OnChanges,\r\n  OnDestroy,\r\n  Output,\r\n  SimpleChanges,\r\n  ViewChild,\r\n} from \"@angular/core\";\r\nimport { Subject } from \"rxjs\";\r\n\r\nimport {\r\n  ICancelCallbackData,\r\n  IClientAuthorizeCallbackData,\r\n  ICreateOrderCallbackActions,\r\n  IInitCallbackData,\r\n  IOnApproveCallbackActions,\r\n  IOnApproveCallbackData,\r\n  IOnClickCallbackActions,\r\n  IOnInitCallbackActions,\r\n  IOnShippingChangeActions,\r\n  IOnShippingChangeData,\r\n  IPayPalConfig,\r\n  ICreateSubscriptionCallbackActions,\r\n  ICreateSubscriptionCallbackData,\r\n} from \"../models/paypal-models\";\r\nimport { PayPalScriptService } from \"../services/paypal-script.service\";\r\n\r\n@Component({\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  selector: \"anatoly-paypal\",\r\n  template: `\r\n    <div #payPalButtonContainer [id]=\"payPalButtonContainerId\"></div>\r\n  `,\r\n})\r\nexport class PayPalComponent implements OnChanges, OnDestroy, AfterViewInit {\r\n  /**\r\n   * Configuration for paypal.\r\n   */\r\n  @Input() config?: IPayPalConfig;\r\n\r\n  /**\r\n   * If enabled, paypal SDK script will be loaded. Useful if you want to have multiple PayPal components on the same page\r\n   * sharing base configuration. In such a case only a single component may register script.\r\n   */\r\n  @Input() registerScript: boolean = true;\r\n\r\n  /**\r\n   * Emitted when paypal script is loaded\r\n   */\r\n  @Output() scriptLoaded = new EventEmitter<any>();\r\n\r\n  /**\r\n   * Id of the element where PayPal button will be rendered\r\n   */\r\n  public payPalButtonContainerId?: string;\r\n\r\n  private readonly ngUnsubscribe: Subject<void> = new Subject<void>();\r\n\r\n  private payPalButtonContainerElem?: ElementRef;\r\n  @ViewChild(\"payPalButtonContainer\", { static: false })\r\n  set payPalButtonContainer(content: ElementRef) {\r\n    this.payPalButtonContainerElem = content;\r\n  }\r\n\r\n  /**\r\n   * Flag that indicates if paypal should be initialized (required for handling script load events and availability of DOM element)\r\n   */\r\n  private initializePayPal: boolean = true;\r\n\r\n  /**\r\n   * Reference to PayPal global API\r\n   */\r\n  private payPal: any;\r\n\r\n  constructor(\r\n    private paypalScriptService: PayPalScriptService,\r\n    private cdr: ChangeDetectorRef,\r\n    private ngZone: NgZone) {\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (!this.payPalButtonContainerId) {\r\n      this.payPalButtonContainerId = this.generateElementId();\r\n    }\r\n\r\n    // first time config setup\r\n    const config = this.config;\r\n    //const name = 'PayPalConfig';\r\n\r\n    if (changes['config'].isFirstChange()) {\r\n      if (config && this.registerScript) {\r\n        this.initPayPalScript(config, (payPal) => {\r\n          // store reference to paypal global script\r\n          this.payPal = payPal;\r\n          this.doPayPalCheck();\r\n        });\r\n      }\r\n    }\r\n\r\n    // changes to config\r\n    if (!changes['config'].isFirstChange()) {\r\n      this.reinitialize(config);\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.paypalScriptService.destroyPayPalScript();\r\n    this.ngUnsubscribe.next();\r\n    this.ngUnsubscribe.complete();\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.doPayPalCheck();\r\n  }\r\n\r\n  customInit(payPal: any): void {\r\n    this.payPal = payPal;\r\n    this.doPayPalCheck();\r\n  }\r\n\r\n  reinitialize(config: IPayPalConfig | undefined): void {\r\n    this.config = config;\r\n    this.payPal = undefined;\r\n    this.paypalScriptService.destroyPayPalScript();\r\n    this.payPalButtonContainerId = this.generateElementId();\r\n    this.initializePayPal = true;\r\n\r\n    if (this.payPalButtonContainerElem) {\r\n      try {\r\n        while (this.payPalButtonContainerElem.nativeElement.firstChild) {\r\n          this.payPalButtonContainerElem.nativeElement.removeChild(\r\n            this.payPalButtonContainerElem.nativeElement.firstChild\r\n          );\r\n        }\r\n      } catch (error) {\r\n        console.error(error);\r\n      }\r\n    }\r\n\r\n    this.cdr.detectChanges();\r\n\r\n    if (this.config) {\r\n      if (!this.payPal) {\r\n        this.initPayPalScript(this.config, (payPal) => {\r\n          // store reference to paypal global script\r\n          this.payPal = payPal;\r\n          this.doPayPalCheck();\r\n        });\r\n      } else {\r\n        this.doPayPalCheck();\r\n      }\r\n    }\r\n  }\r\n\r\n  private doPayPalCheck(): void {\r\n    if (\r\n      this.initializePayPal &&\r\n      this.config &&\r\n      this.payPal &&\r\n      this.payPalButtonContainerElem\r\n    ) {\r\n      // make sure that id is also set\r\n      if (this.payPalButtonContainerElem.nativeElement.id) {\r\n        this.initializePayPal = false;\r\n        this.initPayPal(this.config, this.payPal);\r\n      }\r\n    }\r\n  }\r\n\r\n  private initPayPalScript(\r\n    config: IPayPalConfig,\r\n    initPayPal: (paypal: any) => void\r\n  ): void {\r\n    this.paypalScriptService.registerPayPalScript(\r\n      {\r\n        clientId: config.clientId,\r\n        locale: config.advanced?.locale,\r\n        commit:\r\n          config.advanced && config.advanced.commit\r\n            ? config.advanced.commit\r\n            : undefined,\r\n        currency: config.currency,\r\n        vault: config.vault,\r\n        intent: config.intent,\r\n        funding: config.fundingSource != undefined || config.fundingSource != null ? true : false,\r\n        extraParams:\r\n          config.advanced && config.advanced.extraQueryParams\r\n            ? config.advanced.extraQueryParams\r\n            : [],\r\n      },\r\n      (paypal) => {\r\n        this.scriptLoaded.next(paypal);\r\n        initPayPal(paypal);\r\n      }\r\n    );\r\n  }\r\n\r\n  private generateElementId(): string {\r\n    return `ngx-captcha-id-${this.generateGuid()}`;\r\n  }\r\n\r\n  private initPayPal(config: IPayPalConfig, paypal: any): void {\r\n    // Running outside angular zone prevents infinite ngDoCheck lifecycle calls\r\n    this.ngZone.runOutsideAngular(() => {\r\n      // https://developer.paypal.com/docs/checkout/integrate/#2-add-the-paypal-script-to-your-web-page\r\n      const createOrder = (data: any, actions: ICreateOrderCallbackActions) => {\r\n        return this.ngZone.run(() => {\r\n          if (config.createOrderOnClient && config.createOrderOnServer) {\r\n            throw Error(`Both 'createOrderOnClient' and 'createOrderOnServer' are defined.\r\n                    Please choose one or the other.`);\r\n          }\r\n\r\n          if (!config.createOrderOnClient && !config.createOrderOnServer) {\r\n            throw Error(`Neither 'createOrderOnClient' or 'createOrderOnServer' are defined.\r\n                    Please define one of these to create order.`);\r\n          }\r\n\r\n          if (config.createOrderOnClient) {\r\n            return actions.order.create(config.createOrderOnClient(data));\r\n          }\r\n\r\n          if (config.createOrderOnServer) {\r\n            return config.createOrderOnServer(data);\r\n          }\r\n\r\n          throw Error(`Invalid state for 'createOrder'.`);\r\n        });\r\n      };\r\n      const createSubscription = (\r\n        data: ICreateSubscriptionCallbackData,\r\n        actions: ICreateSubscriptionCallbackActions\r\n      ) => {\r\n        return this.ngZone.run(() => {\r\n          if (config.createSubscriptionOnClient) {\r\n            return actions.subscription.create(\r\n              config.createSubscriptionOnClient(data)\r\n            );\r\n          }\r\n          return;\r\n        });\r\n      };\r\n      const onShippingChange = (\r\n        data: IOnShippingChangeData,\r\n        actions: IOnShippingChangeActions\r\n      ) => {\r\n        return this.ngZone.run(() => {\r\n          if (config.onShippingChange) {\r\n            return config.onShippingChange(data, actions);\r\n          }\r\n        });\r\n      };\r\n\r\n      const buttonsConfig = {\r\n        style: config.style,\r\n        fundingSource: undefined,\r\n        onApprove: (\r\n          data: IOnApproveCallbackData,\r\n          actions: IOnApproveCallbackActions\r\n        ) => {\r\n          return this.ngZone.run(() => {\r\n            if (config.onApprove) {\r\n              config.onApprove(data, actions);\r\n            }\r\n\r\n            // capture on server\r\n            if (config.authorizeOnServer) {\r\n              return config.authorizeOnServer(data, actions);\r\n            }\r\n\r\n            // capture on client\r\n            const onClientAuthorization = config.onClientAuthorization;\r\n            if (onClientAuthorization) {\r\n              actions.order\r\n                .capture()\r\n                .then((details: IClientAuthorizeCallbackData) => {\r\n                  this.ngZone.run(() => {\r\n                    onClientAuthorization(details);\r\n                  });\r\n                });\r\n            }\r\n          });\r\n        },\r\n        onError: (error: any) => {\r\n          this.ngZone.run(() => {\r\n            if (config.onError) {\r\n              config.onError(error);\r\n            }\r\n          });\r\n        },\r\n        onCancel: (data: ICancelCallbackData, actions: any) => {\r\n          this.ngZone.run(() => {\r\n            if (config.onCancel) {\r\n              config.onCancel(data, actions);\r\n            }\r\n          });\r\n        },\r\n        onClick: (data: any, actions: IOnClickCallbackActions) => {\r\n          this.ngZone.run(() => {\r\n            if (config.onClick) {\r\n              config.onClick(data, actions);\r\n            }\r\n          });\r\n        },\r\n        onInit: (data: IInitCallbackData, actions: IOnInitCallbackActions) => {\r\n          this.ngZone.run(() => {\r\n            if (config.onInit) {\r\n              config.onInit(data, actions);\r\n            }\r\n          });\r\n        },\r\n        // Add the functions if they've been created in the config object\r\n        // The API only allows one of the two to be set\r\n        ...((config.createOrderOnClient || config.createOrderOnServer) && {\r\n          createOrder,\r\n        }),\r\n        ...(config.createSubscriptionOnClient && { createSubscription }),\r\n        // The onShippingChange callback cannot be used with subscriptions\r\n        // so we only add it if it is set\r\n        ...(config.onShippingChange && { onShippingChange }),\r\n      };\r\n\r\n      let fundSource = undefined;\r\n      switch(config.fundingSource){\r\n        case \"PAYPAL\":\r\n          fundSource = paypal.FUNDING.PAYPAL;\r\n          break;\r\n        case \"CARD\":\r\n          fundSource = paypal.FUNDING.CARD;\r\n          break;\r\n        case \"PAYLATER\":\r\n          fundSource = paypal.FUNDING.PAYLATER;\r\n          break;\r\n        case \"CREDIT\":\r\n          fundSource = paypal.FUNDING.CREDIT;\r\n          break;\r\n        case \"VENMO\":\r\n          fundSource = paypal.FUNDING.VENMO;\r\n          break;\r\n        default:\r\n          break;\r\n      }\r\n      if(fundSource != undefined)\r\n      {\r\n        buttonsConfig.fundingSource = fundSource;\r\n        if(config.fundingSource !== \"PAYPAL\")\r\n          delete buttonsConfig.style?.color\r\n      }\r\n      paypal.Buttons(buttonsConfig).render(`#${this.payPalButtonContainerId}`);\r\n    });\r\n  }\r\n\r\n  private generateGuid(): string {\r\n    let d = new Date().getTime(),\r\n      d2 = (performance && performance.now && performance.now() * 1000) || 0;\r\n    return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, (c) => {\r\n      let r = Math.random() * 16;\r\n      if (d > 0) {\r\n        r = (d + r) % 16 | 0;\r\n        d = Math.floor(d / 16);\r\n      } else {\r\n        r = (d2 + r) % 16 | 0;\r\n        d2 = Math.floor(d2 / 16);\r\n      }\r\n      return (c == \"x\" ? r : (r & 0x7) | 0x8).toString(16);\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/payments/PayPal/models/paypal-models.mjs

@@ -0,0 +1,17 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny vadim@osovitny.com
+    Anatoly Osovitny anatoly@osovitny.com
+
+  Created:
+    14 Jun 2024
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paypal-models.js","sourceRoot":"","sources":["../../../../../../../projects/anatoly/src/lib/payments/PayPal/models/paypal-models.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;EAcE","sourcesContent":["/*\r\n<file>\r\n  Project:\r\n    @osovitny/anatoly\r\n\r\n  Authors:\r\n    Vadim Osovitny vadim@osovitny.com\r\n    Anatoly Osovitny anatoly@osovitny.com\r\n\r\n  Created:\r\n    14 Jun 2024\r\n\r\n  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.\r\n</file>\r\n*/\r\n\r\nexport interface IPayPalConfig {\r\n  /**\r\n   * Currency - Defaults to USD if not provided\r\n   */\r\n  currency?: string;\r\n\r\n  /**\r\n   * Use when creating order on client\r\n   */\r\n  createOrderOnClient?: (data: any) => ICreateOrderRequest;\r\n\r\n  /**\r\n   * Use when creating subscription on client\r\n   */\r\n  createSubscriptionOnClient?: (data: any) => ICreateSubscriptionRequest;\r\n\r\n  /**\r\n   * Use for creating orders on server. PayPal expects you to return 'orderId' in this method\r\n   */\r\n  createOrderOnServer?: (data: any) => Promise<string>;\r\n\r\n  /**\r\n   * Advanced configuration\r\n   */\r\n  advanced?: IAdvancedConfiguration;\r\n\r\n  /**\r\n   * Client id\r\n   */\r\n  clientId: string;\r\n\r\n  /**\r\n   * Shipping callback\r\n   * see https://developer.paypal.com/docs/checkout/integration-features/shipping-callback/\r\n   */\r\n  onShippingChange?: OnShippingChangeCallback;\r\n\r\n  /**\r\n   * Called when 'onApprove' event occurs\r\n   */\r\n  onApprove?: (data: IOnApproveCallbackData, actions: any) => void;\r\n\r\n  /**\r\n   * Called when authorization on client succeeds\r\n   */\r\n  onClientAuthorization?: (authorization: IClientAuthorizeCallbackData) => void;\r\n\r\n  /**\r\n   * Implement for authorizing on server side\r\n   */\r\n  authorizeOnServer?: (\r\n    data: IOnApproveCallbackData,\r\n    actions: any\r\n  ) => Promise<any>;\r\n\r\n  /**\r\n   * Button style configuration\r\n   */\r\n  style?: IPayPalButtonStyle;\r\n\r\n  /**\r\n   * Error handler\r\n   */\r\n  onError?: (err: any) => void;\r\n\r\n  /**\r\n   * Click handler\r\n   */\r\n  onClick?: (data: any, actions: IOnClickCallbackActions) => void;\r\n\r\n  /**\r\n   * Cancel handler\r\n   */\r\n  onCancel?: (data: ICancelCallbackData, actions: any) => void;\r\n\r\n  /**\r\n   * Init handler.\r\n   * can be used for validation, see: https://developer.paypal.com/docs/checkout/integration-features/validation/#\r\n   */\r\n  onInit?: (data: IInitCallbackData, actions: IOnInitCallbackActions) => void;\r\n\r\n  /**\r\n   * Create subscription handler\r\n   * https://developer.paypal.com/docs/subscriptions/integrate/\r\n   *\r\n   * Note: the vault property in the advanced configuration also has to be set to true\r\n   */\r\n  createSubscription?: (data: any) => ICreateSubscriptionRequest;\r\n\r\n  /**\r\n   * Vault - must be set to true when creating subscriptions\r\n   */\r\n  vault?: TrueFalse;\r\n  intent?: OrderIntent;\r\n\r\n  /*\r\n    Select type of funding source, use it when you need set type of button you want to see, see: https://developer.paypal.com/docs/checkout/standard/customize/standalone-buttons/\r\n  */\r\n  fundingSource?: \"PAYPAL\" | \"CARD\" | \"PAYLATER\" | \"CREDIT\" | \"VENMO\";\r\n}\r\n\r\nexport type TrueFalse = \"true\" | \"false\";\r\n\r\nexport interface IPayPalUrlConfig {\r\n  clientId: string;\r\n  currency?: string;\r\n  funding?: boolean;\r\n  commit?: TrueFalse;\r\n  vault?: TrueFalse;\r\n  intent?: OrderIntent;\r\n  locale?: string;\r\n  extraParams?: IQueryParam[];\r\n}\r\n\r\nexport interface IOrderDetails {\r\n  create_time: string;\r\n  update_time: string;\r\n  id: string;\r\n  intent: OrderIntent;\r\n  payer: IPayer;\r\n  status: OrderStatus;\r\n  links: ILinkDescription[];\r\n  purchase_units: IPurchaseUnit[];\r\n}\r\n\r\nexport interface IClientAuthorizeCallbackData extends IOrderDetails {\r\n  links: ILinkDescription[];\r\n}\r\n\r\nexport interface ILinkDescription {\r\n  href: string;\r\n  rel: String;\r\n  method?: LinkMethod;\r\n}\r\n\r\nexport interface IQueryParam {\r\n  name: string;\r\n  value: string;\r\n}\r\n\r\nexport type OnShippingChangeCallback = (\r\n  data: IOnShippingChangeData,\r\n  actions: IOnShippingChangeActions\r\n) => any;\r\n\r\nexport interface IOnShippingChangeData {\r\n  paymentToken: string;\r\n  shipping_address: any;\r\n  selected_shipping_method?: any;\r\n}\r\n\r\nexport interface IOnShippingChangeActions {\r\n  resolve: () => any;\r\n  reject: () => any;\r\n  patch: () => any;\r\n}\r\n\r\nexport type LinkMethod =\r\n  | \"GET\"\r\n  | \"POST\"\r\n  | \"PUT\"\r\n  | \"DELETE\"\r\n  | \"HEAD\"\r\n  | \"CONNECT\"\r\n  | \"OPTIONS\"\r\n  | \"PATCH\";\r\n\r\nexport interface IAdvancedConfiguration {\r\n  commit?: TrueFalse;\r\n  locale?: string;\r\n  extraQueryParams?: IQueryParam[];\r\n}\r\n\r\nexport interface IOnApproveCallbackData {\r\n  orderID: string;\r\n  payerID: string;\r\n  subscriptionID: string;\r\n}\r\n\r\nexport interface ICreateOrderCallbackActions {\r\n  order: {\r\n    create: (order: ICreateOrderRequest) => Promise<any>;\r\n  };\r\n}\r\n\r\nexport interface ICancelCallbackData {\r\n  orderID: string;\r\n}\r\n\r\nexport interface IOnApproveCallbackActions {\r\n  redirect: () => void;\r\n  restart: () => void;\r\n  order: {\r\n    authorize: () => Promise<any>;\r\n    capture: () => Promise<any>;\r\n    get: () => Promise<IOrderDetails>;\r\n    patch: () => Promise<any>;\r\n  };\r\n}\r\n\r\nexport interface IOnInitCallbackActions {\r\n  enable: () => void;\r\n  disable: () => void;\r\n}\r\n\r\nexport interface ICreateSubscriptionCallbackActions {\r\n  subscription: {\r\n    create: (subscription: ICreateSubscriptionRequest) => Promise<any>;\r\n    revise: (\r\n      subscriptionId: string,\r\n      subscription: ICreateSubscriptionRequest\r\n    ) => Promise<any>;\r\n  };\r\n}\r\n\r\n// tslint:disable-next-line:no-empty-interface\r\nexport interface IInitCallbackData {}\r\n\r\n// tslint:disable-next-line:no-empty-interface\r\nexport interface ICreateSubscriptionCallbackData {}\r\n\r\nexport interface IOnClickCallbackActions {\r\n  resolve: () => void;\r\n  reject: () => void;\r\n}\r\n\r\nexport interface IPayPalButtonStyle {\r\n  label?:\r\n    | \"paypal\"\r\n    | \"checkout\"\r\n    | \"pay\"\r\n    | \"installment\"\r\n    | \"buynow\"\r\n    | \"subscribe\";\r\n  shape?: \"pill\" | \"rect\";\r\n  color?: \"gold\" | \"blue\" | \"silver\" | \"white\" | \"black\";\r\n  layout?: \"horizontal\" | \"vertical\";\r\n  tagline?: boolean;\r\n  height?: number;\r\n  fundingicons?: boolean;\r\n}\r\n\r\nexport interface ICreateOrderRequest {\r\n  intent: OrderIntent;\r\n  purchase_units: IPurchaseUnit[];\r\n\r\n  payer?: IPayer;\r\n  application_context?: IApplicationContext;\r\n}\r\n\r\nexport interface ICreateSubscriptionRequest {\r\n  plan_id: string;\r\n  quantity?: number;\r\n  custom_id: string;\r\n}\r\n\r\nexport interface IPayer {\r\n  name?: IPartyName;\r\n  email_address?: string;\r\n  payer_id?: string;\r\n  birth_date?: string;\r\n  tax_info?: ITaxInfo;\r\n  address?: IAddressPortable;\r\n  phone?: IPhone;\r\n}\r\n\r\nexport interface IApplicationContext {\r\n  brand_name?: string;\r\n  locale?: string;\r\n  landing_page?: PaypalLandingPage;\r\n  shipping_preference?: ShippingPreference;\r\n  user_action?: PayPalUserAction;\r\n  payment_method?: IPaymentMethod;\r\n  return_url?: string;\r\n  cancel_url?: string;\r\n}\r\n\r\nexport interface IPaymentMethod {\r\n  payer_selected?: PayerSelected;\r\n  payee_preferred?: PayeePreferred;\r\n}\r\n\r\nexport type PayeePreferred = \"UNRESTRICTED\" | \"IMMEDIATE_PAYMENT_REQUIRED\";\r\n\r\nexport type PayerSelected = \"PAYPAL_CREDIT\" | \"PAYPAL\";\r\n\r\nexport type PayPalUserAction = \"CONTINUE\" | \"PAY_NOW\";\r\n\r\nexport type ShippingPreference =\r\n  | \"GET_FROM_FILE\"\r\n  | \"NO_SHIPPING\"\r\n  | \"SET_PROVIDED_ADDRESS\";\r\n\r\nexport type PaypalLandingPage = \"LOGIN\" | \"BILLING\";\r\n\r\nexport type OrderIntent = \"CAPTURE\" | \"AUTHORIZE\" | \"subscription\";\r\n\r\nexport type DisbursementMode = \"INSTANT\" | \"DELAYED\";\r\n\r\nexport type ItemCategory = \"DIGITAL_GOODS\" | \"PHYSICAL_GOODS\";\r\n\r\nexport type PhoneType = \"FAX\" | \"HOME\" | \"MOBILE\" | \"OTHER\" | \"PAGER\";\r\n\r\nexport type TaxIdType = \"BR_CPF\" | \"BR_CNPJ\";\r\n\r\nexport interface IPhone {\r\n  phone_type?: PhoneType;\r\n  phone_number?: IPhoneNumber;\r\n}\r\n\r\nexport interface ITaxInfo {\r\n  tax_id: string;\r\n  tax_id_type: TaxIdType;\r\n}\r\n\r\nexport interface IPhoneNumber {\r\n  national_number: string;\r\n}\r\n\r\nexport interface IPurchaseUnit {\r\n  amount: IUnitAmount;\r\n\r\n  reference_id?: string;\r\n  payee?: IPayee;\r\n  payment_instruction?: IPaymentInstructions;\r\n  description?: string;\r\n  custom_id?: string;\r\n  invoice_id?: string;\r\n  soft_descriptor?: string;\r\n  items: ITransactionItem[];\r\n  shipping?: IShipping;\r\n}\r\n\r\nexport interface IPayee {\r\n  email_address?: string;\r\n  merchant_id?: string;\r\n}\r\n\r\nexport interface IPaymentInstructions {\r\n  platform_fees?: IPlatformFee[];\r\n  disbursement_mode?: DisbursementMode;\r\n}\r\n\r\nexport interface IPlatformFee {\r\n  amount: IUnitAmount;\r\n  payee?: IPayee;\r\n}\r\n\r\nexport interface ITransactionItem {\r\n  name: string;\r\n  unit_amount: IUnitAmount;\r\n  quantity: string;\r\n\r\n  description?: string;\r\n  sku?: string;\r\n  category?: ItemCategory;\r\n  tax?: ITax;\r\n}\r\n\r\nexport interface ITax {\r\n  currency_code: string;\r\n  value: string;\r\n}\r\n\r\nexport interface IUnitAmount {\r\n  currency_code: string;\r\n  value: string;\r\n  breakdown?: IUnitBreakdown;\r\n}\r\n\r\nexport interface IMoney {\r\n  currency_code: string;\r\n  value: string;\r\n}\r\n\r\nexport interface IUnitBreakdown {\r\n  item_total?: IUnitAmount;\r\n  shipping?: IUnitAmount;\r\n  handling?: IUnitAmount;\r\n  tax_total?: IUnitAmount;\r\n  insurance?: IUnitAmount;\r\n  shipping_discount?: IUnitAmount;\r\n  discount?: IMoney;\r\n}\r\n\r\nexport interface IPartyName {\r\n  prefix?: string;\r\n  given_name?: string;\r\n  surname?: string;\r\n  middle_name?: string;\r\n  suffix?: string;\r\n  alternate_full_name?: string;\r\n  full_name?: string;\r\n}\r\n\r\nexport interface IAddressPortable {\r\n  country_code: string;\r\n\r\n  address_line_1?: string;\r\n  address_line_2?: string;\r\n  admin_area_2?: string;\r\n  admin_area_1?: string;\r\n  postal_code?: string;\r\n}\r\n\r\nexport interface IShipping {\r\n  name?: IPartyName;\r\n  address?: IAddressPortable;\r\n}\r\n\r\nexport type OrderStatus =\r\n  | \"APPROVED\"\r\n  | \"SAVED\"\r\n  | \"CREATED\"\r\n  | \"VOIDED\"\r\n  | \"COMPLETED\";\r\n"]}

package/esm2022/lib/payments/PayPal/services/paypal-script.service.mjs

@@ -0,0 +1,98 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny vadim@osovitny.com
+    Anatoly Osovitny anatoly@osovitny.com
+
+  Created:
+    14 Jun 2024
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/script.service";
+export class PayPalScriptService {
+    constructor(scriptService) {
+        this.scriptService = scriptService;
+        this.paypalWindowName = 'paypal';
+    }
+    registerPayPalScript(config, onReady) {
+        this.scriptService.registerScript(this.getUrlForConfig(config), this.paypalWindowName, onReady);
+    }
+    destroyPayPalScript() {
+        this.scriptService.cleanup(this.paypalWindowName);
+    }
+    getUrlForConfig(config) {
+        const params = [
+            {
+                name: 'client-id',
+                value: config.clientId
+            }
+        ];
+        if (config.locale) {
+            params.push({
+                name: 'locale',
+                value: config.locale
+            });
+        }
+        if (config.currency) {
+            params.push({
+                name: 'currency',
+                value: config.currency
+            });
+        }
+        if (config.commit) {
+            params.push({
+                name: 'commit',
+                value: config.commit
+            });
+        }
+        if (config.vault) {
+            params.push({
+                name: 'vault',
+                value: config.vault
+            });
+        }
+        if (config.intent) {
+            params.push({
+                name: 'intent',
+                value: config.intent
+            });
+        }
+        if (config.funding) {
+            params.push({
+                name: 'components',
+                value: 'buttons,funding-eligibility'
+            });
+        }
+        if (config.extraParams) {
+            params.push(...config.extraParams);
+        }
+        return `https://www.paypal.com/sdk/js${this.getQueryString(params)}`;
+    }
+    getQueryString(queryParams) {
+        let queryString = '';
+        for (let i = 0; i < queryParams.length; i++) {
+            const queryParam = queryParams[i];
+            if (i === 0) {
+                queryString += '?';
+            }
+            else {
+                queryString += '&';
+            }
+            queryString += `${queryParam.name}=${queryParam.value}`;
+        }
+        return queryString;
+    }
+    static { this.ɵfac = function PayPalScriptService_Factory(t) { return new (t || PayPalScriptService)(i0.ɵɵinject(i1.ScriptService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PayPalScriptService, factory: PayPalScriptService.ɵfac }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PayPalScriptService, [{
+        type: Injectable
+    }], () => [{ type: i1.ScriptService }], null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5cGFsLXNjcmlwdC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5hdG9seS9zcmMvbGliL3BheW1lbnRzL1BheVBhbC9zZXJ2aWNlcy9wYXlwYWwtc2NyaXB0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0VBY0U7QUFFRixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFNM0MsTUFBTSxPQUFPLG1CQUFtQjtJQUc5QixZQUFzQixhQUE0QjtRQUE1QixrQkFBYSxHQUFiLGFBQWEsQ0FBZTtRQUZqQyxxQkFBZ0IsR0FBRyxRQUFRLENBQUM7SUFHN0MsQ0FBQztJQUVELG9CQUFvQixDQUFDLE1BQXdCLEVBQUUsT0FBaUM7UUFDOUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBQUMsRUFBRSxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDbEcsQ0FBQztJQUVELG1CQUFtQjtRQUNqQixJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUNwRCxDQUFDO0lBRU8sZUFBZSxDQUFDLE1BQXdCO1FBQzlDLE1BQU0sTUFBTSxHQUFrQjtZQUMxQjtnQkFDSSxJQUFJLEVBQUUsV0FBVztnQkFDakIsS0FBSyxFQUFFLE1BQU0sQ0FBQyxRQUFRO2FBQ3pCO1NBQ0osQ0FBQztRQUVGLElBQUksTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2xCLE1BQU0sQ0FBQyxJQUFJLENBQUM7Z0JBQ1IsSUFBSSxFQUFFLFFBQVE7Z0JBQ2QsS0FBSyxFQUFFLE1BQU0sQ0FBQyxNQUFNO2FBQ3ZCLENBQUMsQ0FBQztRQUNMLENBQUM7UUFFRCxJQUFJLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNsQixNQUFNLENBQUMsSUFBSSxDQUFDO2dCQUNSLElBQUksRUFBRSxVQUFVO2dCQUNoQixLQUFLLEVBQUUsTUFBTSxDQUFDLFFBQVE7YUFDekIsQ0FBQyxDQUFDO1FBQ1AsQ0FBQztRQUVELElBQUksTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2hCLE1BQU0sQ0FBQyxJQUFJLENBQUM7Z0JBQ1IsSUFBSSxFQUFFLFFBQVE7Z0JBQ2QsS0FBSyxFQUFFLE1BQU0sQ0FBQyxNQUFNO2FBQ3ZCLENBQUMsQ0FBQztRQUNQLENBQUM7UUFFRCxJQUFJLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNmLE1BQU0sQ0FBQyxJQUFJLENBQUM7Z0JBQ1IsSUFBSSxFQUFFLE9BQU87Z0JBQ2IsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLO2FBQ3RCLENBQUMsQ0FBQztRQUNQLENBQUM7UUFFRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNoQixNQUFNLENBQUMsSUFBSSxDQUFDO2dCQUNSLElBQUksRUFBRSxRQUFRO2dCQUNkLEtBQUssRUFBRSxNQUFNLENBQUMsTUFBTTthQUN2QixDQUFDLENBQUM7UUFDUCxDQUFDO1FBRUQsSUFBRyxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbEIsTUFBTSxDQUFDLElBQUksQ0FBQztnQkFDVixJQUFJLEVBQUMsWUFBWTtnQkFDakIsS0FBSyxFQUFFLDZCQUE2QjthQUNyQyxDQUFDLENBQUE7UUFDSixDQUFDO1FBRUQsSUFBSSxNQUFNLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDckIsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUN2QyxDQUFDO1FBRUQsT0FBTyxnQ0FBZ0MsSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO0lBQ3ZFLENBQUM7SUFFTyxjQUFjLENBQUMsV0FBMEI7UUFDL0MsSUFBSSxXQUFXLEdBQUcsRUFBRSxDQUFDO1FBRXJCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxXQUFXLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7WUFDMUMsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ2xDLElBQUksQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO2dCQUNWLFdBQVcsSUFBSSxHQUFHLENBQUM7WUFDdkIsQ0FBQztpQkFBTSxDQUFDO2dCQUNKLFdBQVcsSUFBSSxHQUFHLENBQUM7WUFDdkIsQ0FBQztZQUVELFdBQVcsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLElBQUksVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzVELENBQUM7UUFFRCxPQUFPLFdBQVcsQ0FBQztJQUNyQixDQUFDO29GQXRGVSxtQkFBbUI7dUVBQW5CLG1CQUFtQixXQUFuQixtQkFBbUI7O2lGQUFuQixtQkFBbUI7Y0FEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbjxmaWxlPlxyXG4gIFByb2plY3Q6XHJcbiAgICBAb3Nvdml0bnkvYW5hdG9seVxyXG5cclxuICBBdXRob3JzOlxyXG4gICAgVmFkaW0gT3Nvdml0bnkgdmFkaW1Ab3Nvdml0bnkuY29tXHJcbiAgICBBbmF0b2x5IE9zb3ZpdG55IGFuYXRvbHlAb3Nvdml0bnkuY29tXHJcblxyXG4gIENyZWF0ZWQ6XHJcbiAgICAxNCBKdW4gMjAyNFxyXG5cclxuICBDb3B5cmlnaHQgKGMpIDIwMTYtMjAyMiBPc292aXRueSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXHJcbjwvZmlsZT5cclxuKi9cclxuXHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IElQYXlQYWxVcmxDb25maWcsIElRdWVyeVBhcmFtIH0gZnJvbSAnLi4vbW9kZWxzL3BheXBhbC1tb2RlbHMnO1xyXG5pbXBvcnQgeyBTY3JpcHRTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvc2NyaXB0LnNlcnZpY2UnO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgUGF5UGFsU2NyaXB0U2VydmljZSB7XHJcbiAgcHJpdmF0ZSByZWFkb25seSBwYXlwYWxXaW5kb3dOYW1lID0gJ3BheXBhbCc7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBzY3JpcHRTZXJ2aWNlOiBTY3JpcHRTZXJ2aWNlKSB7XHJcbiAgfVxyXG5cclxuICByZWdpc3RlclBheVBhbFNjcmlwdChjb25maWc6IElQYXlQYWxVcmxDb25maWcsIG9uUmVhZHk6IChwYXlQYWxBcGk6IGFueSkgPT4gdm9pZCk6IHZvaWQge1xyXG4gICAgdGhpcy5zY3JpcHRTZXJ2aWNlLnJlZ2lzdGVyU2NyaXB0KHRoaXMuZ2V0VXJsRm9yQ29uZmlnKGNvbmZpZyksIHRoaXMucGF5cGFsV2luZG93TmFtZSwgb25SZWFkeSk7XHJcbiAgfVxyXG5cclxuICBkZXN0cm95UGF5UGFsU2NyaXB0KCk6IHZvaWQge1xyXG4gICAgdGhpcy5zY3JpcHRTZXJ2aWNlLmNsZWFudXAodGhpcy5wYXlwYWxXaW5kb3dOYW1lKTtcclxuICB9XHJcblxyXG4gIHByaXZhdGUgZ2V0VXJsRm9yQ29uZmlnKGNvbmZpZzogSVBheVBhbFVybENvbmZpZyk6IHN0cmluZyB7XHJcbiAgICBjb25zdCBwYXJhbXM6IElRdWVyeVBhcmFtW10gPSBbXHJcbiAgICAgICAge1xyXG4gICAgICAgICAgICBuYW1lOiAnY2xpZW50LWlkJyxcclxuICAgICAgICAgICAgdmFsdWU6IGNvbmZpZy5jbGllbnRJZFxyXG4gICAgICAgIH1cclxuICAgIF07XHJcblxyXG4gICAgaWYgKGNvbmZpZy5sb2NhbGUpIHtcclxuICAgICAgcGFyYW1zLnB1c2goe1xyXG4gICAgICAgICAgbmFtZTogJ2xvY2FsZScsXHJcbiAgICAgICAgICB2YWx1ZTogY29uZmlnLmxvY2FsZVxyXG4gICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICBpZiAoY29uZmlnLmN1cnJlbmN5KSB7XHJcbiAgICAgICAgcGFyYW1zLnB1c2goe1xyXG4gICAgICAgICAgICBuYW1lOiAnY3VycmVuY3knLFxyXG4gICAgICAgICAgICB2YWx1ZTogY29uZmlnLmN1cnJlbmN5XHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcblxyXG4gICAgaWYgKGNvbmZpZy5jb21taXQpIHtcclxuICAgICAgICBwYXJhbXMucHVzaCh7XHJcbiAgICAgICAgICAgIG5hbWU6ICdjb21taXQnLFxyXG4gICAgICAgICAgICB2YWx1ZTogY29uZmlnLmNvbW1pdFxyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG5cclxuICAgIGlmIChjb25maWcudmF1bHQpIHtcclxuICAgICAgICBwYXJhbXMucHVzaCh7XHJcbiAgICAgICAgICAgIG5hbWU6ICd2YXVsdCcsXHJcbiAgICAgICAgICAgIHZhbHVlOiBjb25maWcudmF1bHRcclxuICAgICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICBpZiAoY29uZmlnLmludGVudCkge1xyXG4gICAgICAgIHBhcmFtcy5wdXNoKHtcclxuICAgICAgICAgICAgbmFtZTogJ2ludGVudCcsXHJcbiAgICAgICAgICAgIHZhbHVlOiBjb25maWcuaW50ZW50XHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcblxyXG4gICAgaWYoY29uZmlnLmZ1bmRpbmcpIHtcclxuICAgICAgcGFyYW1zLnB1c2goe1xyXG4gICAgICAgIG5hbWU6J2NvbXBvbmVudHMnLFxyXG4gICAgICAgIHZhbHVlOiAnYnV0dG9ucyxmdW5kaW5nLWVsaWdpYmlsaXR5J1xyXG4gICAgICB9KVxyXG4gICAgfVxyXG5cclxuICAgIGlmIChjb25maWcuZXh0cmFQYXJhbXMpIHtcclxuICAgICAgICBwYXJhbXMucHVzaCguLi5jb25maWcuZXh0cmFQYXJhbXMpO1xyXG4gICAgfVxyXG5cclxuICAgIHJldHVybiBgaHR0cHM6Ly93d3cucGF5cGFsLmNvbS9zZGsvanMke3RoaXMuZ2V0UXVlcnlTdHJpbmcocGFyYW1zKX1gO1xyXG4gIH1cclxuXHJcbiAgcHJpdmF0ZSBnZXRRdWVyeVN0cmluZyhxdWVyeVBhcmFtczogSVF1ZXJ5UGFyYW1bXSk6IHN0cmluZyB7XHJcbiAgICBsZXQgcXVlcnlTdHJpbmcgPSAnJztcclxuXHJcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHF1ZXJ5UGFyYW1zLmxlbmd0aDsgaSsrKSB7XHJcbiAgICAgICAgY29uc3QgcXVlcnlQYXJhbSA9IHF1ZXJ5UGFyYW1zW2ldO1xyXG4gICAgICAgIGlmIChpID09PSAwKSB7XHJcbiAgICAgICAgICAgIHF1ZXJ5U3RyaW5nICs9ICc/JztcclxuICAgICAgICB9IGVsc2Uge1xyXG4gICAgICAgICAgICBxdWVyeVN0cmluZyArPSAnJic7XHJcbiAgICAgICAgfVxyXG5cclxuICAgICAgICBxdWVyeVN0cmluZyArPSBgJHtxdWVyeVBhcmFtLm5hbWV9PSR7cXVlcnlQYXJhbS52YWx1ZX1gO1xyXG4gICAgfVxyXG5cclxuICAgIHJldHVybiBxdWVyeVN0cmluZztcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/payments/index.mjs

@@ -0,0 +1,22 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny vadim@osovitny.com
+    Anatoly Osovitny anatoly@osovitny.com
+
+  Created:
+    14 Jun 2024
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+//services
+export * from './services/script.service';
+//PayPal
+export * from './PayPal/components/paypal.component';
+export * from './PayPal/models/paypal-models';
+export * from './PayPal/services/paypal-script.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmF0b2x5L3NyYy9saWIvcGF5bWVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0VBY0U7QUFFRixVQUFVO0FBQ1YsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxRQUFRO0FBQ1IsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMseUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG48ZmlsZT5cclxuICBQcm9qZWN0OlxyXG4gICAgQG9zb3ZpdG55L2FuYXRvbHlcclxuXHJcbiAgQXV0aG9yczpcclxuICAgIFZhZGltIE9zb3ZpdG55IHZhZGltQG9zb3ZpdG55LmNvbVxyXG4gICAgQW5hdG9seSBPc292aXRueSBhbmF0b2x5QG9zb3ZpdG55LmNvbVxyXG5cclxuICBDcmVhdGVkOlxyXG4gICAgMTQgSnVuIDIwMjRcclxuXHJcbiAgQ29weXJpZ2h0IChjKSAyMDE2LTIwMjIgT3Nvdml0bnkgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxyXG48L2ZpbGU+XHJcbiovXHJcblxyXG4vL3NlcnZpY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvc2NyaXB0LnNlcnZpY2UnO1xyXG5cclxuLy9QYXlQYWxcclxuZXhwb3J0ICogZnJvbSAnLi9QYXlQYWwvY29tcG9uZW50cy9wYXlwYWwuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9QYXlQYWwvbW9kZWxzL3BheXBhbC1tb2RlbHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL1BheVBhbC9zZXJ2aWNlcy9wYXlwYWwtc2NyaXB0LnNlcnZpY2UnO1xyXG4iXX0=

package/esm2022/lib/payments/payments.module.mjs

@@ -0,0 +1,54 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny vadim@osovitny.com
+    Anatoly Osovitny anatoly@osovitny.com
+
+  Created:
+    14 Jun 2024
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+//Node
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+//App
+import { ScriptService } from './services/script.service';
+//PayPal
+import { PayPalComponent } from './PayPal/components/paypal.component';
+import { PayPalScriptService } from './PayPal/services/paypal-script.service';
+import * as i0 from "@angular/core";
+export class AnatolyPaymentsModule {
+    static { this.ɵfac = function AnatolyPaymentsModule_Factory(t) { return new (t || AnatolyPaymentsModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: AnatolyPaymentsModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            ScriptService,
+            //PayPal
+            PayPalScriptService
+        ], imports: [CommonModule] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AnatolyPaymentsModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule
+                ],
+                declarations: [
+                    PayPalComponent
+                ],
+                exports: [
+                    PayPalComponent
+                ],
+                providers: [
+                    ScriptService,
+                    //PayPal
+                    PayPalScriptService
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(AnatolyPaymentsModule, { declarations: [PayPalComponent], imports: [CommonModule], exports: [PayPalComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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