@everymatrix/casino-engagement-suite-luckywheel-list 0.1.0

package/dist/collection/components/casino-engagement-suite-luckywheel-list/casino-engagement-suite-luckywheel-list.js

@@ -0,0 +1,467 @@
+import { h } from "@stencil/core";
+import { translate, getTranslations } from "../../utils/locale.utils";
+import "../../../../../casino-engagement-suite-progress-bar/dist/types/index";
+import "../../../../../../svelte/general-animation-loading/es2015/general-animation-loading";
+import { getHistoryLoaderTemplate, getLuckyWheelsHistoryTemplate } from "../../renders/LuckyWheelsHistory";
+export class CasinoEngagementSuiteLuckyWheelList {
+    constructor() {
+        this.setClientStyling = () => {
+            let sheet = document.createElement('style');
+            sheet.innerHTML = this.clientStyling;
+            this.host.prepend(sheet);
+        };
+        this.setClientStylingURL = () => {
+            let url = new URL(this.clientStylingUrl);
+            let cssFile = document.createElement('style');
+            fetch(url.href)
+                .then((res) => res.text())
+                .then((data) => {
+                cssFile.innerHTML = data;
+                setTimeout(() => { this.host.prepend(cssFile); }, 1);
+            })
+                .catch((err) => {
+                console.log('Error ', err);
+            });
+        };
+        this.handleCloseClick = () => {
+            this.close.emit();
+            this.tooltip = false;
+        };
+        this.handleLuckyWheelClick = (ev) => {
+            const id = ev.currentTarget.getAttribute('data-id');
+            const index = ev.currentTarget.getAttribute('data-index');
+            window.postMessage({ type: 'LuckyWheelClick', id, index });
+        };
+        this.showTooltip = () => {
+            this.tooltip = true;
+        };
+        this.hideTooltip = () => {
+            this.tooltip = false;
+        };
+        this.handleTabChange = (e) => {
+            this.activeTab = +(e.target.getAttribute('data-index'));
+            if (this.activeTab === 2) {
+                if (!this.historyLoaded) {
+                    this.sendHistoryRequest();
+                }
+            }
+        };
+        this.toggleLuckyWheelHistory = (ev) => {
+            const id = ev.currentTarget.getAttribute('data-id');
+            const index = this.openedHistoryIds.findIndex(historyId => historyId === id);
+            if (index > -1) {
+                this.openedHistoryIds = this.openedHistoryIds.filter((historyId) => historyId !== id);
+            }
+            else {
+                this.openedHistoryIds.push(id);
+            }
+            this.openedHistoryIds = [...this.openedHistoryIds];
+        };
+        this.clientStyling = '';
+        this.clientStylingUrl = '';
+        this.language = 'en';
+        this.device = 'Mobile';
+        this.luckywheels = [];
+        this.endpoint = undefined;
+        this.session = undefined;
+        this.translationUrl = '';
+        this.tooltip = false;
+        this.timers = {};
+        this.limitStylingAppends = false;
+        this.activeTab = 1;
+        this.historyLoading = false;
+        this.luckywheelHistory = {};
+        this.openedHistoryIds = [];
+        this.historyLoaded = false;
+        this.isLoading = false;
+    }
+    handleEvent(e) {
+        const { type } = e === null || e === void 0 ? void 0 : e.data;
+        if (type === 'BarLuckyWheelsClick') {
+            this.activeTab = 1;
+            this.openedHistoryIds = [];
+        }
+    }
+    luckywheelsPropHandler(value) {
+        if (!this.interval && value.length) {
+            this.updateTimers();
+            this.startCountdown();
+        }
+        if (this.interval && !value.length) {
+            clearInterval(this.interval);
+        }
+    }
+    componentWillLoad() {
+        const promises = [];
+        this.luckywheels = [];
+        if (this.endpoint) {
+            const consentsPromise = this.getLuckyWheels();
+            promises.push(consentsPromise);
+        }
+        if (this.translationUrl) {
+            const translationPromise = getTranslations(this.translationUrl);
+            promises.push(translationPromise);
+        }
+        return Promise.all(promises);
+    }
+    getLuckyWheels() {
+        let url = new URL(this.endpoint + `/v1/wof/lotteries`);
+        let reqHeaders = new Headers();
+        url.searchParams.append('language', this.language);
+        if (this.session) {
+            reqHeaders.append('X-SessionId', this.session);
+        }
+        let requestOptions = {
+            method: 'GET',
+            headers: reqHeaders,
+        };
+        this.isLoading = true;
+        fetch(url.href, requestOptions).then((res) => res.json()).then((res) => {
+            this.luckywheels = res.items;
+        }).catch((err) => {
+            throw new Error(err);
+        }).finally(() => {
+            this.isLoading = false;
+        });
+    }
+    getLuckyWheelsHistory(luckywheelId) {
+        let url = new URL(this.endpoint + `/v1/wof/outcome/${luckywheelId}`);
+        let reqHeaders = new Headers();
+        url.searchParams.append('language', this.language);
+        if (this.session) {
+            reqHeaders.append('X-SessionId', this.session);
+        }
+        let requestOptions = {
+            method: 'GET',
+            headers: reqHeaders,
+        };
+        return fetch(url.href, requestOptions).then((res) => res.json());
+    }
+    componentDidRender() {
+        if (!this.limitStylingAppends && this.host) {
+            if (this.clientStyling)
+                this.setClientStyling();
+            if (this.clientStylingUrl)
+                this.setClientStylingURL();
+            this.limitStylingAppends = true;
+        }
+    }
+    disconnectedCallback() {
+        this.interval && clearInterval(this.interval);
+    }
+    startCountdown() {
+        this.interval = setInterval(() => {
+            this.updateTimers();
+        }, 1000);
+    }
+    updateTimers() {
+        const now = new Date().getTime();
+        this.timers = this.luckywheels.reduce((acc, luckywheel) => {
+            var _a;
+            const expirationDate = new Date((_a = luckywheel.current) === null || _a === void 0 ? void 0 : _a.endTime).getTime();
+            const diff = expirationDate - now;
+            let countdown = '00h:00m:00s';
+            if (diff < 1) {
+                this.removeLuckyWheel(luckywheel.program.id);
+            }
+            else {
+                const { days, hours, minutes, seconds } = {
+                    days: String(Math.floor(diff / (1000 * 60 * 60 * 24))).padStart(2, '0'),
+                    hours: String(Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60))).padStart(2, '0'),
+                    minutes: String(Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60))).padStart(2, '0'),
+                    seconds: String(Math.floor((diff % (1000 * 60)) / 1000)).padStart(2, '0')
+                };
+                countdown = days === '00'
+                    ? `${hours}h:${minutes}m:${seconds}s`
+                    : `${days}d:${hours}h:${minutes}m`;
+            }
+            return Object.assign(Object.assign({}, acc), { [luckywheel.program.id]: countdown });
+        }, {});
+    }
+    removeLuckyWheel(id) {
+        this.luckywheels = this.luckywheels.filter((luckywheel) => luckywheel.program.id !== id);
+        window.postMessage({ type: 'LuckyWheelHasExpired', id });
+    }
+    async sendHistoryRequest() {
+        this.historyLoading = true;
+        if (!this.luckywheels.length) {
+            return;
+        }
+        const promises = [];
+        this.luckywheels.forEach(async (luckywheel) => {
+            promises.push(this.getLuckyWheelsHistory(luckywheel.program.id).then(res => {
+                this.luckywheelHistory[luckywheel.program.id] = res.items;
+            }));
+        });
+        await Promise.all(promises);
+        this.historyLoading = false;
+        this.historyLoaded = true;
+    }
+    getLuckyWheelClasses(luckyWheel) {
+        return {
+            LuckyWheelsCard: true,
+            LuckyWheelsEmptyNumber: luckyWheel.current.remainingTimes === 0
+        };
+    }
+    getLuckyWheelName(luckywheel) {
+        var _a, _b;
+        return ((_a = luckywheel.program) === null || _a === void 0 ? void 0 : _a.name['en']) || ((_b = luckywheel.program) === null || _b === void 0 ? void 0 : _b.name['*']);
+    }
+    getLuckyWheelHeaderTemplate(luckywheel) {
+        var _a, _b;
+        return (h("div", { class: "LuckyWheelsCardHeader" }, h("div", { class: `LuckyWheelsName` }, this.getLuckyWheelName(luckywheel)), (h("div", { class: "LuckyWheelsCounter" }, h("div", { class: `${((_a = luckywheel.current) === null || _a === void 0 ? void 0 : _a.remainingTimes) ? 'LuckyWheelsHighlightedCounter' : 'LuckyWheelsEmptyCounter'}` }, (_b = luckywheel.current) === null || _b === void 0 ? void 0 : _b.remainingTimes)))));
+    }
+    getLuckyWheelTemplate(luckywheel, index) {
+        const countdown = this.timers[luckywheel.program.id];
+        //TODO: canceled status
+        const isCanceled = luckywheel.current.remainingTimes === 0;
+        return (h("div", { class: this.getLuckyWheelClasses(luckywheel), onClick: this.handleLuckyWheelClick, key: luckywheel.program.id, "data-id": luckywheel.program.id, "data-index": index }, this.getLuckyWheelHeaderTemplate(luckywheel), isCanceled ? (h("div", { class: "ForfeitedMessage" }, h("div", null, translate('canceled', this.language)), h("div", null, translate('support', this.language)))) : (h("div", { class: "LuckyWheelsCountdownWrapper" }, h("span", { class: "LuckyWheelsCountdown" }, countdown)))));
+    }
+    getHeaderTemplate() {
+        return h("header", { class: "LuckyWheelsListPopupHeader" }, h("button", { onClick: this.showTooltip, class: "EngagementSuiteIconButton Help" }), h("div", { class: "LuckyWheelsListPopupHeaderName" }, translate('luckyWheel', this.language)), h("button", { class: "EngagementSuiteIconButton Close", onClick: this.handleCloseClick }));
+    }
+    getListTemplate() {
+        if (this.isLoading) {
+            return h("general-animation-loading", null);
+        }
+        if (this.luckywheels.length) {
+            return h("div", { class: "LuckyWheelsListWrapper" }, h("div", { class: "LuckyWheelsList" }, this.luckywheels.map((luckywheel, index) => this.getLuckyWheelTemplate(luckywheel, index))));
+        }
+        else {
+            return h("div", { class: "LuckyWheelsListEmpty" }, h("h2", null, translate('noluckywheels', this.language)), h("p", null, translate('tryOtherGames', this.language)));
+        }
+    }
+    getTooltipTemplate() {
+        if (this.tooltip) {
+            return h("div", { class: "EngagementSuiteTooltipBackdrop" }, h("div", { class: "EngagementSuiteTooltip" }, h("button", { class: "EngagementSuiteIconButton Close", onClick: this.hideTooltip }), translate('tooltip', this.language)));
+        }
+        else {
+            return '';
+        }
+    }
+    getTabsTemplate() {
+        return h("div", { class: "EngagementSuiteTabsWrapper" }, h("div", { class: "EngagementSuiteTabs" }, h("div", { "data-index": "1", onClick: this.handleTabChange, class: `EngagementSuiteTab ${this.activeTab === 1 ? 'Active' : ''}` }, translate('luckywheels', this.language)), h("div", { "data-index": "2", onClick: this.handleTabChange, class: `EngagementSuiteTab ${this.activeTab === 2 ? 'Active' : ''}` }, translate('history', this.language))));
+    }
+    getHistoryTabTemplate() {
+        return h("div", { class: "HistoryWrapper" }, h("div", { class: "HistoryCols" }, h("div", { class: "HistoryColName Rewards" }, translate('rewards', this.language)), h("div", { class: "HistoryColName Issued" }, translate('issued', this.language)), h("div", { class: "HistoryColName Time" }, translate('time', this.language))), this.historyLoading
+            ? getHistoryLoaderTemplate(this.language)
+            : getLuckyWheelsHistoryTemplate(this.luckywheels, this.luckywheelHistory, this.openedHistoryIds, this.toggleLuckyWheelHistory, this.language));
+    }
+    getTabsContentTemplate() {
+        return this.activeTab === 1
+            ? this.getListTemplate()
+            : this.getHistoryTabTemplate();
+    }
+    render() {
+        return h("div", { key: 'bec9d35e1b9362a5098ab53c9fddb620b407b17e', class: `LuckyWheelsListPopup ${this.device}` }, this.getHeaderTemplate(), this.getTabsTemplate(), this.getTabsContentTemplate(), this.getTooltipTemplate());
+    }
+    static get is() { return "casino-engagement-suite-luckywheel-list"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["casino-engagement-suite-luckywheel-list.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["casino-engagement-suite-luckywheel-list.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "clientStyling": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Client custom styling via string"
+                },
+                "attribute": "client-styling",
+                "reflect": true,
+                "defaultValue": "''"
+            },
+            "clientStylingUrl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Client custom styling via url"
+                },
+                "attribute": "client-styling-url",
+                "reflect": true,
+                "defaultValue": "''"
+            },
+            "language": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Language of the widget"
+                },
+                "attribute": "language",
+                "reflect": false,
+                "defaultValue": "'en'"
+            },
+            "device": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "\"Mobile\" | \"Tablet\" | \"Desktop\"",
+                    "resolved": "\"Desktop\" | \"Mobile\" | \"Tablet\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "User's device type"
+                },
+                "attribute": "device",
+                "reflect": false,
+                "defaultValue": "'Mobile' as 'Mobile' | 'Tablet' | 'Desktop'"
+            },
+            "luckywheels": {
+                "type": "unknown",
+                "mutable": true,
+                "complexType": {
+                    "original": "LuckyWheel[]",
+                    "resolved": "LuckyWheel[]",
+                    "references": {
+                        "LuckyWheel": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "../../../../packages/stencil/casino-engagement-suite-luckywheel-list/src/components.d.ts::unknown"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "List of lucky wheels"
+                },
+                "defaultValue": "[] as Array<LuckyWheel>"
+            },
+            "endpoint": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The NWA endpoint"
+                },
+                "attribute": "endpoint",
+                "reflect": false
+            },
+            "session": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The NWA session for the logged-in user"
+                },
+                "attribute": "session",
+                "reflect": false
+            },
+            "translationUrl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Translations via URL"
+                },
+                "attribute": "translation-url",
+                "reflect": false,
+                "defaultValue": "''"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "tooltip": {},
+            "timers": {},
+            "limitStylingAppends": {},
+            "activeTab": {},
+            "historyLoading": {},
+            "luckywheelHistory": {},
+            "openedHistoryIds": {},
+            "historyLoaded": {},
+            "isLoading": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "close",
+                "name": "close",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get elementRef() { return "host"; }
+    static get watchers() {
+        return [{
+                "propName": "luckywheels",
+                "methodName": "luckywheelsPropHandler"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "message",
+                "method": "handleEvent",
+                "target": "window",
+                "capture": false,
+                "passive": false
+            }];
+    }
+}

package/dist/collection/components/casino-engagement-suite-luckywheel-list/index.js

@@ -0,0 +1 @@
+export { CasinoEngagementSuiteLuckyWheelList } from './casino-engagement-suite-luckywheel-list';

package/dist/collection/index.js

@@ -0,0 +1 @@
+export * from './components/casino-engagement-suite-luckywheel-list';

package/dist/collection/models/luckywheel.js

@@ -0,0 +1,14 @@
+export var LuckyWheelRewardType;
+(function (LuckyWheelRewardType) {
+    LuckyWheelRewardType[LuckyWheelRewardType["FreeSpins"] = 0] = "FreeSpins";
+    LuckyWheelRewardType[LuckyWheelRewardType["LuckyWheel"] = 1] = "LuckyWheel";
+    LuckyWheelRewardType[LuckyWheelRewardType["Leaderboard"] = 2] = "Leaderboard";
+    LuckyWheelRewardType[LuckyWheelRewardType["Challenge"] = 3] = "Challenge";
+    LuckyWheelRewardType[LuckyWheelRewardType["Custom"] = 4] = "Custom";
+})(LuckyWheelRewardType || (LuckyWheelRewardType = {}));
+export var LuckyWheelHistoryLevelStatus;
+(function (LuckyWheelHistoryLevelStatus) {
+    LuckyWheelHistoryLevelStatus[LuckyWheelHistoryLevelStatus["Completed"] = 0] = "Completed";
+    LuckyWheelHistoryLevelStatus[LuckyWheelHistoryLevelStatus["Expired"] = 1] = "Expired";
+    LuckyWheelHistoryLevelStatus[LuckyWheelHistoryLevelStatus["Forfeited"] = 2] = "Forfeited";
+})(LuckyWheelHistoryLevelStatus || (LuckyWheelHistoryLevelStatus = {}));

package/dist/collection/renders/LuckyWheelsHistory.js

@@ -0,0 +1,52 @@
+import { LuckyWheelRewardType } from "../models/luckywheel";
+import { h } from "@stencil/core";
+import { translate } from "../utils/locale.utils";
+import { format } from "date-fns";
+export const getHistoryLoaderTemplate = (lang) => {
+    return h("div", { class: "HistoryLoader" }, h("casino-engagement-suite-progress-bar", { indeterminate: true }), h("span", null, translate('loading', lang)));
+};
+const getRewardNameByType = (type, lang) => {
+    switch (type) {
+        case 0: return translate('freeSpins', lang);
+        case 1: return translate('luckyWheel', lang);
+        case 2: return translate('leaderboard', lang);
+        case 3: return translate('mission', lang);
+    }
+};
+export const getRewardTemplate = (reward, lang) => {
+    const isCustom = reward.Type === LuckyWheelRewardType.Custom;
+    const rewardName = isCustom ? reward.RewardDescription : getRewardNameByType(reward.Type, lang);
+    const isRewarded = isCustom || reward.IsRewarded;
+    return h("div", { class: `HistoryRewardsItem ${isRewarded || isCustom ? 'IsRewarded' : 'IsNotRewarded'}` }, h("span", { class: "HistoryRewardsItemName" }, rewardName), !isCustom && h("div", { class: `EngagementSuiteIconButton ${isRewarded ? 'Check' : 'Close'}` }));
+};
+export const getHistoryLevelRewardsTemplate = (level, lang) => {
+    return h("div", { class: "HistoryRewardsList" }, h("div", { class: "EngagementSuiteIconButton CupRewardList" }), Object.values(level.Rewards).map(reward => getRewardTemplate(reward, lang)));
+};
+export const getHistoryLevelTemplate = (level, index, lang) => {
+    return h("div", { class: "HistoryLevelInfo" }, h("span", { class: "Level" }, `${translate('level', lang)} ${index + 1}`), h("span", { class: "Time" }, format(new Date(level.Time), 'LLL d, yyyy HH:mm:ss')));
+};
+const getRewards = (luckywheel, result) => {
+    var _a, _b, _c, _d;
+    const index = result.wheelOfFortunePartitionIndex || 0;
+    const name = (_b = (_a = luckywheel.program.wheelOfFortune) === null || _a === void 0 ? void 0 : _a.partitions[index]) === null || _b === void 0 ? void 0 : _b.name;
+    const displayName = name['en'] || name['*'];
+    const assets = (_d = (_c = luckywheel.program.wheelOfFortune) === null || _c === void 0 ? void 0 : _c.partitions[index]) === null || _d === void 0 ? void 0 : _d.image1;
+    const displayAssets = assets['en'] || assets['*'];
+    const programName = luckywheel.program.name['en'] || luckywheel.program.name['*'];
+    return h("div", { class: "HistoryRewards" }, displayName ? displayName : displayAssets ? (h("img", { src: displayAssets })) : programName);
+};
+const getStatus = (state) => {
+    return state === 'fulfilled' ? 'Success' : 'Failed';
+};
+export const getLuckyWheelsHistoryTemplate = (luckywheels, historyGroups, openedHistoryIds, toggleLuckyWheelHistory, lang) => {
+    if (luckywheels.length === 0) {
+        return h("p", { class: "HistoryEmptyMessage" }, translate('noHistory', lang));
+    }
+    return h("div", { class: "HistoryList" }, luckywheels.map((luckywheel) => {
+        return h("div", { key: luckywheel.program.id, class: `HistoryListItem ${openedHistoryIds.includes(luckywheel.program.id) ? 'Opened' : 'Closed'}` }, h("header", { class: "HistoryListItemHeader", "data-id": luckywheel.program.id, onClick: toggleLuckyWheelHistory }, luckywheel.program.name['en'] || luckywheel.program.name['*'], h("button", { class: "EngagementSuiteIconButton ArrowDown" })), h("div", { class: "HistoryListItemBody" }, h("div", { class: "HistoryInfoRow" }, Object.entries(historyGroups).map((histories) => {
+            return histories[0] === luckywheel.program.id && histories[1].map((history) => {
+                return h("div", { class: "HistoryInfo" }, h("div", { class: "HistoryCol Rewards" }, getRewards(luckywheel, history.draw.result)), h("div", { class: "HistoryCol Issued" }, getStatus(history.draw.state)), h("div", { class: "HistoryCol Time" }, format(new Date(history.draw.time), 'LLL d, yyyy HH:mm:ss')));
+            });
+        }))));
+    }));
+};

package/dist/collection/utils/locale.utils.js

@@ -0,0 +1,46 @@
+const DEFAULT_LANGUAGE = 'en';
+const SUPPORTED_LANGUAGES = ['en'];
+const TRANSLATIONS = {
+    en: {
+        luckywheels: 'LuckyWheels',
+        join: 'Join',
+        unjoin: 'Unjoin',
+        new: 'new',
+        noluckywheels: 'No Unlocked LuckyWheel',
+        tryOtherGames: 'Try winning LuckyWheel as rewards or launching other booster games',
+        tooltip: 'LuckyWheels where your real money bets contribute towards the level progress to achieve the level reward',
+        history: 'History',
+        rewards: 'Rewards',
+        issued: 'Issued',
+        time: 'Time',
+        loading: 'Loading...',
+        noHistory: 'No LuckyWheels’ history available (last 30 days)',
+        freeSpins: 'Free Spins',
+        luckyWheel: 'LuckyWheel',
+        leaderboard: 'Leaderboard',
+        mission: 'Mission',
+        canceled: 'The luckywheel has been canceled.',
+        support: 'Please, contact support.'
+    }
+};
+export const translate = (key, customLang) => {
+    const lang = customLang;
+    return TRANSLATIONS[lang !== undefined && SUPPORTED_LANGUAGES.includes(lang) ? lang : DEFAULT_LANGUAGE][key];
+};
+export const getTranslations = (url) => {
+    // fetch url, get the data, replace the TRANSLATIONS content
+    return new Promise((resolve, reject) => {
+        fetch(url)
+            .then((res) => res.json())
+            .then((data) => {
+            Object.keys(data).forEach((item) => {
+                for (let key in data[item]) {
+                    TRANSLATIONS[item][key] = data[item][key];
+                }
+            });
+            resolve(TRANSLATIONS);
+        }).catch(err => {
+            reject(err);
+        });
+    });
+};

package/dist/collection/utils/utils.js

@@ -0,0 +1,3 @@
+export function format(first, middle, last) {
+    return (first || '') + (middle ? ` ${middle}` : '') + (last ? ` ${last}` : '');
+}

package/dist/esm/app-globals-0f993ce5.js

@@ -0,0 +1,3 @@
+const globalScripts = () => {};
+
+export { globalScripts as g };