@xsolla/payment-client-core 0.2.21 → 0.2.22

package/esm2022/lib/core/payment-methods/payment-methods.service.mjs

@@ -0,0 +1,75 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { lastValueFrom, map } from 'rxjs';
+import { ResponseError } from '../exceptions-handling/errors/response-error.class';
+import { paymentMethodsResponseFactoryToken, } from './payment-methods-response.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../settings/settings.service";
+import * as i2 from "../country/country.service";
+import * as i3 from "../http/secure-api/secure-api.service";
+export class PaymentMethodsService {
+    constructor(responseFactory, settingsService, countryService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'remained_payment_methods';
+        this.cache = new Map();
+    }
+    async getAllMethods() {
+        return this.request();
+    }
+    async getList(isSaveMethodMode) {
+        const response = await this.request(isSaveMethodMode);
+        if (this.isFixedPaymentMethod) {
+            return this.filterMethodsByFixedPaymentMethod(response.remained);
+        }
+        return response.remained;
+    }
+    async getQuickMethods() {
+        const response = await this.request();
+        return response.especial;
+    }
+    async request(isSaveMethodMode) {
+        const requestParams = {
+            access_token: this.settingsService.token,
+            country: this.countryService.getCountry(),
+            save_payment_account_only: isSaveMethodMode
+                ? "1" /* XpsBoolean.true */
+                : "0" /* XpsBoolean.false */,
+        };
+        const cacheKey = JSON.stringify(requestParams);
+        if (!this.cache.has(cacheKey)) {
+            this.cache.set(cacheKey, lastValueFrom(this.secureApi
+                .post(this.apiRoute, new URLSearchParams({ ...requestParams }), {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            })
+                .pipe(map((response) => this.responseFactory(response.payment_methods)))).catch((error) => {
+                throw new ResponseError(error.message);
+            }));
+        }
+        // @ts-expect-error the map already has the cache with key
+        return this.cache.get(cacheKey);
+    }
+    filterMethodsByFixedPaymentMethod(methods) {
+        const fixedPid = this.settingsService.purchase?.payment_system?.id;
+        const paymentMethod = methods.find((method) => method.id === fixedPid);
+        return paymentMethod ? [paymentMethod] : [];
+    }
+    get isFixedPaymentMethod() {
+        return !!this.settingsService.purchase?.payment_system?.id;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentMethodsService, deps: [{ token: paymentMethodsResponseFactoryToken }, { token: i1.SettingsService }, { token: i2.CountryService }, { token: i3.SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentMethodsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentMethodsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [paymentMethodsResponseFactoryToken]
+                }] }, { type: i1.SettingsService }, { type: i2.CountryService }, { type: i3.SecureApiClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payment-methods.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/payment-methods/payment-methods.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,MAAM,oDAAoD,CAAC;AAOnF,OAAO,EAEL,kCAAkC,GACnC,MAAM,kCAAkC,CAAC;;;;;AAM1C,MAAM,OAAO,qBAAqB;IAKhC,YAEmB,eAA8C,EAC9C,eAAgC,EAChC,cAA8B,EAC9B,SAA0B;QAH1B,oBAAe,GAAf,eAAe,CAA+B;QAC9C,oBAAe,GAAf,eAAe,CAAiB;QAChC,mBAAc,GAAd,cAAc,CAAgB;QAC9B,cAAS,GAAT,SAAS,CAAiB;QAT5B,aAAQ,GAAG,0BAA0B,CAAC;QAEtC,UAAK,GAAG,IAAI,GAAG,EAA2C,CAAC;IAQzE,CAAC;IAEG,KAAK,CAAC,aAAa;QACxB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,gBAA0B;QAC7C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAEtD,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,iCAAiC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACnE,CAAC;QAED,OAAO,QAAQ,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,eAAe;QAC1B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACtC,OAAO,QAAQ,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,gBAA0B;QAE1B,MAAM,aAAa,GAAgC;YACjD,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK;YACxC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE;YACzC,yBAAyB,EAAE,gBAAgB;gBACzC,CAAC;gBACD,CAAC,2BAAiB;SACrB,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAE/C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,GAAG,CACZ,QAAQ,EACR,aAAa,CACX,IAAI,CAAC,SAAS;iBACX,IAAI,CACH,IAAI,CAAC,QAAQ,EACb,IAAI,eAAe,CAAC,EAAE,GAAG,aAAa,EAAE,CAAC,EACzC;gBACE,OAAO,EAAE,IAAI,WAAW,EAAE,CAAC,GAAG,CAC5B,cAAc,EACd,kDAAkD,CACnD;gBACD,YAAY,EAAE,MAAM;aACrB,CACF;iBACA,IAAI,CACH,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAClE,CACJ,CAAC,KAAK,CAAC,CAAC,KAAY,EAAE,EAAE;gBACvB,MAAM,IAAI,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACzC,CAAC,CAAC,CACH,CAAC;QACJ,CAAC;QAED,0DAA0D;QAC1D,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;IAEO,iCAAiC,CACvC,OAAwB;QAExB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,CAAC;QACnE,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC;QAEvE,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9C,CAAC;IAED,IAAY,oBAAoB;QAC9B,OAAO,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,CAAC;IAC7D,CAAC;8GApFU,qBAAqB,kBAMtB,kCAAkC;kHANjC,qBAAqB,cAFpB,MAAM;;2FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAOI,MAAM;2BAAC,kCAAkC","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { lastValueFrom, map } from 'rxjs';\nimport { CountryService } from '../country/country.service';\nimport { ResponseError } from '../exceptions-handling/errors/response-error.class';\nimport { SecureApiClient } from '../http/secure-api/secure-api.service';\nimport { SettingsService } from '../settings/settings.service';\nimport { PaymentMethod } from './payment-method.interface';\nimport { PaymentMethodsRequestParams } from './payment-methods-request-params.interface';\nimport { PaymentMethodsResponse } from './payment-methods-response.class';\nimport { PaymentMethodsResponseApi } from './payment-methods-response.interface';\nimport {\n  PaymentMethodsResponseFactory,\n  paymentMethodsResponseFactoryToken,\n} from './payment-methods-response.token';\nimport { XpsBoolean } from '../xps-boolean.enum';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PaymentMethodsService {\n  private readonly apiRoute = 'remained_payment_methods';\n\n  private readonly cache = new Map<string, Promise<PaymentMethodsResponse>>();\n\n  public constructor(\n    @Inject(paymentMethodsResponseFactoryToken)\n    private readonly responseFactory: PaymentMethodsResponseFactory,\n    private readonly settingsService: SettingsService,\n    private readonly countryService: CountryService,\n    private readonly secureApi: SecureApiClient\n  ) {}\n\n  public async getAllMethods(): Promise<PaymentMethodsResponse> {\n    return this.request();\n  }\n\n  public async getList(isSaveMethodMode?: boolean): Promise<PaymentMethod[]> {\n    const response = await this.request(isSaveMethodMode);\n\n    if (this.isFixedPaymentMethod) {\n      return this.filterMethodsByFixedPaymentMethod(response.remained);\n    }\n\n    return response.remained;\n  }\n\n  public async getQuickMethods(): Promise<PaymentMethod[]> {\n    const response = await this.request();\n    return response.especial;\n  }\n\n  private async request(\n    isSaveMethodMode?: boolean\n  ): Promise<PaymentMethodsResponse> {\n    const requestParams: PaymentMethodsRequestParams = {\n      access_token: this.settingsService.token,\n      country: this.countryService.getCountry(),\n      save_payment_account_only: isSaveMethodMode\n        ? XpsBoolean.true\n        : XpsBoolean.false,\n    };\n    const cacheKey = JSON.stringify(requestParams);\n\n    if (!this.cache.has(cacheKey)) {\n      this.cache.set(\n        cacheKey,\n        lastValueFrom(\n          this.secureApi\n            .post<PaymentMethodsResponseApi>(\n              this.apiRoute,\n              new URLSearchParams({ ...requestParams }),\n              {\n                headers: new HttpHeaders().set(\n                  'Content-Type',\n                  'application/x-www-form-urlencoded; charset=utf-8'\n                ),\n                responseType: 'json',\n              }\n            )\n            .pipe(\n              map((response) => this.responseFactory(response.payment_methods))\n            )\n        ).catch((error: Error) => {\n          throw new ResponseError(error.message);\n        })\n      );\n    }\n\n    // @ts-expect-error the map already has the cache with key\n    return this.cache.get(cacheKey);\n  }\n\n  private filterMethodsByFixedPaymentMethod(\n    methods: PaymentMethod[]\n  ): PaymentMethod[] {\n    const fixedPid = this.settingsService.purchase?.payment_system?.id;\n    const paymentMethod = methods.find((method) => method.id === fixedPid);\n\n    return paymentMethod ? [paymentMethod] : [];\n  }\n\n  private get isFixedPaymentMethod(): boolean {\n    return !!this.settingsService.purchase?.payment_system?.id;\n  }\n}\n"]}

package/esm2022/lib/core/performance/performance.service.mjs

@@ -0,0 +1,111 @@
+import { Inject, Injectable } from '@angular/core';
+import { userBehaviourEventTypes } from '../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types';
+import { eventCategories } from '../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-categories';
+import { windowToken } from '../window.token';
+import { defaultApiUrl } from '../http/secure-api/api-url.const';
+import * as i0 from "@angular/core";
+import * as i1 from "../user-behaviour-analytics/user-behaviour-analytics.service";
+import * as i2 from "./xhr-action.service";
+export class PerformanceService {
+    get network() {
+        return this.navigationPerformance?.responseEnd;
+    }
+    get runApp() {
+        const domComplete = this.navigationPerformance?.domComplete;
+        if (domComplete == null || this.network == null) {
+            return null;
+        }
+        return domComplete - this.network;
+    }
+    constructor(userBehaviourAnalyticsService, xhrActionService, window, zone) {
+        this.userBehaviourAnalyticsService = userBehaviourAnalyticsService;
+        this.xhrActionService = xhrActionService;
+        this.window = window;
+        this.zone = zone;
+        this.navigationPerformance = this.window.performance?.getEntriesByType('navigation')?.[0];
+        this.resourcesPerformance = this.window.performance?.getEntriesByType('resource');
+    }
+    init() {
+        if (!this.window?.performance) {
+            return;
+        }
+        this.zone.runOutsideAngular(() => {
+            this.measureInitialValues();
+            this.listenXhrActions();
+        });
+    }
+    getInitRequest() {
+        if (!this.navigationPerformance || !this.resourcesPerformance) {
+            return null;
+        }
+        const utilsTiming = this.resourcesPerformance.find((performance) => performance.name.includes(`${defaultApiUrl}utils`));
+        if (!utilsTiming) {
+            return null;
+        }
+        return {
+            duration: utilsTiming.fetchStart - utilsTiming.responseEnd,
+            timeReserve: this.navigationPerformance.domComplete - utilsTiming.responseEnd,
+            utilsDuration: utilsTiming.duration,
+        };
+    }
+    sendMeasurement(name, value, additional) {
+        if (value == null) {
+            return;
+        }
+        const eventOptions = {
+            value: value.toString(),
+        };
+        if (additional) {
+            Object.keys(additional).forEach((optionName) => {
+                const optionValue = additional[optionName];
+                if (optionValue != null) {
+                    eventOptions[optionName] =
+                        optionValue.toString();
+                }
+            });
+        }
+        void this.userBehaviourAnalyticsService.send(name, userBehaviourEventTypes.manual, eventOptions);
+    }
+    measureRunApp() {
+        const sendRunApp = () => void setTimeout(() => this.sendMeasurement('run-app', this.runApp));
+        if (document.readyState === 'complete') {
+            sendRunApp();
+        }
+        else {
+            this.window.addEventListener('load', () => sendRunApp());
+        }
+    }
+    measureInitialValues() {
+        const initRequest = this.getInitRequest();
+        if (initRequest) {
+            this.sendMeasurement('utils', initRequest.duration, {
+                extraValue: initRequest.timeReserve,
+                dimension1: initRequest.utilsDuration,
+            });
+        }
+        this.sendMeasurement('network', this.network);
+        this.measureRunApp();
+    }
+    listenXhrActions() {
+        const xhrAction = this.xhrActionService.getXhrAction();
+        xhrAction.subscribe((event) => {
+            void this.userBehaviourAnalyticsService.send(`xhr-action:${event.name}`, userBehaviourEventTypes.manual, {
+                value: event.duration.toString(),
+                eventCategory: eventCategories.withoutInvoice,
+                extraValue: JSON.stringify(event),
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PerformanceService, deps: [{ token: i1.UserBehaviourAnalyticsService }, { token: i2.XhrActionService }, { token: windowToken }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PerformanceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PerformanceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.UserBehaviourAnalyticsService }, { type: i2.XhrActionService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"performance.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/performance/performance.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, NgZone } from '@angular/core';\nimport { UserBehaviourAnalyticsService } from '../user-behaviour-analytics/user-behaviour-analytics.service';\nimport { XhrActionService } from './xhr-action.service';\nimport { XhrAction } from './xhr-action.interface';\nimport { userBehaviourEventTypes } from '../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types';\nimport { eventCategories } from '../user-behaviour-analytics/user-behaviour-event/user-behaviour-event-categories';\nimport { Observable } from 'rxjs';\nimport { ExtendedWindow } from '../extended-window.interface';\nimport { windowToken } from '../window.token';\nimport { defaultApiUrl } from '../http/secure-api/api-url.const';\nimport { SendEventMethodOptionsInterface } from '../user-behaviour-analytics/user-behaviour-analytics.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PerformanceService {\n  private readonly navigationPerformance =\n    this.window.performance?.getEntriesByType('navigation')?.[0] as\n      | PerformanceNavigationTiming\n      | undefined;\n\n  private readonly resourcesPerformance =\n    this.window.performance?.getEntriesByType('resource') as\n      | PerformanceResourceTiming[]\n      | undefined;\n\n  private get network(): number | undefined {\n    return this.navigationPerformance?.responseEnd;\n  }\n\n  private get runApp(): number | null {\n    const domComplete = this.navigationPerformance?.domComplete;\n\n    if (domComplete == null || this.network == null) {\n      return null;\n    }\n\n    return domComplete - this.network;\n  }\n\n  public constructor(\n    private readonly userBehaviourAnalyticsService: UserBehaviourAnalyticsService,\n    private readonly xhrActionService: XhrActionService,\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow,\n    private readonly zone: NgZone\n  ) {}\n\n  public init(): undefined | void {\n    if (!this.window?.performance) {\n      return;\n    }\n\n    this.zone.runOutsideAngular(() => {\n      this.measureInitialValues();\n      this.listenXhrActions();\n    });\n  }\n\n  private getInitRequest(): {\n    duration: number;\n    timeReserve: number;\n    utilsDuration: number;\n  } | null {\n    if (!this.navigationPerformance || !this.resourcesPerformance) {\n      return null;\n    }\n\n    const utilsTiming: PerformanceResourceTiming | undefined =\n      this.resourcesPerformance.find((performance: PerformanceResourceTiming) =>\n        performance.name.includes(`${defaultApiUrl}utils`)\n      );\n\n    if (!utilsTiming) {\n      return null;\n    }\n\n    return {\n      duration: utilsTiming.fetchStart - utilsTiming.responseEnd,\n      timeReserve:\n        this.navigationPerformance.domComplete - utilsTiming.responseEnd,\n      utilsDuration: utilsTiming.duration,\n    };\n  }\n\n  private sendMeasurement(\n    name: string,\n    value: number | null | undefined,\n    additional?: {\n      extraValue?: number | null | undefined;\n      dimension1?: number | null | undefined;\n      dimension2?: number | null | undefined;\n    }\n  ): void {\n    if (value == null) {\n      return;\n    }\n\n    const eventOptions: SendEventMethodOptionsInterface = {\n      value: value.toString(),\n    };\n\n    if (additional) {\n      Object.keys(additional).forEach((optionName: string): void => {\n        const optionValue: number | null | undefined =\n          additional[optionName as keyof typeof additional];\n        if (optionValue != null) {\n          eventOptions[optionName as keyof typeof additional] =\n            optionValue.toString();\n        }\n      });\n    }\n\n    void this.userBehaviourAnalyticsService.send(\n      name,\n      userBehaviourEventTypes.manual,\n      eventOptions\n    );\n  }\n\n  private measureRunApp(): void {\n    const sendRunApp = (): void =>\n      void setTimeout(() => this.sendMeasurement('run-app', this.runApp));\n\n    if (document.readyState === 'complete') {\n      sendRunApp();\n    } else {\n      this.window.addEventListener('load', () => sendRunApp());\n    }\n  }\n\n  private measureInitialValues(): void {\n    const initRequest = this.getInitRequest();\n    if (initRequest) {\n      this.sendMeasurement('utils', initRequest.duration, {\n        extraValue: initRequest.timeReserve,\n        dimension1: initRequest.utilsDuration,\n      });\n    }\n    this.sendMeasurement('network', this.network);\n    this.measureRunApp();\n  }\n\n  private listenXhrActions(): void {\n    const xhrAction: Observable<XhrAction> =\n      this.xhrActionService.getXhrAction();\n\n    xhrAction.subscribe((event: XhrAction) => {\n      void this.userBehaviourAnalyticsService.send(\n        `xhr-action:${event.name}`,\n        userBehaviourEventTypes.manual,\n        {\n          value: event.duration.toString(),\n          eventCategory: eventCategories.withoutInvoice,\n          extraValue: JSON.stringify(event),\n        }\n      );\n    });\n  }\n}\n"]}

package/esm2022/lib/core/performance/xhr-action.service.mjs

@@ -0,0 +1,114 @@
+import { Inject, Injectable } from '@angular/core';
+import { interval, of, Subject } from 'rxjs';
+import { debounce, filter, map } from 'rxjs/operators';
+import { windowToken } from '../window.token';
+import { defaultApiUrl, sandboxApiUrl } from '../http/secure-api/api-url.const';
+import * as i0 from "@angular/core";
+export class XhrActionService {
+    constructor(window) {
+        this.window = window;
+        this.pauseTime = 1000;
+        this.userInputEventNames = ['click', 'change'];
+        this.isXhrActionStarted = false;
+        this.apiRequestEntries = [];
+        this.cdnRequestEntries = [];
+        this.entriesSubject = new Subject();
+    }
+    getXhrAction() {
+        if (!this.window.performance || !this.window.PerformanceObserver) {
+            return of();
+        }
+        this.getUserInput().subscribe(() => this.window.performance.mark('userInput'));
+        this.getPerformance().subscribe((entry) => this.processEntry(entry));
+        return this.getPauseEvent().pipe(map(() => {
+            const event = {
+                name: this.getApiRequestName(),
+                duration: this.getDuration([
+                    ...this.apiRequestEntries,
+                    ...this.cdnRequestEntries,
+                ]),
+                apiRequestCount: this.apiRequestEntries.length,
+                apiRequestDuration: this.getDuration(this.apiRequestEntries),
+                cdnRequestCount: this.cdnRequestEntries.length,
+                cdnRequestDuration: this.getDuration(this.cdnRequestEntries),
+            };
+            this.stopXhrAction();
+            return event;
+        }));
+    }
+    processEntry(entry) {
+        const isApiRequest = entry.name.includes(defaultApiUrl || sandboxApiUrl);
+        const cdnUrl = '';
+        const isCdnRequest = !isApiRequest && entry.name.startsWith(cdnUrl);
+        if (this.isXhrActionStarted && isApiRequest) {
+            this.apiRequestEntries.push(entry);
+        }
+        if (this.isXhrActionStarted && isCdnRequest) {
+            this.cdnRequestEntries.push(entry);
+        }
+        if (isApiRequest && !this.isXhrActionStarted) {
+            const userInputEntries = this.window.performance.getEntriesByName('userInput', 'mark');
+            const userInputEntry = userInputEntries[userInputEntries.length - 1];
+            if (userInputEntry) {
+                this.startXhrAction(entry);
+            }
+        }
+        if (isApiRequest || isCdnRequest) {
+            this.entriesSubject.next(entry);
+        }
+    }
+    startXhrAction(xhrEntry) {
+        this.isXhrActionStarted = true;
+        this.apiRequestEntries.push(xhrEntry);
+    }
+    stopXhrAction() {
+        this.isXhrActionStarted = false;
+        this.apiRequestEntries = [];
+        this.cdnRequestEntries = [];
+    }
+    getUserInput() {
+        const userInputSubject = new Subject();
+        this.userInputEventNames.forEach((eventName) => {
+            this.window.addEventListener(eventName, () => userInputSubject.next());
+        });
+        return userInputSubject;
+    }
+    getPerformance() {
+        const performanceSubject = new Subject();
+        if (this.window.PerformanceObserver) {
+            const observer = new this.window.PerformanceObserver((list) => {
+                list.getEntries().forEach((entry) => {
+                    return performanceSubject.next(entry);
+                });
+            });
+            observer.observe({ entryTypes: ['resource'] });
+        }
+        return performanceSubject;
+    }
+    getApiRequestName() {
+        return this.apiRequestEntries[0].name.split(defaultApiUrl)[1].split('?')[0];
+    }
+    getDuration(entries) {
+        if (!entries.length) {
+            return 0;
+        }
+        const firstApiRequestEntry = entries.reduce((prev, current) => (prev.startTime < current.startTime ? prev : current));
+        const lastApiRequestEntry = entries.reduce((prev, current) => prev.responseEnd > current.responseEnd ? prev : current);
+        return Math.round(lastApiRequestEntry.responseEnd - firstApiRequestEntry.startTime);
+    }
+    getPauseEvent() {
+        return this.entriesSubject.pipe(debounce(() => interval(this.pauseTime)), filter(() => this.isXhrActionStarted));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: XhrActionService, deps: [{ token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: XhrActionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: XhrActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xhr-action.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/performance/xhr-action.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { interval, Observable, of, Subject } from 'rxjs';\nimport { debounce, filter, map } from 'rxjs/operators';\nimport { XhrAction } from './xhr-action.interface';\nimport { ExtendedWindow } from '../extended-window.interface';\nimport { windowToken } from '../window.token';\nimport { defaultApiUrl, sandboxApiUrl } from '../http/secure-api/api-url.const';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class XhrActionService {\n  private readonly pauseTime = 1000;\n  private readonly userInputEventNames: string[] = ['click', 'change'];\n  private isXhrActionStarted = false;\n  private apiRequestEntries: PerformanceResourceTiming[] = [];\n  private cdnRequestEntries: PerformanceResourceTiming[] = [];\n  private readonly entriesSubject = new Subject<PerformanceResourceTiming>();\n\n  public constructor(\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow\n  ) {}\n\n  public getXhrAction(): Observable<XhrAction> {\n    if (!this.window.performance || !this.window.PerformanceObserver) {\n      return of();\n    }\n\n    this.getUserInput().subscribe(() =>\n      this.window.performance.mark('userInput')\n    );\n\n    this.getPerformance().subscribe((entry: PerformanceResourceTiming) =>\n      this.processEntry(entry)\n    );\n\n    return this.getPauseEvent().pipe(\n      map<PerformanceResourceTiming, XhrAction>(() => {\n        const event: XhrAction = {\n          name: this.getApiRequestName(),\n          duration: this.getDuration([\n            ...this.apiRequestEntries,\n            ...this.cdnRequestEntries,\n          ]),\n          apiRequestCount: this.apiRequestEntries.length,\n          apiRequestDuration: this.getDuration(this.apiRequestEntries),\n          cdnRequestCount: this.cdnRequestEntries.length,\n          cdnRequestDuration: this.getDuration(this.cdnRequestEntries),\n        };\n\n        this.stopXhrAction();\n\n        return event;\n      })\n    );\n  }\n\n  private processEntry(entry: PerformanceResourceTiming): void {\n    const isApiRequest: boolean = entry.name.includes(\n      defaultApiUrl || sandboxApiUrl\n    );\n\n    const cdnUrl = '';\n    const isCdnRequest: boolean =\n      !isApiRequest && entry.name.startsWith(cdnUrl);\n\n    if (this.isXhrActionStarted && isApiRequest) {\n      this.apiRequestEntries.push(entry);\n    }\n\n    if (this.isXhrActionStarted && isCdnRequest) {\n      this.cdnRequestEntries.push(entry);\n    }\n\n    if (isApiRequest && !this.isXhrActionStarted) {\n      const userInputEntries: PerformanceEntry[] =\n        this.window.performance.getEntriesByName('userInput', 'mark');\n      const userInputEntry: PerformanceEntry =\n        userInputEntries[userInputEntries.length - 1];\n\n      if (userInputEntry) {\n        this.startXhrAction(entry);\n      }\n    }\n\n    if (isApiRequest || isCdnRequest) {\n      this.entriesSubject.next(entry);\n    }\n  }\n\n  private startXhrAction(xhrEntry: PerformanceResourceTiming): void {\n    this.isXhrActionStarted = true;\n    this.apiRequestEntries.push(xhrEntry);\n  }\n\n  private stopXhrAction(): void {\n    this.isXhrActionStarted = false;\n    this.apiRequestEntries = [];\n    this.cdnRequestEntries = [];\n  }\n\n  private getUserInput(): Subject<void> {\n    const userInputSubject: Subject<void> = new Subject();\n\n    this.userInputEventNames.forEach((eventName: string) => {\n      this.window.addEventListener(eventName, () => userInputSubject.next());\n    });\n\n    return userInputSubject;\n  }\n\n  private getPerformance(): Subject<PerformanceResourceTiming> {\n    const performanceSubject: Subject<PerformanceResourceTiming> =\n      new Subject();\n\n    if (this.window.PerformanceObserver) {\n      const observer = new this.window.PerformanceObserver(\n        (list: PerformanceObserverEntryList) => {\n          list.getEntries().forEach((entry: PerformanceEntry): void => {\n            return performanceSubject.next(entry as PerformanceResourceTiming);\n          });\n        }\n      );\n\n      observer.observe({ entryTypes: ['resource'] });\n    }\n\n    return performanceSubject;\n  }\n\n  private getApiRequestName(): string {\n    return this.apiRequestEntries[0].name.split(defaultApiUrl)[1].split('?')[0];\n  }\n\n  private getDuration(entries: PerformanceResourceTiming[]): number {\n    if (!entries.length) {\n      return 0;\n    }\n\n    const firstApiRequestEntry: PerformanceResourceTiming = entries.reduce(\n      (prev, current) => (prev.startTime < current.startTime ? prev : current)\n    );\n    const lastApiRequestEntry: PerformanceResourceTiming = entries.reduce(\n      (prev, current) =>\n        prev.responseEnd > current.responseEnd ? prev : current\n    );\n\n    return Math.round(\n      lastApiRequestEntry.responseEnd - firstApiRequestEntry.startTime\n    );\n  }\n\n  private getPauseEvent(): Observable<PerformanceResourceTiming> {\n    return this.entriesSubject.pipe(\n      debounce(() => interval(this.pauseTime)),\n      filter(() => this.isXhrActionStarted)\n    );\n  }\n}\n"]}

package/esm2022/lib/core/saved-methods/saved-methods.service.mjs

@@ -0,0 +1,54 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { lastValueFrom, map } from 'rxjs';
+import { ResponseError } from '../exceptions-handling/errors/response-error.class';
+import { savedMethodsResponseFactoryToken, } from './saved-methods-response.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../settings/settings.service";
+import * as i2 from "../http/secure-api/secure-api.service";
+export class SavedMethodsService {
+    constructor(responseFactory, settingsService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'savedmethods';
+        this.cache = new Map();
+    }
+    async getList(needResetCache = false) {
+        if (needResetCache) {
+            this.cache.clear();
+        }
+        const response = await this.request();
+        return response.list;
+    }
+    async request() {
+        const requestParams = {
+            access_token: this.settingsService.token,
+        };
+        const cacheKey = JSON.stringify(requestParams);
+        if (!this.cache.has(cacheKey)) {
+            this.cache.set(cacheKey, lastValueFrom(this.secureApi
+                .post(this.apiRoute, new URLSearchParams({ ...requestParams }), {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            })
+                .pipe(map((response) => this.responseFactory(response)))).catch((error) => {
+                throw new ResponseError(error.message);
+            }));
+        }
+        // @ts-expect-error the map already has the cache with key
+        return this.cache.get(cacheKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SavedMethodsService, deps: [{ token: savedMethodsResponseFactoryToken }, { token: i1.SettingsService }, { token: i2.SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SavedMethodsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SavedMethodsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [savedMethodsResponseFactoryToken]
+                }] }, { type: i1.SettingsService }, { type: i2.SecureApiClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZWQtbWV0aG9kcy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGF5bWVudC1jbGllbnQtY29yZS9zcmMvbGliL2NvcmUvc2F2ZWQtbWV0aG9kcy9zYXZlZC1tZXRob2RzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUtuRixPQUFPLEVBRUwsZ0NBQWdDLEdBQ2pDLE1BQU0sZ0NBQWdDLENBQUM7Ozs7QUFPeEMsTUFBTSxPQUFPLG1CQUFtQjtJQUs5QixZQUVtQixlQUE0QyxFQUM1QyxlQUFnQyxFQUNoQyxTQUEwQjtRQUYxQixvQkFBZSxHQUFmLGVBQWUsQ0FBNkI7UUFDNUMsb0JBQWUsR0FBZixlQUFlLENBQWlCO1FBQ2hDLGNBQVMsR0FBVCxTQUFTLENBQWlCO1FBUjVCLGFBQVEsR0FBRyxjQUFjLENBQUM7UUFFMUIsVUFBSyxHQUFHLElBQUksR0FBRyxFQUF5QyxDQUFDO0lBT3ZFLENBQUM7SUFFRyxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQWMsR0FBRyxLQUFLO1FBQ3pDLElBQUksY0FBYyxFQUFFLENBQUM7WUFDbkIsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNyQixDQUFDO1FBRUQsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDdEMsT0FBTyxRQUFRLENBQUMsSUFBSSxDQUFDO0lBQ3ZCLENBQUM7SUFFTyxLQUFLLENBQUMsT0FBTztRQUNuQixNQUFNLGFBQWEsR0FBOEI7WUFDL0MsWUFBWSxFQUFFLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSztTQUN6QyxDQUFDO1FBQ0YsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUUvQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUM5QixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FDWixRQUFRLEVBQ1IsYUFBYSxDQUNYLElBQUksQ0FBQyxTQUFTO2lCQUNYLElBQUksQ0FDSCxJQUFJLENBQUMsUUFBUSxFQUNiLElBQUksZUFBZSxDQUFDLEVBQUUsR0FBRyxhQUFhLEVBQUUsQ0FBQyxFQUN6QztnQkFDRSxPQUFPLEVBQUUsSUFBSSxXQUFXLEVBQUUsQ0FBQyxHQUFHLENBQzVCLGNBQWMsRUFDZCxrREFBa0QsQ0FDbkQ7Z0JBQ0QsWUFBWSxFQUFFLE1BQU07YUFDckIsQ0FDRjtpQkFDQSxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FDM0QsQ0FBQyxLQUFLLENBQUMsQ0FBQyxLQUFZLEVBQUUsRUFBRTtnQkFDdkIsTUFBTSxJQUFJLGFBQWEsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDekMsQ0FBQyxDQUFDLENBQ0gsQ0FBQztRQUNKLENBQUM7UUFFRCwwREFBMEQ7UUFDMUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNsQyxDQUFDOzhHQXBEVSxtQkFBbUIsa0JBTXBCLGdDQUFnQztrSEFOL0IsbUJBQW1CLGNBRmxCLE1BQU07OzJGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OzBCQU9JLE1BQU07MkJBQUMsZ0NBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cEhlYWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBJbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGxhc3RWYWx1ZUZyb20sIG1hcCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgUmVzcG9uc2VFcnJvciB9IGZyb20gJy4uL2V4Y2VwdGlvbnMtaGFuZGxpbmcvZXJyb3JzL3Jlc3BvbnNlLWVycm9yLmNsYXNzJztcbmltcG9ydCB7IFNlY3VyZUFwaUNsaWVudCB9IGZyb20gJy4uL2h0dHAvc2VjdXJlLWFwaS9zZWN1cmUtYXBpLnNlcnZpY2UnO1xuaW1wb3J0IHsgU2V0dGluZ3NTZXJ2aWNlIH0gZnJvbSAnLi4vc2V0dGluZ3Mvc2V0dGluZ3Muc2VydmljZSc7XG5pbXBvcnQgeyBTYXZlZE1ldGhvZHNSZXF1ZXN0UGFyYW1zIH0gZnJvbSAnLi9zYXZlZC1tZXRob2RzLXJlcXVlc3QtcGFyYW1zLmludGVyZmFjZSc7XG5pbXBvcnQgeyBTYXZlZE1ldGhvZHNSZXNwb25zZUFwaSB9IGZyb20gJy4vc2F2ZWQtbWV0aG9kcy1yZXNwb25zZS5pbnRlcmZhY2UnO1xuaW1wb3J0IHtcbiAgU2F2ZWRNZXRob2RzUmVzcG9uc2VGYWN0b3J5LFxuICBzYXZlZE1ldGhvZHNSZXNwb25zZUZhY3RvcnlUb2tlbixcbn0gZnJvbSAnLi9zYXZlZC1tZXRob2RzLXJlc3BvbnNlLnRva2VuJztcbmltcG9ydCB7IFNhdmVkTWV0aG9kc1Jlc3BvbnNlIH0gZnJvbSAnLi9zYXZlZC1tZXRob2RzLXJlc3BvbnNlLmNsYXNzJztcbmltcG9ydCB7IFNhdmVkTWV0aG9kIH0gZnJvbSAnLi9zYXZlZC1tZXRob2QuaW50ZXJmYWNlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFNhdmVkTWV0aG9kc1NlcnZpY2Uge1xuICBwcml2YXRlIHJlYWRvbmx5IGFwaVJvdXRlID0gJ3NhdmVkbWV0aG9kcyc7XG5cbiAgcHJpdmF0ZSByZWFkb25seSBjYWNoZSA9IG5ldyBNYXA8c3RyaW5nLCBQcm9taXNlPFNhdmVkTWV0aG9kc1Jlc3BvbnNlPj4oKTtcblxuICBwdWJsaWMgY29uc3RydWN0b3IoXG4gICAgQEluamVjdChzYXZlZE1ldGhvZHNSZXNwb25zZUZhY3RvcnlUb2tlbilcbiAgICBwcml2YXRlIHJlYWRvbmx5IHJlc3BvbnNlRmFjdG9yeTogU2F2ZWRNZXRob2RzUmVzcG9uc2VGYWN0b3J5LFxuICAgIHByaXZhdGUgcmVhZG9ubHkgc2V0dGluZ3NTZXJ2aWNlOiBTZXR0aW5nc1NlcnZpY2UsXG4gICAgcHJpdmF0ZSByZWFkb25seSBzZWN1cmVBcGk6IFNlY3VyZUFwaUNsaWVudFxuICApIHt9XG5cbiAgcHVibGljIGFzeW5jIGdldExpc3QobmVlZFJlc2V0Q2FjaGUgPSBmYWxzZSk6IFByb21pc2U8U2F2ZWRNZXRob2RbXT4ge1xuICAgIGlmIChuZWVkUmVzZXRDYWNoZSkge1xuICAgICAgdGhpcy5jYWNoZS5jbGVhcigpO1xuICAgIH1cblxuICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgdGhpcy5yZXF1ZXN0KCk7XG4gICAgcmV0dXJuIHJlc3BvbnNlLmxpc3Q7XG4gIH1cblxuICBwcml2YXRlIGFzeW5jIHJlcXVlc3QoKTogUHJvbWlzZTxTYXZlZE1ldGhvZHNSZXNwb25zZT4ge1xuICAgIGNvbnN0IHJlcXVlc3RQYXJhbXM6IFNhdmVkTWV0aG9kc1JlcXVlc3RQYXJhbXMgPSB7XG4gICAgICBhY2Nlc3NfdG9rZW46IHRoaXMuc2V0dGluZ3NTZXJ2aWNlLnRva2VuLFxuICAgIH07XG4gICAgY29uc3QgY2FjaGVLZXkgPSBKU09OLnN0cmluZ2lmeShyZXF1ZXN0UGFyYW1zKTtcblxuICAgIGlmICghdGhpcy5jYWNoZS5oYXMoY2FjaGVLZXkpKSB7XG4gICAgICB0aGlzLmNhY2hlLnNldChcbiAgICAgICAgY2FjaGVLZXksXG4gICAgICAgIGxhc3RWYWx1ZUZyb20oXG4gICAgICAgICAgdGhpcy5zZWN1cmVBcGlcbiAgICAgICAgICAgIC5wb3N0PFNhdmVkTWV0aG9kc1Jlc3BvbnNlQXBpPihcbiAgICAgICAgICAgICAgdGhpcy5hcGlSb3V0ZSxcbiAgICAgICAgICAgICAgbmV3IFVSTFNlYXJjaFBhcmFtcyh7IC4uLnJlcXVlc3RQYXJhbXMgfSksXG4gICAgICAgICAgICAgIHtcbiAgICAgICAgICAgICAgICBoZWFkZXJzOiBuZXcgSHR0cEhlYWRlcnMoKS5zZXQoXG4gICAgICAgICAgICAgICAgICAnQ29udGVudC1UeXBlJyxcbiAgICAgICAgICAgICAgICAgICdhcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQ7IGNoYXJzZXQ9dXRmLTgnXG4gICAgICAgICAgICAgICAgKSxcbiAgICAgICAgICAgICAgICByZXNwb25zZVR5cGU6ICdqc29uJyxcbiAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgKVxuICAgICAgICAgICAgLnBpcGUobWFwKChyZXNwb25zZSkgPT4gdGhpcy5yZXNwb25zZUZhY3RvcnkocmVzcG9uc2UpKSlcbiAgICAgICAgKS5jYXRjaCgoZXJyb3I6IEVycm9yKSA9PiB7XG4gICAgICAgICAgdGhyb3cgbmV3IFJlc3BvbnNlRXJyb3IoZXJyb3IubWVzc2FnZSk7XG4gICAgICAgIH0pXG4gICAgICApO1xuICAgIH1cblxuICAgIC8vIEB0cy1leHBlY3QtZXJyb3IgdGhlIG1hcCBhbHJlYWR5IGhhcyB0aGUgY2FjaGUgd2l0aCBrZXlcbiAgICByZXR1cm4gdGhpcy5jYWNoZS5nZXQoY2FjaGVLZXkpO1xuICB9XG59XG4iXX0=