@everymatrix/player-limit-notification-nd 0.0.1

package/dist/collection/components/player-limit-notification-nd/player-limit-notification-nd.js

@@ -0,0 +1,815 @@
+import { h, Fragment } from "@stencil/core";
+import { translate, getTranslations } from "../../utils/locale.utils";
+import { setClientStyling, setClientStylingURL, setStreamStyling } from "../../../../../../../../libs/common/src/styling/index";
+import { LimitPeriod, LimitType } from "../../utils/types";
+import { DefaultLimitConfig } from "./limitConfig";
+import "../../../../../../../libs/vaadin-facade/index";
+export class PlayerLimitNotificationNd {
+    constructor() {
+        this.MATCH_CONFIG_AMOUNT = /^(\w+)\((\w+)\):(\d+)-(\d+)$/;
+        this.MATCH_CONFIG_PERIOD = /^(\w+)\((\w+)\):([A-Z\-]+)$/;
+        this.defaultPeriods = [LimitPeriod.DAILY, LimitPeriod.WEEKLY, LimitPeriod.MONTHLY];
+        this.fetchSkipLimit = () => {
+            const url = new URL(`${this.endpoint}/api/pam/v1/player-notifications`);
+            url.searchParams.append('createNotificationIfNotFound', 'true');
+            this.loading = true;
+            fetch(url, {
+                headers: {
+                    'X-SessionId': this.session,
+                    'Content-Type': 'application/json'
+                },
+                method: 'PATCH',
+                body: JSON.stringify({
+                    type: 1,
+                    interval: 5,
+                    ackNotification: true,
+                    ackNotificationTimestamp: new Date().toISOString()
+                })
+            })
+                .then((res) => {
+                if (res.ok) {
+                    return res.json();
+                }
+                window.postMessage({
+                    type: 'WidgetNotification',
+                    data: {
+                        type: 'error',
+                        message: translate('limitNotificationFail', this.language)
+                    }
+                }, window.location.href);
+                throw new Error(`Error while skipping the limit setting`);
+            })
+                .then(() => {
+                window.postMessage({
+                    type: 'WidgetNotification',
+                    data: {
+                        type: 'success',
+                        message: translate('setLimitSuccessful', this.language)
+                    }
+                }, window.location.href);
+                window.postMessage({ type: 'SubmitLimitNotificationSuccess' }, window.location.href);
+            })
+                .catch((error) => {
+                console.error(error);
+            })
+                .finally(() => {
+                this.loading = false;
+            });
+        };
+        this.mbSource = undefined;
+        this.clientStyling = undefined;
+        this.clientStylingUrl = undefined;
+        this.session = undefined;
+        this.userid = undefined;
+        this.language = undefined;
+        this.endpoint = undefined;
+        this.limitsamount = undefined;
+        this.limitsperiods = undefined;
+        this.currency = undefined;
+        this.customcurrencysymbols = undefined;
+        this.translationurl = '';
+        this.limitItems = [{}];
+        this.limitTypeOptions = [];
+        this.skipLimit = false;
+        this.loading = false;
+        this.confirmPopupVisibility = false;
+    }
+    get currencySymbolMap() {
+        const customSymbols = {};
+        const defaultCurrencySymbols = {
+            EUR: '€',
+            RON: ' lei',
+            USD: '$'
+        };
+        if (this.customcurrencysymbols) {
+            this.customcurrencysymbols.split(',').forEach((symbol) => {
+                let symbolParts = symbol.split(':');
+                customSymbols[symbolParts[0].trim()] = symbolParts[1].trim();
+            });
+        }
+        return Object.assign(Object.assign({}, defaultCurrencySymbols), customSymbols);
+    }
+    handleClientStylingChange(newValue, oldValue) {
+        if (newValue != oldValue) {
+            setClientStyling(this.stylingContainer, this.clientStyling);
+        }
+    }
+    handleClientStylingUrlChange(newValue, oldValue) {
+        if (newValue != oldValue) {
+            setClientStylingURL(this.stylingContainer, this.clientStylingUrl);
+        }
+    }
+    handleMbSourceChange(newValue, oldValue) {
+        if (newValue != oldValue) {
+            setStreamStyling(this.stylingContainer, `${this.mbSource}.Style`, this.stylingSubscription);
+        }
+    }
+    componentDidLoad() {
+        if (this.stylingContainer) {
+            if (this.mbSource)
+                setStreamStyling(this.stylingContainer, `${this.mbSource}.Style`, this.stylingSubscription);
+            if (this.clientStyling)
+                setClientStyling(this.stylingContainer, this.clientStyling);
+            if (this.clientStylingUrl)
+                setClientStylingURL(this.stylingContainer, this.clientStylingUrl);
+        }
+    }
+    async componentWillLoad() {
+        if (this.translationurl.length > 2) {
+            await getTranslations(this.translationurl);
+        }
+        await this.parseLimitConfigs();
+    }
+    eventParamsToTranslationKeys(x) {
+        return `dataLayer-${x}`;
+    }
+    emitGtag(eventName, limitItem) {
+        //@ts-ignore
+        if (typeof gtag == 'function') {
+            //@ts-ignore
+            gtag({
+                event: eventName,
+                limit_category: translate(this.eventParamsToTranslationKeys(limitItem.product.toLowerCase()), this.language) ||
+                    limitItem.product,
+                limit_type: translate(this.eventParamsToTranslationKeys(limitItem.type.toLowerCase())) || limitItem.type,
+                limit_period: translate(this.eventParamsToTranslationKeys(limitItem.period), this.language) || limitItem.period,
+                limit_amount: limitItem.amount
+            });
+        }
+    }
+    disconnectedCallback() {
+        this.stylingSubscription && this.stylingSubscription.unsubscribe();
+    }
+    parsePeriodsConfig(periodItem) {
+        const match = periodItem.match(this.MATCH_CONFIG_PERIOD);
+        const periodMap = {
+            D: 'daily',
+            W: 'weekly',
+            M: 'monthly',
+            N: 'none'
+        };
+        const periodsOptions = [];
+        if (match) {
+            const [, , , periodStr] = match;
+            periodStr.split('-').forEach((code) => {
+                if (periodMap[code]) {
+                    periodsOptions.push(periodMap[code]);
+                }
+                else {
+                    throw new Error(`Unknown period code: ${code}`);
+                }
+            });
+        }
+        return periodsOptions;
+    }
+    async parseLimitConfigs() {
+        const amountsArray = this.limitsamount.replace(/\s/g, '').split('|');
+        const periodsArray = this.limitsperiods.replace(/\s/g, '').split('|');
+        if (amountsArray.length === 0) {
+            throw new Error('Please provide a full limits configuration.');
+        }
+        else if (amountsArray.length !== periodsArray.length) {
+            throw new Error('Please make sure that the limit configuration parameters specify the same number of tabs.');
+        }
+        try {
+            for (let i = 0; i < amountsArray.length; i++) {
+                const amountSection = amountsArray[i];
+                const periodSection = periodsArray[i];
+                const amountItems = amountSection.split(',');
+                const periodItems = periodSection.split(',');
+                amountItems.forEach((item, index) => {
+                    const match = item.match(this.MATCH_CONFIG_AMOUNT);
+                    if (match) {
+                        const periodOptions = this.parsePeriodsConfig(periodItems[index]);
+                        const [, product, type, min, max] = match;
+                        const limitTypeObject = {
+                            type: type,
+                            product,
+                            min: parseInt(min, 10),
+                            max: parseInt(max, 10),
+                            label: `${DefaultLimitConfig[type].title} - ${product}`,
+                            periodOptions,
+                            selectedKey: `${type}-${product}`
+                        };
+                        this.limitTypeOptions.push(limitTypeObject);
+                    }
+                });
+            }
+        }
+        catch (error) {
+            throw new Error(`Error parsing limit config: ${error}`);
+        }
+        await this.filterExistingLimits();
+        this.limitTypeOptions = [...this.limitTypeOptions];
+    }
+    async filterExistingLimits() {
+        try {
+            const { sessionLimit, cumulativeSessionLimits, monetaryLimits } = await this.getLimits16();
+            if (sessionLimit) {
+                this.limitTypeOptions = this.limitTypeOptions.filter((item) => item.type === LimitType.SESSION_LIMIT);
+            }
+            const limitsLookup = new Map();
+            monetaryLimits.forEach((limit) => {
+                var _a;
+                const key = `${(_a = limit.products) === null || _a === void 0 ? void 0 : _a[0]}-${limit.type}`.toLowerCase();
+                const periods = limitsLookup.get(key) || new Set();
+                periods.add(limit.period.toLowerCase());
+                limitsLookup.set(key, periods);
+            });
+            this.limitTypeOptions = this.limitTypeOptions
+                .map((option) => {
+                const key = `${option.product}-${option.type}`.toLowerCase();
+                let existingPeriods = limitsLookup.get(key) || new Set();
+                if (option.type === LimitType.CUMULATIVE_SESSION && cumulativeSessionLimits) {
+                    existingPeriods = new Set(cumulativeSessionLimits.map((item) => item.period.toLowerCase()));
+                }
+                const filteredPeriodOptions = option.periodOptions.filter((period) => !existingPeriods.has(period));
+                return filteredPeriodOptions.length > 0 ? Object.assign(Object.assign({}, option), { periodOptions: filteredPeriodOptions }) : null;
+            })
+                .filter(Boolean);
+        }
+        catch (e) {
+            console.error('error getting limits', e);
+        }
+    }
+    async getLimits16() {
+        const fetchSessionLimits = this.limitTypeOptions.some((limit) => limit.type === LimitType.SESSION_LIMIT || limit.type === LimitType.CUMULATIVE_SESSION);
+        const monetaryUrl = new URL(`${this.endpoint}/v1/player/${this.userid}/limits/monetary`);
+        const optionsEditLimits = {
+            method: 'GET',
+            headers: {
+                'X-SessionID': this.session,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            }
+        };
+        const res = await fetch(monetaryUrl.href, optionsEditLimits);
+        if (res.status >= 300) {
+            throw new Error(`An error occured during the fetch request`);
+        }
+        const limitData = (await res.json());
+        const monetaryLimits = (limitData === null || limitData === void 0 ? void 0 : limitData.limits) || [];
+        let sessionLimit = null;
+        let cumulativeSessionLimits = null;
+        if (fetchSessionLimits) {
+            const sessionUrl = new URL(`${this.endpoint}/v1/player/${this.userid}/limits/session`);
+            const sessionRes = await fetch(sessionUrl.href, optionsEditLimits);
+            if (sessionRes.status >= 300) {
+                throw new Error(`An error occured during the fetch request`);
+            }
+            const res = (await sessionRes.json());
+            sessionLimit = res === null || res === void 0 ? void 0 : res.sessionLimit;
+            cumulativeSessionLimits = res === null || res === void 0 ? void 0 : res.cumulativeSessionLimits;
+        }
+        return {
+            sessionLimit,
+            cumulativeSessionLimits,
+            monetaryLimits
+        };
+    }
+    handleSelectLimitType(e, item) {
+        const selectedKey = e.target.value;
+        const selectedOption = this.limitTypeOptions.find((item) => item.selectedKey === selectedKey);
+        Object.assign(item, Object.assign(Object.assign({}, selectedOption), { selectedKey, typeErrorMessage: null }));
+        // trigger rerender
+        this.limitItems = [...this.limitItems];
+        if (this.isDisabledPeriod(item, item.period)) {
+            // reset duplicate periods
+            item.period = null;
+        }
+    }
+    handleSelectLimitPeriod(period, item) {
+        Object.assign(item, {
+            period,
+            periodErrorMessage: null
+        });
+        this.limitItems = [...this.limitItems];
+    }
+    isDisabledPeriod(limitItem, period) {
+        if (!limitItem.type) {
+            return false;
+        }
+        const otherSameTypeLimits = this.limitItems.filter((item) => item !== limitItem && item.selectedKey === limitItem.selectedKey);
+        return otherSameTypeLimits.some((item) => item.period === period);
+    }
+    validateSave() {
+        if (this.skipLimit) {
+            return true;
+        }
+        let canSave = true;
+        this.limitItems.forEach((item) => {
+            var _a;
+            Object.assign(item, {
+                amountErrorMessage: null,
+                periodErrorMessage: null,
+                typeErrorMessage: null
+            });
+            item.amountErrorMessage = this.getAmountErrorMsg(item);
+            if (!item.period && !((_a = item.periodOptions) === null || _a === void 0 ? void 0 : _a.includes(LimitPeriod.NONE))) {
+                item.periodErrorMessage = translate('emptyPeriodWarning', this.language);
+            }
+            if (!item.type) {
+                item.typeErrorMessage = translate('emptyLimitTypeWarning', this.language);
+            }
+            if (item.amountErrorMessage || item.typeErrorMessage || item.periodErrorMessage) {
+                canSave = false;
+            }
+        });
+        this.limitItems = [...this.limitItems];
+        return canSave;
+    }
+    handleSaveLimit() {
+        var _a, _b, _c;
+        const canSave = this.validateSave();
+        if (!canSave) {
+            return;
+        }
+        if (this.skipLimit) {
+            const hasMultipleItems = this.limitItems.length > 1;
+            const hasFirstItemData = typeof ((_a = this.limitItems[0]) === null || _a === void 0 ? void 0 : _a.amount) === 'number' || ((_b = this.limitItems[0]) === null || _b === void 0 ? void 0 : _b.period) || ((_c = this.limitItems[0]) === null || _c === void 0 ? void 0 : _c.type);
+            if (hasMultipleItems || hasFirstItemData) {
+                this.doubleConfirmSkip();
+            }
+            else {
+                this.fetchSkipLimit();
+            }
+            return;
+        }
+        this.fetchUpdateLimit();
+    }
+    doubleConfirmSkip() {
+        this.confirmPopupVisibility = true;
+    }
+    handleCloseConfirm() {
+        this.confirmPopupVisibility = false;
+    }
+    handleSaveSkip() {
+        this.handleCloseConfirm();
+        this.fetchSkipLimit();
+    }
+    async fetchUpdateLimit() {
+        this.loading = true;
+        const updateLimitCalls = [];
+        this.limitItems.forEach((limitItem) => {
+            switch (limitItem.type) {
+                case 'lugas':
+                    updateLimitCalls.push(this.createSubmitLimitCall(this.updateLugasCall, limitItem));
+                    break;
+                case 'sessionLimit':
+                    updateLimitCalls.push(this.createSubmitLimitCall(this.updateSingleSessionLimit16Call, limitItem));
+                    break;
+                case 'cumulativeSession':
+                    updateLimitCalls.push(this.createSubmitLimitCall(this.updateCumulativeSessionLimit16Call, limitItem));
+                    break;
+                default:
+                    updateLimitCalls.push(this.createSubmitLimitCall(this.updateMonetaryLimits16Call, limitItem));
+                    break;
+            }
+        });
+        const results = await Promise.allSettled(updateLimitCalls.map((call) => call()));
+        const successful = results.filter((result) => result.status === 'fulfilled');
+        const failed = results.filter((result) => result.status === 'rejected');
+        this.loading = false;
+        if (failed.length === updateLimitCalls.length) {
+            window.postMessage({
+                type: 'WidgetNotification',
+                data: {
+                    type: 'error',
+                    message: translate('limitNotificationFail', this.language)
+                }
+            }, window.location.href);
+            return;
+        }
+        if (successful.length === updateLimitCalls.length) {
+            window.postMessage({
+                type: 'WidgetNotification',
+                data: {
+                    type: 'success',
+                    message: translate('setLimitSuccessful', this.language)
+                }
+            });
+            window.postMessage({ type: 'SubmitLimitNotificationSuccess' }, window.location.href);
+            return;
+        }
+        if (failed.length) {
+            window.postMessage({
+                type: 'WidgetNotification',
+                data: {
+                    type: 'info',
+                    config: {
+                        enableHtml: true
+                    },
+                    message: translate('partialFailedUpdateLimit', this.language, {
+                        values: {
+                            accountLimitPath: `/${this.language}/account/limits`
+                        }
+                    })
+                }
+            }, window.location.href);
+            window.postMessage({ type: 'SubmitLimitNotificationSuccess' }, window.location.href);
+        }
+    }
+    createSubmitLimitCall(fetchMethod, limitItem) {
+        return async () => {
+            try {
+                const res = await fetchMethod.bind(this)(limitItem);
+                if (res.status >= 300) {
+                    throw new Error(`An error occured during the fetch request`);
+                }
+                this.emitGtag('self_limitation_success', limitItem);
+            }
+            catch (e) {
+                console.error('error while updating limit', e);
+                throw new Error(`error while updating limit: ${e}`);
+            }
+        };
+    }
+    updateLugasCall(limitItem) {
+        const url = new URL(`${this.endpoint}/v2/player/${this.userid}/limit/lugas`);
+        const method = 'POST';
+        const body = {
+            amount: limitItem.amount,
+            roleLimitAmount: 0,
+            softMigration: false,
+            keepLimit: false
+        };
+        let optionsEditLimits = {
+            method,
+            headers: {
+                'X-SessionID': this.session,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: JSON.stringify(body)
+        };
+        return fetch(url.href, optionsEditLimits);
+    }
+    updateSingleSessionLimit16Call(limitItem) {
+        const url = new URL(`${this.endpoint}/v1/player/${this.userid}/limits/session/`);
+        const method = 'PUT';
+        const putBody = { sessionLimit: limitItem.amount, sessionLimitUnit: 'minute' };
+        let optionsEditLimits = {
+            method,
+            headers: {
+                'X-SessionID': this.session,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: JSON.stringify(putBody)
+        };
+        return fetch(url.href, optionsEditLimits);
+    }
+    // // daily -> Daily ...
+    capitalizeFirst(str) {
+        return str[0].toUpperCase() + str.substring(1);
+    }
+    updateCumulativeSessionLimit16Call(limitItem) {
+        const url = new URL(`${this.endpoint}/v1/player/${this.userid}/limits/session/`);
+        const method = 'PUT';
+        const putBody = {
+            cumulativeSessionLimits: [
+                {
+                    period: this.capitalizeFirst(limitItem.period),
+                    minutes: limitItem.amount
+                }
+            ]
+        };
+        let optionsEditLimits = {
+            method,
+            headers: {
+                'X-SessionID': this.session,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: JSON.stringify(putBody)
+        };
+        return fetch(url.href, optionsEditLimits);
+    }
+    updateMonetaryLimits16Call(limitItem) {
+        var _a;
+        const url = new URL(`${this.endpoint}/v1/player/${this.userid}/limits/monetary/`);
+        const body = {
+            amount: limitItem.amount,
+            currency: this.currency,
+            period: this.capitalizeFirst(limitItem.period),
+            type: DefaultLimitConfig[limitItem.type].callValue16,
+            products: [(_a = limitItem.product) !== null && _a !== void 0 ? _a : 'All'],
+            walletTypes: ['Deposit', 'NetDeposit'].includes(DefaultLimitConfig[limitItem.type].callValue16)
+                ? ['All']
+                : ['RealCash']
+        };
+        let optionsEditLimits = {
+            method: 'POST',
+            headers: {
+                'X-SessionID': this.session,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: JSON.stringify(body)
+        };
+        return fetch(url.href, optionsEditLimits);
+    }
+    handleBlockInputWheel(e) {
+        e.preventDefault();
+    }
+    handleSkipLimitChange(e) {
+        this.skipLimit = e.target.checked;
+    }
+    handleAddLimit() {
+        this.limitItems = [...this.limitItems, {}];
+    }
+    handleRemoveLimit(limitIndex) {
+        this.limitItems.splice(limitIndex, 1);
+        this.limitItems = [...this.limitItems];
+    }
+    handleInputLimitAmount(e, item) {
+        const inputAmount = Number(e.target.value);
+        if (typeof inputAmount !== 'number' || Number.isNaN(inputAmount)) {
+            item.amountErrorMessage = translate('invalidAmount', this.language);
+            return;
+        }
+        const isFloat = !Number.isInteger(inputAmount);
+        const rounded = isFloat ? Math.round(inputAmount) : inputAmount;
+        item.amount = rounded;
+        item.amountErrorMessage = this.getAmountErrorMsg(item);
+        this.limitItems = [...this.limitItems];
+    }
+    getAmountErrorMsg(item) {
+        if (typeof item.amount !== 'number' || Number.isNaN(item.amount)) {
+            return translate('invalidAmount', this.language);
+        }
+        let amountErrorMessage = null;
+        if (item.amount < item.min) {
+            amountErrorMessage = translate('invalidInputMessageLimitMin', this.language, {
+                values: {
+                    minValue: item.min,
+                    currency: this.currency
+                }
+            });
+        }
+        if (item.amount > item.max) {
+            amountErrorMessage = translate('invalidInputMessageLimitMax', this.language, {
+                values: {
+                    maxValue: item.max,
+                    currency: this.currency
+                }
+            });
+        }
+        return amountErrorMessage;
+    }
+    renderPeriodButtons(limitItem) {
+        const periodOptions = limitItem.periodOptions || this.defaultPeriods;
+        if (periodOptions.includes(LimitPeriod.NONE)) {
+            return '';
+        }
+        return (h(Fragment, null, h("div", { class: "limit-item-period" }, h("label", { class: "limit-period-label" }, translate('selectLimitPeriodLabel', this.language)), h("div", { class: "limit-period-wrapper" }, periodOptions.map((period) => (h("button", { class: `
+                  limit-period-option
+                  ${limitItem.period === period ? 'selected' : ''}
+                  `, disabled: this.isDisabledPeriod(limitItem, period), onClick: () => this.handleSelectLimitPeriod(period, limitItem) }, translate(period, this.language)))))), h("small", { class: "error-message" }, limitItem.periodErrorMessage)));
+    }
+    render() {
+        return (h("div", { key: 'ae3dad7b876e7d9ceb250f234c3e1747fdc889d6', class: "player-limit-modal", ref: (el) => (this.stylingContainer = el) }, h("section", { key: '1c1ff957e5d7fa274e92a5962185e6dcc5ca2472', class: "limit-modal-container" }, h("div", { key: '3043c525a39bf35f91614deadbd808d3bad4758b', class: "limit-modal-title" }, h("h2", { key: '88160571e334767c68269ed6fcb44c467617f4c6' }, translate('limitNotificationTitle', this.language)), h("p", { key: '0cdd7545ef845e0f22d74386df28d9a5e97ec3e5' }, translate('limitNotificationSubTitle', this.language))), h("div", { key: '78119df2f63cca751404d0f749a686336256e6ab', class: `limit-modal-content ${this.skipLimit || this.loading ? 'disable-content' : ''}` }, this.limitItems.map((item, index) => (h("div", { class: "limit-item" }, h("div", { class: "limit-item-type" }, h("label", { class: "type-select-label" }, translate('selectLimitTypeLabel', this.language)), h("div", null, h("vaadin-combo-box", { value: item.selectedKey, items: this.limitTypeOptions, "no-vertical-overlap": true, "item-label-path": "label", "item-value-path": "selectedKey", placeholder: translate('selectLimitTypePlaceholder', this.language), onChange: (e) => this.handleSelectLimitType(e, item) })), h("small", { class: "error-message" }, item.typeErrorMessage)), this.renderPeriodButtons(item), h("div", { class: "limit-item-amount" }, h("div", { class: "amount-input" }, h("label", { class: "amount-input-label" }, translate('limitNotificationAmountLabel', this.language)), h("div", { class: "amount-input-wrapper" }, h("div", { class: "amount-input-content" }, h("input", { class: "amount-input-inner", type: "number", pattern: "[0-9]*", value: item.amount, onWheel: this.handleBlockInputWheel, onInput: (e) => this.handleInputLimitAmount(e, item) }), h("span", { class: "amount-input-suffix" }, h("i", null, this.currencySymbolMap[this.currency]))), h("button", { onClick: () => this.handleRemoveLimit(index), class: "remove-limit-button" }, h("svg", { width: "16", height: "18", viewBox: "0 0 16 18", fill: "none", xmlns: "http://www.w3.org/2000/svg" }, h("path", { d: "M3 18C2.45 18 1.97934 17.8043 1.588 17.413C1.19667 17.0217 1.00067 16.5507 1 16V3C0.71667 3 0.479337 2.904 0.288004 2.712C0.0966702 2.52 0.000670115 2.28267 3.44827e-06 2C-0.000663218 1.71733 0.0953369 1.48 0.288004 1.288C0.48067 1.096 0.718003 1 1 1H5C5 0.716667 5.096 0.479333 5.288 0.288C5.48 0.0966668 5.71734 0.000666667 6 0H10C10.2833 0 10.521 0.0960001 10.713 0.288C10.905 0.48 11.0007 0.717333 11 1H15C15.2833 1 15.521 1.096 15.713 1.288C15.905 1.48 16.0007 1.71733 16 2C15.9993 2.28267 15.9033 2.52033 15.712 2.713C15.5207 2.90567 15.2833 3.00133 15 3V16C15 16.55 14.8043 17.021 14.413 17.413C14.0217 17.805 13.5507 18.0007 13 18H3ZM6 14C6.28334 14 6.521 13.904 6.713 13.712C6.905 13.52 7.00067 13.2827 7 13V6C7 5.71667 6.904 5.47933 6.712 5.288C6.52 5.09667 6.28267 5.00067 6 5C5.71734 4.99933 5.48 5.09533 5.288 5.288C5.096 5.48067 5 5.718 5 6V13C5 13.2833 5.096 13.521 5.288 13.713C5.48 13.905 5.71734 14.0007 6 14ZM10 14C10.2833 14 10.521 13.904 10.713 13.712C10.905 13.52 11.0007 13.2827 11 13V6C11 5.71667 10.904 5.47933 10.712 5.288C10.52 5.09667 10.2827 5.00067 10 5C9.71734 4.99933 9.48 5.09533 9.288 5.288C9.096 5.48067 9 5.718 9 6V13C9 13.2833 9.096 13.521 9.288 13.713C9.48 13.905 9.71734 14.0007 10 14Z" })))))), h("small", { class: "error-message" }, item.amountErrorMessage))))), h("div", { key: '23139e7d1b327533489ce4b3f2e432230a3f7645', class: "checkbox-container" }, h("label", { key: '334c57934771223af2403998ddb20b7536c1a959' }, h("span", { key: '04ccbafd91a90ff474bfabd3337a987a953766b9', class: "custom-checkbox" }, h("input", { key: '734547aa3750a0d12fc1e9056092fce2ea1b957c', disabled: this.loading, onChange: (e) => this.handleSkipLimitChange(e), type: "checkbox", class: "checkbox-original" }), h("span", { key: '63f3ce41d763ad6b16b16aa7b39bc74432a9fd3a', class: "checkbox-custom" })), h("span", { key: 'c8f24246e5335e86a76b1e495d410fe2d2ec30fc', class: "checkbox-label" }, translate('skipLimitLimitDescription', this.language)))), h("div", { key: '41cdf413024f032b4120be47b300d26a413dfd8b', class: "limit-buttons" }, h("button", { key: 'cebe997da3cce9473c5f7519d433b3a646f945e2', class: "add-limit", disabled: this.skipLimit || this.loading, onClick: () => this.handleAddLimit() }, h("svg", { key: '8f4e2b46602dd8ca2a8470d1ca33712a359d7fb5', class: "add-limit-mark", width: "14", height: "14", viewBox: "0 0 14 14", xmlns: "http://www.w3.org/2000/svg" }, h("path", { key: '98f33783a2c5c9a2b26978b657b69a4d0d1cb8cd', d: "M13 8H8V13C8 13.2652 7.89464 13.5196 7.70711 13.7071C7.51957 13.8946 7.26522 14 7 14C6.73478 14 6.48043 13.8946 6.29289 13.7071C6.10536 13.5196 6 13.2652 6 13V8H1C0.734784 8 0.48043 7.89464 0.292893 7.70711C0.105357 7.51957 0 7.26522 0 7C0 6.73478 0.105357 6.48043 0.292893 6.29289C0.48043 6.10536 0.734784 6 1 6H6V1C6 0.734784 6.10536 0.480429 6.29289 0.292893C6.48043 0.105357 6.73478 0 7 0C7.26522 0 7.51957 0.105357 7.70711 0.292893C7.89464 0.480429 8 0.734784 8 1V6H13C13.2652 6 13.5196 6.10536 13.7071 6.29289C13.8946 6.48043 14 6.73478 14 7C14 7.26522 13.8946 7.51957 13.7071 7.70711C13.5196 7.89464 13.2652 8 13 8Z" })), h("span", { key: '46c37e85b147a3870a183ebf5cae1a1a10d4c1af' }, translate('addLimitType', this.language))), h("button", { key: '2284595e04d263234d7fca37549738df3424278b', class: "save-limit", disabled: this.loading, onClick: () => this.handleSaveLimit() }, translate('savePlayerLimit', this.language)))), this.confirmPopupVisibility ? (h("section", { class: "confirm-modal" }, h("div", { class: "confirm-modal-content" }, h("h2", { class: "confirm-modal-title" }, translate('limitNotificationTitle', this.language)), h("p", null, translate('confirmLimitNotification', this.language)), h("div", { class: "confirm-modal-buttons" }, h("button", { class: "confirm-limit-close", onClick: () => this.handleCloseConfirm() }, translate('confirmLimitClose', this.language)), h("button", { class: "confirm-limit-save", onClick: () => this.handleSaveSkip() }, translate('confirmLimitSave', this.language)))))) : null));
+    }
+    static get is() { return "player-limit-notification-nd"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["player-limit-notification-nd.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["player-limit-notification-nd.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "mbSource": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "mb-source",
+                "reflect": true
+            },
+            "clientStyling": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "client-styling",
+                "reflect": true
+            },
+            "clientStylingUrl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "client-styling-url",
+                "reflect": true
+            },
+            "session": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "session",
+                "reflect": true
+            },
+            "userid": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "userid",
+                "reflect": true
+            },
+            "language": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "language",
+                "reflect": true
+            },
+            "endpoint": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "endpoint",
+                "reflect": true
+            },
+            "limitsamount": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "limitsamount",
+                "reflect": true
+            },
+            "limitsperiods": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "limitsperiods",
+                "reflect": true
+            },
+            "currency": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "currency",
+                "reflect": true
+            },
+            "customcurrencysymbols": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "customcurrencysymbols",
+                "reflect": true
+            },
+            "translationurl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "translationurl",
+                "reflect": true,
+                "defaultValue": "''"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "limitItems": {},
+            "limitTypeOptions": {},
+            "skipLimit": {},
+            "loading": {},
+            "confirmPopupVisibility": {}
+        };
+    }
+    static get watchers() {
+        return [{
+                "propName": "clientStyling",
+                "methodName": "handleClientStylingChange"
+            }, {
+                "propName": "clientStylingUrl",
+                "methodName": "handleClientStylingUrlChange"
+            }, {
+                "propName": "mbSource",
+                "methodName": "handleMbSourceChange"
+            }];
+    }
+}