@xsolla/payment-client-core 0.2.21 → 0.2.22

package/esm2022/lib/core/user-behaviour-analytics/event-builder/event-builder.service.mjs

@@ -0,0 +1,144 @@
+import { Inject, Injectable, isDevMode } from '@angular/core';
+import { EventParameterType } from './event-parameter-types';
+import { Device } from '../../user-agent/device.enum';
+import { windowToken } from '../../window.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../../settings/settings.service";
+import * as i2 from "../../user-agent/user-agent.service";
+export class EventBuilderService {
+    constructor(settingsService, userAgentService, window) {
+        this.settingsService = settingsService;
+        this.userAgentService = userAgentService;
+        this.window = window;
+    }
+    createEvent(options, userSessionOptions) {
+        return {
+            action: options.action,
+            type: options.type,
+            value: this.convertToEventParameterType(options.value, options.valueType ?? EventParameterType.string),
+            state: options.state,
+            date: this.getDate(options.date),
+            milliseconds: options.date.getTime(),
+            timezone: this.getTimezone(options.date),
+            session_id: this.settingsService.unsafeUtilsResponse?.user?.session_id ?? null,
+            referrer_url: this.window?.document?.referrer,
+            project_id: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.project?.id, EventParameterType.int),
+            payment_country: this.convertToEventParameterType(options.invoice?.payment_country ??
+                this.settingsService.unsafeUtilsResponse?.user?.country?.value, EventParameterType.string),
+            geotype_id: this.convertToEventParameterType(options.invoice?.geotype_id, EventParameterType.int),
+            instance_id: this.convertToEventParameterType(options.instanceId ??
+                this.getPaymentMethodId(userSessionOptions.instanceId), EventParameterType.int),
+            payment_method_contr_id: this.convertToEventParameterType(options.invoice?.payment_method_contr_id, EventParameterType.int),
+            ps_type: this.convertToEventParameterType(options.invoice?.ps_type, EventParameterType.int),
+            is_pay_with_saved_method: this.convertToEventParameterType(userSessionOptions.isPayWithSavedMethod, EventParameterType.bool),
+            purchase_invoice_id: this.convertToEventParameterType(options.invoice?.purchase_invoice_id, EventParameterType.int),
+            purchase_external_id: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.purchase_external_id, EventParameterType.string),
+            purchase_type: this.settingsService.unsafeUtilsResponse?.purchase
+                ?.purchase_type,
+            purchase_sum: this.convertToEventParameterType(options.invoice?.purchase_sum, EventParameterType.float),
+            purchase_currency: this.convertToEventParameterType(options.invoice?.purchase_currency, EventParameterType.string),
+            purchase_sku: this.convertToEventParameterType(options.invoice?.purchase_sku, EventParameterType.string),
+            purchase_digital_content_sku: null,
+            purchase_description: this.convertToEventParameterType(options.invoice?.purchase_description, EventParameterType.string),
+            virtual_currency_amount: null, // TODO: add value
+            digital_content_cart_id: this.convertToEventParameterType(options.invoice?.digital_content_cart_id, EventParameterType.int),
+            digital_good_cart_id: this.convertToEventParameterType(options.invoice?.digital_good_cart_id, EventParameterType.int),
+            coupon_code: this.convertToEventParameterType(userSessionOptions.couponCode, EventParameterType.string),
+            theme_version: this.userAgentService.isMobileDevice
+                ? Device.mobile
+                : Device.desktop,
+            subscription_package_id: this.convertToEventParameterType(userSessionOptions.subscriptionPackageId, EventParameterType.int),
+            subscription_product_id: this.convertToEventParameterType(userSessionOptions.subscriptionProductId, EventParameterType.int),
+            subscription_recurrent_id: this.convertToEventParameterType(userSessionOptions.subscriptionRecurrentId, EventParameterType.int),
+            user_id: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.requisites?.id, EventParameterType.string),
+            user_access_token: this.settingsService.token,
+            user_name: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.requisites?.v2, EventParameterType.string),
+            user_email: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.email?.value, EventParameterType.string),
+            user_country: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.country?.value, EventParameterType.string),
+            user_ip: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.ip, EventParameterType.string),
+            user_mobile_operator_name: this.convertToEventParameterType(userSessionOptions.userMobileOperatorName, EventParameterType.string),
+            user_operation_system: this.userAgentService.platform,
+            user_browser: this.userAgentService.browserDescription,
+            user_browser_version: this.userAgentService.browserVersion,
+            user_locale: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.local, EventParameterType.string),
+            user_utm: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.user?.utm_parameters, EventParameterType.string),
+            xsolla_product_tag: this.convertToEventParameterType(this.settingsService.unsafeUtilsResponse?.xsolla_product_tag, EventParameterType.string),
+            experiment_id: null,
+            is_test_session: +isDevMode(),
+            babka_value: null,
+            extra_value: this.convertToEventParameterType(options?.extraValue, EventParameterType.string),
+            is_subscription: this.convertToEventParameterType(this.isSubscription(), EventParameterType.bool),
+            is_iframe: this.convertToEventParameterType(this.window.parent !== this.window, EventParameterType.bool),
+            web3wallet: null, // TODO: add value
+            dimension_1: this.convertToEventParameterType(options?.dimension1, EventParameterType.string),
+            dimension_2: this.convertToEventParameterType(options?.dimension2, EventParameterType.string),
+            dimension_3: this.convertToEventParameterType(options?.dimension3, EventParameterType.string),
+            dimension_4: this.convertToEventParameterType(options?.dimension4, EventParameterType.string),
+            dimension_5: this.convertToEventParameterType(options?.dimension5, EventParameterType.string),
+            client_version: 'Headless Checkout',
+        };
+    }
+    getDate(date) {
+        const nullIndex = 0;
+        return date.toISOString().replace('T', ' ').replace('Z', '').split('.')[nullIndex];
+    }
+    getTimezone(date) {
+        const hour = 60;
+        const nullHour = 0;
+        const hourOffset = -date.getTimezoneOffset() / hour;
+        if (hourOffset === nullHour) {
+            return '0';
+        }
+        return hourOffset > nullHour ? `+${hourOffset}` : hourOffset.toString();
+    }
+    convertToEventParameterType(value, type
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value === 'boolean') {
+            value = value ? 1 : 0;
+        }
+        switch (type) {
+            case EventParameterType.string:
+                return String(value);
+            case EventParameterType.int:
+                value = parseInt(String(value), 10);
+                return isNaN(value) ? 0 : value;
+            case EventParameterType.intArray:
+                return Array.isArray(value) ? value : [];
+            case EventParameterType.float:
+                value = parseFloat(String(value));
+                return isNaN(value) ? 0 : value;
+            case EventParameterType.bool:
+                return value ? 1 : 0;
+        }
+    }
+    convertValueForPostMessage(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        return String(value);
+    }
+    isSubscription() {
+        return (this.settingsService.unsafeUtilsResponse?.purchase?.purchase_type ===
+            'subscription');
+    }
+    getPaymentMethodId(instanceId) {
+        return (this.settingsService.unsafeUtilsResponse?.settings?.payment_system ??
+            instanceId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: EventBuilderService, deps: [{ token: i1.SettingsService }, { token: i2.UserAgentService }, { token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: EventBuilderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: EventBuilderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SettingsService }, { type: i2.UserAgentService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-builder.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/user-behaviour-analytics/event-builder/event-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, isDevMode } from '@angular/core';\nimport { EventParameterType } from './event-parameter-types';\nimport { UserBehaviourEvent } from './user-behaviour-event.interface';\nimport { Purchase } from './purchase.type';\nimport { CreateEventMethodOptionsInterface } from '../user-behaviour-analytics.interface';\nimport { SettingsService } from '../../settings/settings.service';\nimport { UserAgentService } from '../../user-agent/user-agent.service';\nimport { ExtendedWindow } from '../../extended-window.interface';\nimport { Device } from '../../user-agent/device.enum';\nimport { windowToken } from '../../window.token';\nimport { UserSessionOptions } from '../user-session-options';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class EventBuilderService {\n  public constructor(\n    private readonly settingsService: SettingsService,\n    private readonly userAgentService: UserAgentService,\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow\n  ) {}\n\n  public createEvent(\n    options: CreateEventMethodOptionsInterface,\n    userSessionOptions: UserSessionOptions\n  ): UserBehaviourEvent {\n    return {\n      action: options.action,\n      type: options.type,\n      value: this.convertToEventParameterType(\n        options.value,\n        options.valueType ?? EventParameterType.string\n      ),\n      state: options.state,\n      date: this.getDate(options.date),\n      milliseconds: options.date.getTime(),\n      timezone: this.getTimezone(options.date),\n      session_id:\n        this.settingsService.unsafeUtilsResponse?.user?.session_id ?? null,\n      referrer_url: this.window?.document?.referrer,\n      project_id: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.project?.id,\n        EventParameterType.int\n      ),\n      payment_country: this.convertToEventParameterType(\n        options.invoice?.payment_country ??\n          this.settingsService.unsafeUtilsResponse?.user?.country?.value,\n        EventParameterType.string\n      ),\n      geotype_id: this.convertToEventParameterType(\n        options.invoice?.geotype_id,\n        EventParameterType.int\n      ),\n      instance_id: this.convertToEventParameterType(\n        options.instanceId ??\n          this.getPaymentMethodId(userSessionOptions.instanceId),\n        EventParameterType.int\n      ),\n      payment_method_contr_id: this.convertToEventParameterType(\n        options.invoice?.payment_method_contr_id,\n        EventParameterType.int\n      ),\n      ps_type: this.convertToEventParameterType(\n        options.invoice?.ps_type,\n        EventParameterType.int\n      ),\n      is_pay_with_saved_method: this.convertToEventParameterType(\n        userSessionOptions.isPayWithSavedMethod,\n        EventParameterType.bool\n      ),\n      purchase_invoice_id: this.convertToEventParameterType(\n        options.invoice?.purchase_invoice_id,\n        EventParameterType.int\n      ),\n      purchase_external_id: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.purchase_external_id,\n        EventParameterType.string\n      ),\n      purchase_type: this.settingsService.unsafeUtilsResponse?.purchase\n        ?.purchase_type as Purchase,\n      purchase_sum: this.convertToEventParameterType(\n        options.invoice?.purchase_sum,\n        EventParameterType.float\n      ),\n      purchase_currency: this.convertToEventParameterType(\n        options.invoice?.purchase_currency,\n        EventParameterType.string\n      ),\n      purchase_sku: this.convertToEventParameterType(\n        options.invoice?.purchase_sku,\n        EventParameterType.string\n      ),\n      purchase_digital_content_sku: null,\n      purchase_description: this.convertToEventParameterType(\n        options.invoice?.purchase_description,\n        EventParameterType.string\n      ),\n      virtual_currency_amount: null, // TODO: add value\n      digital_content_cart_id: this.convertToEventParameterType(\n        options.invoice?.digital_content_cart_id,\n        EventParameterType.int\n      ),\n      digital_good_cart_id: this.convertToEventParameterType(\n        options.invoice?.digital_good_cart_id,\n        EventParameterType.int\n      ),\n      coupon_code: this.convertToEventParameterType(\n        userSessionOptions.couponCode,\n        EventParameterType.string\n      ),\n      theme_version: this.userAgentService.isMobileDevice\n        ? Device.mobile\n        : Device.desktop,\n      subscription_package_id: this.convertToEventParameterType(\n        userSessionOptions.subscriptionPackageId,\n        EventParameterType.int\n      ),\n      subscription_product_id: this.convertToEventParameterType(\n        userSessionOptions.subscriptionProductId,\n        EventParameterType.int\n      ),\n      subscription_recurrent_id: this.convertToEventParameterType(\n        userSessionOptions.subscriptionRecurrentId,\n        EventParameterType.int\n      ),\n      user_id: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.requisites?.id,\n        EventParameterType.string\n      ),\n      user_access_token: this.settingsService.token,\n      user_name: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.requisites?.v2,\n        EventParameterType.string\n      ),\n      user_email: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.email?.value,\n        EventParameterType.string\n      ),\n      user_country: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.country?.value,\n        EventParameterType.string\n      ),\n      user_ip: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.ip,\n        EventParameterType.string\n      ),\n      user_mobile_operator_name: this.convertToEventParameterType(\n        userSessionOptions.userMobileOperatorName,\n        EventParameterType.string\n      ),\n      user_operation_system: this.userAgentService.platform,\n      user_browser: this.userAgentService.browserDescription,\n      user_browser_version: this.userAgentService.browserVersion,\n      user_locale: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.local,\n        EventParameterType.string\n      ),\n      user_utm: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.user?.utm_parameters,\n        EventParameterType.string\n      ),\n      xsolla_product_tag: this.convertToEventParameterType(\n        this.settingsService.unsafeUtilsResponse?.xsolla_product_tag,\n        EventParameterType.string\n      ),\n      experiment_id: null,\n      is_test_session: +isDevMode(),\n      babka_value: null,\n      extra_value: this.convertToEventParameterType(\n        options?.extraValue,\n        EventParameterType.string\n      ),\n      is_subscription: this.convertToEventParameterType(\n        this.isSubscription(),\n        EventParameterType.bool\n      ),\n      is_iframe: this.convertToEventParameterType(\n        this.window.parent !== this.window,\n        EventParameterType.bool\n      ),\n      web3wallet: null, // TODO: add value\n      dimension_1: this.convertToEventParameterType(\n        options?.dimension1,\n        EventParameterType.string\n      ),\n      dimension_2: this.convertToEventParameterType(\n        options?.dimension2,\n        EventParameterType.string\n      ),\n      dimension_3: this.convertToEventParameterType(\n        options?.dimension3,\n        EventParameterType.string\n      ),\n      dimension_4: this.convertToEventParameterType(\n        options?.dimension4,\n        EventParameterType.string\n      ),\n      dimension_5: this.convertToEventParameterType(\n        options?.dimension5,\n        EventParameterType.string\n      ),\n      client_version: 'Headless Checkout',\n    };\n  }\n\n  private getDate(date: Date): string {\n    const nullIndex = 0;\n    return date.toISOString().replace('T', ' ').replace('Z', '').split('.')[\n      nullIndex\n    ];\n  }\n\n  private getTimezone(date: Date): string {\n    const hour = 60;\n    const nullHour = 0;\n    const hourOffset = -date.getTimezoneOffset() / hour;\n\n    if (hourOffset === nullHour) {\n      return '0';\n    }\n\n    return hourOffset > nullHour ? `+${hourOffset}` : hourOffset.toString();\n  }\n\n  private convertToEventParameterType(\n    value: boolean | number | number[] | string | null | undefined,\n    type: EventParameterType\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): any | null {\n    if (value === null || value === undefined) {\n      return null;\n    }\n\n    if (typeof value === 'boolean') {\n      value = value ? 1 : 0;\n    }\n\n    switch (type) {\n      case EventParameterType.string:\n        return String(value);\n      case EventParameterType.int:\n        value = parseInt(String(value), 10);\n        return isNaN(value) ? 0 : value;\n      case EventParameterType.intArray:\n        return Array.isArray(value) ? value : [];\n      case EventParameterType.float:\n        value = parseFloat(String(value));\n        return isNaN(value) ? 0 : value;\n      case EventParameterType.bool:\n        return value ? 1 : 0;\n    }\n  }\n\n  private convertValueForPostMessage(\n    value: string | number[] | null\n  ): string | null {\n    if (value === null || value === undefined) {\n      return null;\n    }\n    return String(value);\n  }\n\n  private isSubscription(): boolean {\n    return (\n      this.settingsService.unsafeUtilsResponse?.purchase?.purchase_type ===\n      'subscription'\n    );\n  }\n\n  private getPaymentMethodId(instanceId: number | null): number | null {\n    return (\n      this.settingsService.unsafeUtilsResponse?.settings?.payment_system ??\n      instanceId\n    );\n  }\n}\n"]}

package/esm2022/lib/core/user-behaviour-analytics/user-behaviour-analytics.service.mjs

@@ -0,0 +1,158 @@
+import { Injectable } from '@angular/core';
+import { userBehaviourEventTypes } from './user-behaviour-event/user-behaviour-event-types';
+import { eventCategories } from './user-behaviour-event/user-behaviour-event-categories';
+import { Subject } from 'rxjs';
+import { UserBehaviourEventName } from './user-behaviour-event-name.enum';
+import { oneTimeAnalyticsEvents } from './one-time-analytics-events.const';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./event-builder/event-builder.service";
+import * as i3 from "../settings/settings.service";
+export class UserBehaviourAnalyticsService {
+    set isPayWithSavedMethod(value) {
+        this.userSessionOptions.isPayWithSavedMethod = value;
+    }
+    set subscriptionPackageId(value) {
+        this.userSessionOptions.subscriptionPackageId = value;
+    }
+    set couponCode(value) {
+        this.userSessionOptions.couponCode = value;
+    }
+    set paymentStatus(value) {
+        this.userSessionOptions.paymentStatus = value;
+    }
+    get sessionOptions() {
+        return this.userSessionOptions;
+    }
+    get purchaseType() {
+        return this.settingsService.unsafeUtilsResponse?.purchase?.purchase_type
+            ? 'subscription'
+            : null;
+    }
+    constructor(http, eventBuilderService, settingsService) {
+        this.http = http;
+        this.eventBuilderService = eventBuilderService;
+        this.settingsService = settingsService;
+        this.apiUrl = 'https://datagather.xsolla.com/paystation-user-sessions';
+        this._events$ = new Subject();
+        this.userSessionOptions = {
+            invoice: null,
+            instanceId: null,
+            subscriptionRecurrentId: null,
+            userMobileOperatorName: null,
+            isPayWithSavedMethod: false,
+            subscriptionPackageId: null,
+            subscriptionProductId: null,
+            couponCode: null,
+            totalSum: null,
+            totalCurrency: null,
+            paymentInstanceName: null,
+            paymentStatus: null,
+        };
+        this.sentEvents = new Set();
+    }
+    init() {
+        this.setPid(this.settingsService.unsafeUtilsResponse?.purchase?.payment_system?.id);
+        this.onOpenPayStation();
+    }
+    setPid(pid) {
+        if (pid) {
+            this.userSessionOptions.instanceId = pid;
+        }
+    }
+    fillUserSession(paymentForm) {
+        if (paymentForm.subscriptionRecurrentId) {
+            this.userSessionOptions.subscriptionRecurrentId =
+                paymentForm.subscriptionRecurrentId;
+        }
+        const operator = paymentForm.fields.find((field) => field.name === 'operator');
+        if (operator) {
+            this.userSessionOptions.userMobileOperatorName = operator.value;
+        }
+        if (paymentForm.pid) {
+            this.setPid(paymentForm.pid);
+        }
+        if (paymentForm.userSession) {
+            this.userSessionOptions.invoice = paymentForm.userSession;
+            const createInvoiceOptions = {
+                eventCategory: eventCategories.withInvoice,
+            };
+            this.send('create-invoice', userBehaviourEventTypes.manual, createInvoiceOptions);
+            if (paymentForm.errors?.length) {
+                this.resetInvoice();
+            }
+        }
+        const total = paymentForm?.summary?.finance?.total;
+        if (total) {
+            this.userSessionOptions.totalSum = total.amount;
+            this.userSessionOptions.totalCurrency = total.currency;
+        }
+        if (paymentForm.title) {
+            this.userSessionOptions.paymentInstanceName = paymentForm.title;
+        }
+    }
+    send(action, type, options) {
+        if (oneTimeAnalyticsEvents.has(action) && this.sentEvents.has(action)) {
+            return;
+        }
+        const date = new Date();
+        const invoice = options?.eventCategory === eventCategories.withInvoice
+            ? this.userSessionOptions.invoice
+            : null;
+        const eventOptions = {
+            action,
+            type,
+            value: options?.value ?? null,
+            valueType: options?.valueType ?? null,
+            date,
+            invoice,
+            state: '',
+            extraValue: options?.extraValue ?? null,
+            purchase_type: options?.purchaseType ?? null,
+            instanceId: options?.instanceId ?? null,
+            dimension1: options?.dimension1 ?? null,
+            dimension2: options?.dimension2 ?? null,
+            dimension3: options?.dimension3 ?? null,
+            dimension4: options?.dimension4 ?? null,
+            dimension5: options?.dimension5 ?? null,
+        };
+        const sendEvent = () => {
+            this.sentEvents.add(action);
+            const event = this.eventBuilderService.createEvent(eventOptions, this.userSessionOptions);
+            this._events$.next(event);
+            const requestBody = JSON.stringify(event);
+            if (navigator.sendBeacon) {
+                navigator.sendBeacon(this.apiUrl, requestBody);
+            }
+            else {
+                void this.http.post(this.apiUrl, requestBody).toPromise();
+            }
+        };
+        if (options?.syncRequest) {
+            sendEvent();
+            return;
+        }
+        setTimeout(() => sendEvent());
+    }
+    onOpenPayStation() {
+        this.send(UserBehaviourEventName.openPaystation, userBehaviourEventTypes.open, {
+            value: null,
+            purchaseType: this.purchaseType,
+        });
+    }
+    resetInvoice() {
+        this.userSessionOptions.invoice = null;
+    }
+    resetPid() {
+        this.userSessionOptions.instanceId = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserBehaviourAnalyticsService, deps: [{ token: i1.HttpClient }, { token: i2.EventBuilderService }, { token: i3.SettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserBehaviourAnalyticsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserBehaviourAnalyticsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.EventBuilderService }, { type: i3.SettingsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-behaviour-analytics.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/user-behaviour-analytics/user-behaviour-analytics.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { userBehaviourEventTypes } from './user-behaviour-event/user-behaviour-event-types';\nimport { eventCategories } from './user-behaviour-event/user-behaviour-event-categories';\nimport {\n  SendEventMethodOptionsInterface,\n  CreateEventMethodOptionsInterface,\n} from './user-behaviour-analytics.interface';\nimport { EventBuilderService } from './event-builder/event-builder.service';\nimport { UserBehaviourEvent } from './event-builder/user-behaviour-event.interface';\nimport { Subject } from 'rxjs';\nimport { Invoice } from './event-builder/invoice.interface';\nimport { UserBehaviourEventName } from './user-behaviour-event-name.enum';\nimport { oneTimeAnalyticsEvents } from './one-time-analytics-events.const';\nimport { SettingsService } from '../settings/settings.service';\nimport { Field } from '../payment/field.interface';\nimport { XpsResponse } from '../payment/xps-response.interface';\nimport { UserSessionOptions } from './user-session-options';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UserBehaviourAnalyticsService {\n  public set isPayWithSavedMethod(value: boolean) {\n    this.userSessionOptions.isPayWithSavedMethod = value;\n  }\n\n  public set subscriptionPackageId(value: number) {\n    this.userSessionOptions.subscriptionPackageId = value;\n  }\n\n  public set couponCode(value: string) {\n    this.userSessionOptions.couponCode = value;\n  }\n\n  public set paymentStatus(value: string) {\n    this.userSessionOptions.paymentStatus = value;\n  }\n\n  public get sessionOptions(): UserSessionOptions {\n    return this.userSessionOptions;\n  }\n\n  private get purchaseType(): string | null {\n    return this.settingsService.unsafeUtilsResponse?.purchase?.purchase_type\n      ? 'subscription'\n      : null;\n  }\n\n  private readonly apiUrl: string =\n    'https://datagather.xsolla.com/paystation-user-sessions';\n\n  private readonly _events$ = new Subject<UserBehaviourEvent>();\n\n  private readonly userSessionOptions: UserSessionOptions = {\n    invoice: null,\n    instanceId: null,\n    subscriptionRecurrentId: null,\n    userMobileOperatorName: null,\n    isPayWithSavedMethod: false,\n    subscriptionPackageId: null,\n    subscriptionProductId: null,\n    couponCode: null,\n    totalSum: null,\n    totalCurrency: null,\n    paymentInstanceName: null,\n    paymentStatus: null,\n  };\n\n  private readonly sentEvents = new Set();\n\n  public constructor(\n    private readonly http: HttpClient,\n    private readonly eventBuilderService: EventBuilderService,\n    private readonly settingsService: SettingsService\n  ) {}\n\n  public init(): undefined | void {\n    this.setPid(\n      this.settingsService.unsafeUtilsResponse?.purchase?.payment_system?.id\n    );\n    this.onOpenPayStation();\n  }\n\n  public setPid(pid?: number | null): void {\n    if (pid) {\n      this.userSessionOptions.instanceId = pid;\n    }\n  }\n\n  public fillUserSession(paymentForm: {\n    fields: Field[];\n    subscriptionRecurrentId?: number;\n    userSession?: Invoice;\n    pid: XpsResponse['pid'];\n    errors: XpsResponse['errors'];\n    summary: XpsResponse['summary'];\n    title: string;\n  }): void {\n    if (paymentForm.subscriptionRecurrentId) {\n      this.userSessionOptions.subscriptionRecurrentId =\n        paymentForm.subscriptionRecurrentId;\n    }\n\n    const operator: Field | undefined = paymentForm.fields.find(\n      (field: Field) => field.name === 'operator'\n    );\n    if (operator) {\n      this.userSessionOptions.userMobileOperatorName = operator.value;\n    }\n\n    if (paymentForm.pid) {\n      this.setPid(paymentForm.pid);\n    }\n\n    if (paymentForm.userSession) {\n      this.userSessionOptions.invoice = paymentForm.userSession;\n      const createInvoiceOptions = {\n        eventCategory: eventCategories.withInvoice,\n      };\n      this.send(\n        'create-invoice',\n        userBehaviourEventTypes.manual,\n        createInvoiceOptions\n      );\n\n      if (paymentForm.errors?.length) {\n        this.resetInvoice();\n      }\n    }\n\n    const total = paymentForm?.summary?.finance?.total;\n    if (total) {\n      this.userSessionOptions.totalSum = total.amount;\n      this.userSessionOptions.totalCurrency = total.currency;\n    }\n\n    if (paymentForm.title) {\n      this.userSessionOptions.paymentInstanceName = paymentForm.title;\n    }\n  }\n\n  public send(\n    action: string,\n    type: keyof typeof userBehaviourEventTypes,\n    options?: SendEventMethodOptionsInterface\n  ): void {\n    if (oneTimeAnalyticsEvents.has(action) && this.sentEvents.has(action)) {\n      return;\n    }\n\n    const date = new Date();\n    const invoice =\n      options?.eventCategory === eventCategories.withInvoice\n        ? this.userSessionOptions.invoice\n        : null;\n    const eventOptions: CreateEventMethodOptionsInterface = {\n      action,\n      type,\n      value: options?.value ?? null,\n      valueType: options?.valueType ?? null,\n      date,\n      invoice,\n      state: '',\n      extraValue: options?.extraValue ?? null,\n      purchase_type: options?.purchaseType ?? null,\n      instanceId: options?.instanceId ?? null,\n      dimension1: options?.dimension1 ?? null,\n      dimension2: options?.dimension2 ?? null,\n      dimension3: options?.dimension3 ?? null,\n      dimension4: options?.dimension4 ?? null,\n      dimension5: options?.dimension5 ?? null,\n    };\n\n    const sendEvent = (): void => {\n      this.sentEvents.add(action);\n      const event: UserBehaviourEvent = this.eventBuilderService.createEvent(\n        eventOptions,\n        this.userSessionOptions\n      );\n      this._events$.next(event);\n      const requestBody = JSON.stringify(event);\n      if (navigator.sendBeacon) {\n        navigator.sendBeacon(this.apiUrl, requestBody);\n      } else {\n        void this.http.post(this.apiUrl, requestBody).toPromise();\n      }\n    };\n\n    if (options?.syncRequest) {\n      sendEvent();\n      return;\n    }\n\n    setTimeout(() => sendEvent());\n  }\n\n  private onOpenPayStation(): void {\n    this.send(\n      UserBehaviourEventName.openPaystation,\n      userBehaviourEventTypes.open,\n      {\n        value: null,\n        purchaseType: this.purchaseType,\n      }\n    );\n  }\n\n  private resetInvoice(): void {\n    this.userSessionOptions.invoice = null;\n  }\n\n  private resetPid(): void {\n    this.userSessionOptions.instanceId = null;\n  }\n}\n"]}

package/esm2022/lib/core/web-socket/centrifugo-web-socket.service.mjs

@@ -0,0 +1,200 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { WsError } from '../exceptions-handling/errors/ws-error.class';
+import { ErrorTags } from '../exceptions-handling/errors/elk-error-types.enum';
+import { WebSocketClientType } from './web-socket-client-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../exceptions-handling/elk/elk-logger.service";
+export class CentrifugoWebSocketService {
+    static { this.reconnectionTimeoutIncrementFactor = 2; }
+    static { this.timeoutsMs = {
+        reconnection: 1000,
+        reconnectionMaxDeviation: 1000,
+    }; }
+    constructor(elkLoggerService) {
+        this.elkLoggerService = elkLoggerService;
+        this.type = WebSocketClientType.centrifugo;
+        this.reconnectionTimerId = null;
+        this.isConnectionOpen = false;
+        this.isConnecting = false;
+        this.incomingMessages$ = new Subject();
+        this.successfulReconnectionEventsProxy$ = new Subject();
+    }
+    async open(url, channel) {
+        if (url === this.url && channel === this.channel) {
+            return;
+        }
+        try {
+            this.url = url;
+            this.channel = channel;
+            await this.createConnection(url, channel);
+        }
+        catch (error) {
+            // @ts-expect-error error is unknown
+            const message = (error?.message || error);
+            const unknownError = new WsError(`unknown websocket error: ${message}`, channel);
+            this.elkLoggerService.handleError(unknownError);
+        }
+    }
+    close() {
+        this.clearReconnectionTimer();
+        if (!this.isConnectionOpen) {
+            return;
+        }
+        this.connection.disconnect();
+    }
+    get messages$() {
+        return (this.incomingMessages$
+            .asObservable()
+            // event don't respect type from argument, it's weird
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            .pipe(map((event) => event.data)));
+    }
+    subscribeOnSuccessfulReconnection(next) {
+        return this.successfulReconnectionEventsProxy$
+            .asObservable()
+            .subscribe(next);
+    }
+    clearReconnectionTimer() {
+        if (this.reconnectionTimerId) {
+            clearTimeout(this.reconnectionTimerId);
+            this.reconnectionTimerId = null;
+        }
+    }
+    setFirstReconnectionTimeout() {
+        const min = CentrifugoWebSocketService.timeoutsMs.reconnection -
+            CentrifugoWebSocketService.timeoutsMs.reconnectionMaxDeviation;
+        const max = CentrifugoWebSocketService.timeoutsMs.reconnection +
+            CentrifugoWebSocketService.timeoutsMs.reconnectionMaxDeviation;
+        this.reconnectionTimeoutMs =
+            Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    incrementReconnectionTimeout() {
+        this.reconnectionTimeoutMs =
+            this.reconnectionTimeoutMs *
+                CentrifugoWebSocketService.reconnectionTimeoutIncrementFactor;
+    }
+    async getCentrifugoClient() {
+        return import('centrifuge').then((module) => module.Centrifuge);
+    }
+    async createConnection(url, channel) {
+        if (this.isConnectionOpen || this.isConnecting) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const CentrifugeClient = await this.getCentrifugoClient();
+        const websocketUrl = url ?? this.url;
+        const websocketChannel = channel ?? this.channel;
+        this.connection = new CentrifugeClient(websocketUrl, {
+            debug: true,
+            maxReconnectDelay: 1500,
+            maxServerPingDelay: 1000,
+        });
+        return new Promise((resolve, reject) => {
+            this.connection
+                .on('connecting', () => {
+                this.isConnecting = true;
+            })
+                .on('connected', () => {
+                this.onConnect();
+                resolve();
+            })
+                .on('disconnected', (ctx) => {
+                this.onDisconnect(ctx, websocketChannel);
+                reject();
+            })
+                .on('error', (ctx) => {
+                const message = `code ${ctx.error.code} - ${ctx.error.message}`;
+                this.elkLoggerService.log(`connection error: ${message}`, [ErrorTags.WS], {
+                    channel: websocketChannel,
+                });
+            })
+                .connect();
+            this.subscription = this.connection.newSubscription(websocketChannel, this.getSubscriptionOptions(websocketChannel));
+            this.subscription
+                .on('subscribed', (ctx) => {
+                this.subscriptionPosition = ctx.streamPosition;
+                this.prevSubscribedChannel = websocketChannel;
+            })
+                .on('publication', (ctx) => {
+                const message = ctx.data;
+                this.elkLoggerService.log(`websocket message received: ${message}`, [ErrorTags.WS], {
+                    channel: websocketChannel,
+                });
+                this.incomingMessages$.next(ctx);
+            })
+                .on('error', (ctx) => {
+                const message = `code ${ctx.error.code} - ${ctx.error.message}`;
+                this.elkLoggerService.log(`subscription error: ${message}`, [ErrorTags.WS], {
+                    channel: websocketChannel,
+                });
+            })
+                .subscribe();
+        });
+    }
+    onConnect() {
+        clearTimeout(this.openConnectionTimerId);
+        this.isConnecting = false;
+        this.isConnectionOpen = true;
+    }
+    onDisconnect(ctx, websocketChannel) {
+        this.isConnecting = false;
+        this.isConnectionOpen = false;
+        /* If connection error, cause any connection error isn't 0 */
+        if (ctx.code !== 0) {
+            const message = `code ${ctx.code} - ${ctx.reason}`;
+            this.elkLoggerService.log(`disconnected error: ${message}`, [ErrorTags.WS], {
+                channel: websocketChannel,
+            });
+            (async () => {
+                await this.waitWhileNotReconnect();
+            })();
+        }
+    }
+    async reconnect() {
+        this.clearReconnectionTimer();
+        return new Promise((resolve) => {
+            this.reconnectionTimerId = setTimeout(() => {
+                this.createConnection()
+                    .then(() => resolve(true))
+                    .catch(() => resolve(false));
+                this.incrementReconnectionTimeout();
+            }, this.reconnectionTimeoutMs);
+        });
+    }
+    async waitWhileNotReconnect() {
+        this.clearReconnectionTimer();
+        this.setFirstReconnectionTimeout();
+        let isConnected = false;
+        const beforeTimer = performance.now();
+        while (!isConnected) {
+            isConnected = await this.reconnect();
+        }
+        const afterTimer = performance.now();
+        const timerDuration = afterTimer - beforeTimer;
+        this.elkLoggerService.log(`fallback to reconnection timer: duration ${timerDuration}ms`, [ErrorTags.WS], {
+            channel: this.channel,
+        });
+        this.successfulReconnectionEventsProxy$.next();
+    }
+    getSubscriptionOptions(websocketChannel) {
+        const options = {
+            recoverable: true,
+        };
+        if (websocketChannel === this.prevSubscribedChannel &&
+            this.subscriptionPosition) {
+            options.since = this.subscriptionPosition;
+        }
+        return options;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CentrifugoWebSocketService, deps: [{ token: i1.ElkLoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CentrifugoWebSocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CentrifugoWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ElkLoggerService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"centrifugo-web-socket.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/web-socket/centrifugo-web-socket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, Subject, Subscription } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport type {\n  Centrifuge,\n  DisconnectedContext,\n  PublicationContext,\n  Subscription as CentrifugeSubscription,\n} from 'centrifuge';\nimport { StreamPosition, SubscriptionOptions } from 'centrifuge/build/types';\nimport { ElkLoggerService } from '../exceptions-handling/elk/elk-logger.service';\nimport { WsError } from '../exceptions-handling/errors/ws-error.class';\nimport { ErrorTags } from '../exceptions-handling/errors/elk-error-types.enum';\nimport { WebSocketClient } from './web-socket.interface';\nimport { WebSocketClientType } from './web-socket-client-type.enum';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CentrifugoWebSocketService implements WebSocketClient {\n  public static readonly reconnectionTimeoutIncrementFactor = 2;\n\n  public type = WebSocketClientType.centrifugo;\n\n  private static readonly timeoutsMs = {\n    reconnection: 1000,\n    reconnectionMaxDeviation: 1000,\n  };\n\n  private reconnectionTimeoutMs!: number;\n  private reconnectionTimerId: ReturnType<typeof setTimeout> | null = null;\n\n  private readonly openConnectionTimerId: number | undefined;\n\n  private connection!: Centrifuge;\n  private subscription!: CentrifugeSubscription;\n  private subscriptionPosition?: StreamPosition;\n  private isConnectionOpen = false;\n  private isConnecting = false;\n  private url!: string;\n  private channel!: string;\n  private prevSubscribedChannel?: string;\n\n  private readonly incomingMessages$: Subject<PublicationContext> =\n    new Subject<PublicationContext>();\n\n  private readonly successfulReconnectionEventsProxy$: Subject<void> =\n    new Subject<void>();\n\n  public constructor(private readonly elkLoggerService: ElkLoggerService) {}\n\n  public async open(url: string, channel: string): Promise<void> {\n    if (url === this.url && channel === this.channel) {\n      return;\n    }\n\n    try {\n      this.url = url;\n      this.channel = channel;\n      await this.createConnection(url, channel);\n    } catch (error: unknown) {\n      // @ts-expect-error error is unknown\n      const message = (error?.message || error) as string;\n      const unknownError = new WsError(\n        `unknown websocket error: ${message}`,\n        channel\n      );\n\n      this.elkLoggerService.handleError(unknownError);\n    }\n  }\n\n  public close(): void {\n    this.clearReconnectionTimer();\n\n    if (!this.isConnectionOpen) {\n      return;\n    }\n\n    this.connection.disconnect();\n  }\n\n  public get messages$(): Observable<string> {\n    return (\n      this.incomingMessages$\n        .asObservable()\n        // event don't respect type from argument, it's weird\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        .pipe(map((event) => event.data))\n    );\n  }\n\n  public subscribeOnSuccessfulReconnection(next?: () => void): Subscription {\n    return this.successfulReconnectionEventsProxy$\n      .asObservable()\n      .subscribe(next);\n  }\n\n  private clearReconnectionTimer(): void {\n    if (this.reconnectionTimerId) {\n      clearTimeout(this.reconnectionTimerId);\n      this.reconnectionTimerId = null;\n    }\n  }\n\n  private setFirstReconnectionTimeout(): void {\n    const min =\n      CentrifugoWebSocketService.timeoutsMs.reconnection -\n      CentrifugoWebSocketService.timeoutsMs.reconnectionMaxDeviation;\n    const max =\n      CentrifugoWebSocketService.timeoutsMs.reconnection +\n      CentrifugoWebSocketService.timeoutsMs.reconnectionMaxDeviation;\n    this.reconnectionTimeoutMs =\n      Math.floor(Math.random() * (max - min + 1)) + min;\n  }\n\n  private incrementReconnectionTimeout(): void {\n    this.reconnectionTimeoutMs =\n      this.reconnectionTimeoutMs *\n      CentrifugoWebSocketService.reconnectionTimeoutIncrementFactor;\n  }\n\n  private async getCentrifugoClient(): Promise<typeof Centrifuge> {\n    return import('centrifuge').then((module) => module.Centrifuge);\n  }\n\n  private async createConnection(\n    url?: string,\n    channel?: string\n  ): Promise<void> {\n    if (this.isConnectionOpen || this.isConnecting) {\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const CentrifugeClient = await this.getCentrifugoClient();\n\n    const websocketUrl = url ?? this.url;\n    const websocketChannel = channel ?? this.channel;\n\n    this.connection = new CentrifugeClient(websocketUrl, {\n      debug: true,\n      maxReconnectDelay: 1500,\n      maxServerPingDelay: 1000,\n    });\n\n    return new Promise<void>((resolve, reject) => {\n      this.connection\n        .on('connecting', () => {\n          this.isConnecting = true;\n        })\n        .on('connected', () => {\n          this.onConnect();\n          resolve();\n        })\n        .on('disconnected', (ctx) => {\n          this.onDisconnect(ctx, websocketChannel);\n          reject();\n        })\n        .on('error', (ctx) => {\n          const message = `code ${ctx.error.code} - ${ctx.error.message}`;\n\n          this.elkLoggerService.log(\n            `connection error: ${message}`,\n            [ErrorTags.WS],\n            {\n              channel: websocketChannel,\n            }\n          );\n        })\n        .connect();\n\n      this.subscription = this.connection.newSubscription(\n        websocketChannel,\n        this.getSubscriptionOptions(websocketChannel)\n      );\n\n      this.subscription\n        .on('subscribed', (ctx) => {\n          this.subscriptionPosition = ctx.streamPosition;\n          this.prevSubscribedChannel = websocketChannel;\n        })\n        .on('publication', (ctx) => {\n          const message = ctx.data as string;\n\n          this.elkLoggerService.log(\n            `websocket message received: ${message}`,\n            [ErrorTags.WS],\n            {\n              channel: websocketChannel,\n            }\n          );\n\n          this.incomingMessages$.next(ctx);\n        })\n        .on('error', (ctx) => {\n          const message = `code ${ctx.error.code} - ${ctx.error.message}`;\n\n          this.elkLoggerService.log(\n            `subscription error: ${message}`,\n            [ErrorTags.WS],\n            {\n              channel: websocketChannel,\n            }\n          );\n        })\n        .subscribe();\n    });\n  }\n\n  private onConnect(): void {\n    clearTimeout(this.openConnectionTimerId);\n    this.isConnecting = false;\n    this.isConnectionOpen = true;\n  }\n\n  private onDisconnect(\n    ctx: DisconnectedContext,\n    websocketChannel: string\n  ): void {\n    this.isConnecting = false;\n    this.isConnectionOpen = false;\n\n    /* If connection error, cause any connection error isn't 0 */\n    if (ctx.code !== 0) {\n      const message = `code ${ctx.code} - ${ctx.reason}`;\n\n      this.elkLoggerService.log(\n        `disconnected error: ${message}`,\n        [ErrorTags.WS],\n        {\n          channel: websocketChannel,\n        }\n      );\n\n      (async () => {\n        await this.waitWhileNotReconnect();\n      })();\n    }\n  }\n\n  private async reconnect(): Promise<boolean> {\n    this.clearReconnectionTimer();\n\n    return new Promise((resolve) => {\n      this.reconnectionTimerId = setTimeout(() => {\n        this.createConnection()\n          .then(() => resolve(true))\n          .catch(() => resolve(false));\n        this.incrementReconnectionTimeout();\n      }, this.reconnectionTimeoutMs);\n    });\n  }\n\n  private async waitWhileNotReconnect(): Promise<void> {\n    this.clearReconnectionTimer();\n    this.setFirstReconnectionTimeout();\n\n    let isConnected = false;\n\n    const beforeTimer = performance.now();\n\n    while (!isConnected) {\n      isConnected = await this.reconnect();\n    }\n\n    const afterTimer = performance.now();\n\n    const timerDuration = afterTimer - beforeTimer;\n\n    this.elkLoggerService.log(\n      `fallback to reconnection timer: duration ${timerDuration}ms`,\n      [ErrorTags.WS],\n      {\n        channel: this.channel,\n      }\n    );\n\n    this.successfulReconnectionEventsProxy$.next();\n  }\n\n  private getSubscriptionOptions(\n    websocketChannel: string\n  ): Partial<SubscriptionOptions> {\n    const options: Partial<SubscriptionOptions> = {\n      recoverable: true,\n    };\n\n    if (\n      websocketChannel === this.prevSubscribedChannel &&\n      this.subscriptionPosition\n    ) {\n      options.since = this.subscriptionPosition;\n    }\n\n    return options;\n  }\n}\n"]}