@everymatrix/lottery-subscription 0.0.1

package/dist/cjs/lottery-subscription.cjs.entry.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const lotterySubscription = require('./lottery-subscription-99a4efee.js');
+require('./index-a7f3c31f.js');
+
+
+
+exports.lottery_subscription = lotterySubscription.LotterySubscription;

package/dist/cjs/lottery-subscription.cjs.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-a7f3c31f.js');
+const appGlobals = require('./app-globals-3a1e7e63.js');
+
+/*
+ Stencil Client Patch Browser v4.19.2 | MIT Licensed | https://stenciljs.com
+ */
+var patchBrowser = () => {
+  const importMeta = (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('lottery-subscription.cjs.js', document.baseURI).href));
+  const opts = {};
+  if (importMeta !== "") {
+    opts.resourcesUrl = new URL(".", importMeta).href;
+  }
+  return index.promiseResolve(opts);
+};
+
+patchBrowser().then(async (options) => {
+  await appGlobals.globalScripts();
+  return index.bootstrapLazy([["lottery-subscription.cjs",[[1,"lottery-subscription",{"translationUrl":[520,"translation-url"],"clientStyling":[513,"client-styling"],"clientStylingUrlContent":[513,"client-styling-url-content"],"endpoint":[513],"endpointTicket":[513,"endpoint-ticket"],"endpointSubscription":[513,"endpoint-subscription"],"language":[513],"gameName":[513,"game-name"],"isSubscribed":[32],"frequenceList":[32],"frequenceState":[32],"filterData":[32],"subscriptionCode":[32],"conditionId":[32],"paramId":[32],"conditionRule":[32],"paramRule":[32],"peroidRule":[32],"startDateRule":[32],"endDateRule":[32],"gameNameRule":[32],"ruleType":[32],"limitStylingAppends":[32]}]]]], options);
+});
+
+exports.setNonce = index.setNonce;

package/dist/collection/collection-manifest.json

@@ -0,0 +1,12 @@
+{
+  "entries": [
+    "components/lottery-subscription/lottery-subscription.js"
+  ],
+  "compiler": {
+    "name": "@stencil/core",
+    "version": "4.19.2",
+    "typescriptVersion": "5.4.5"
+  },
+  "collections": [],
+  "bundles": []
+}

package/dist/collection/components/lottery-subscription/index.js

@@ -0,0 +1 @@
+export { LotterySubscription } from './lottery-subscription';

package/dist/collection/components/lottery-subscription/lottery-subscription.css

@@ -0,0 +1,17 @@
+.subscripitonContainer {
+  margin-bottom: 40px;
+}
+.subscripitonContainer vaadin-checkbox[checked]::part(checkbox) {
+  background-color: var(--emw--color-background, #009993);
+}
+.subscripitonContainer .secondCondition {
+  padding-left: 24px;
+}
+.subscripitonContainer .thirdCondition {
+  display: flex;
+  gap: 24px;
+  align-items: center;
+}
+.subscripitonContainer .thirdCondition, .subscripitonContainer .secondConditon {
+  margin: 16px 0;
+}

package/dist/collection/components/lottery-subscription/lottery-subscription.js

@@ -0,0 +1,457 @@
+import { h } from "@stencil/core";
+import { translate, getTranslations } from "../../utils/locale.utils";
+import { fetchRequest } from "../../utils/utils";
+import "../../../../../../../libs/vaadin-facade/index";
+import { format } from "date-fns";
+export class LotterySubscription {
+    constructor() {
+        this.setClientStyling = () => {
+            let sheet = document.createElement('style');
+            sheet.innerHTML = this.clientStyling;
+            this.stylingContainer.prepend(sheet);
+        };
+        this.setClientStylingURL = () => {
+            let cssFile = document.createElement('style');
+            setTimeout(() => {
+                cssFile.innerHTML = this.clientStylingUrlContent;
+                this.stylingContainer.prepend(cssFile);
+            }, 1);
+        };
+        this.changeDateParam = () => {
+            if (this.filterData.from && !this.filterData.to) {
+                let from = this.filterData.from;
+                let dateArray = from.split('/');
+                from = new Date(Date.UTC(Number(dateArray[2]), Number(dateArray[1]) - 1, Number(dateArray[0]), 0, 0, 0)).toISOString();
+                const ruleDefinitionParams = {
+                    conditionMetadata: this.conditionRule,
+                    paramMetadata: this.paramRule,
+                    conditions: [
+                        {
+                            value: from,
+                            fieldId: this.startDateRule.id
+                        },
+                        {
+                            value: '',
+                            fieldId: this.endDateRule.id
+                        },
+                        {
+                            value: this.frequenceState,
+                            fieldId: this.peroidRule.id
+                        },
+                        {
+                            fieldId: this.gameNameRule.id,
+                            value: this.gameName
+                        }
+                    ],
+                    params: [],
+                    ruleType: this.ruleType
+                };
+                ruleDefinitionParams.params = this.paramRule.fields.map((field) => {
+                    return {
+                        value: '',
+                        field,
+                        fieldId: field.id
+                    };
+                });
+                this.subscriptionCompleted.emit(ruleDefinitionParams);
+            }
+            if (this.filterData.from && this.filterData.to) {
+                const { from, to } = this.transDate(this.filterData.from, this.filterData.to);
+                const ruleDefinitionParams = {
+                    conditionMetadata: this.conditionRule,
+                    paramMetadata: this.paramRule,
+                    conditions: [
+                        {
+                            value: from,
+                            fieldId: this.startDateRule.id
+                        },
+                        {
+                            value: to,
+                            fieldId: this.endDateRule.id
+                        },
+                        {
+                            value: this.frequenceState,
+                            fieldId: this.peroidRule.id
+                        },
+                        {
+                            fieldId: this.gameNameRule.id,
+                            value: this.gameName
+                        }
+                    ],
+                    params: [],
+                    ruleType: this.ruleType
+                };
+                ruleDefinitionParams.params = this.paramRule.fields.map((field) => {
+                    return {
+                        value: '',
+                        field,
+                        fieldId: field.id
+                    };
+                });
+                this.subscriptionCompleted.emit(ruleDefinitionParams);
+            }
+        };
+        this.handleFilterFrom = (event) => {
+            const inputElement = event.target;
+            let dateArray = inputElement.value.split('-');
+            if (dateArray.length === 3) {
+                this.filterData = Object.assign(Object.assign({}, this.filterData), { from: `${dateArray[2]}/${dateArray[1]}/${dateArray[0]}` });
+            }
+            this.changeDateParam();
+        };
+        this.handleFilterTo = (event) => {
+            const inputElement = event.target;
+            let dateArray = inputElement.value.split('-');
+            if (dateArray.length === 3) {
+                this.filterData = Object.assign(Object.assign({}, this.filterData), { to: `${dateArray[2]}/${dateArray[1]}/${dateArray[0]}` });
+            }
+            this.changeDateParam();
+        };
+        this.translationUrl = undefined;
+        this.clientStyling = '';
+        this.clientStylingUrlContent = '';
+        this.endpoint = undefined;
+        this.endpointTicket = undefined;
+        this.endpointSubscription = undefined;
+        this.language = 'en';
+        this.gameName = undefined;
+        this.isSubscribed = false;
+        this.frequenceList = [];
+        this.frequenceState = '';
+        this.filterData = { from: '', to: '' };
+        this.subscriptionCode = 'lottery-subscription-widget001';
+        this.conditionId = '';
+        this.paramId = '';
+        this.conditionRule = undefined;
+        this.paramRule = undefined;
+        this.peroidRule = undefined;
+        this.startDateRule = undefined;
+        this.endDateRule = undefined;
+        this.gameNameRule = undefined;
+        this.ruleType = '';
+        this.limitStylingAppends = false;
+    }
+    componentWillLoad() {
+        if (this.translationUrl) {
+            getTranslations(JSON.parse(this.translationUrl));
+        }
+        this.getSubscriptionData();
+    }
+    componentDidRender() {
+        if (!this.limitStylingAppends && this.stylingContainer) {
+            if (this.clientStyling)
+                this.setClientStyling();
+            if (this.clientStylingUrlContent)
+                this.setClientStylingURL();
+            this.limitStylingAppends = true;
+        }
+    }
+    transDate(from, to) {
+        let dateArray = from.split('/');
+        let dateArrayTo = to.split('/');
+        const transferData = {
+            from: new Date(Date.UTC(Number(dateArray[2]), Number(dateArray[1]) - 1, Number(dateArray[0]), 0, 0, 0)).toISOString(),
+            to: new Date(Date.UTC(Number(dateArrayTo[2]), Number(dateArrayTo[1]) - 1, Number(dateArrayTo[0]), 23, 59, 59)).toISOString(),
+        };
+        return transferData;
+    }
+    async getSubscriptionData() {
+        try {
+            const url = `${this.endpointSubscription}/feWidgetConfig/${this.subscriptionCode}`;
+            const { conditionMetadataId, paramMetadataId, ruleType } = await fetchRequest(url);
+            this.conditionId = conditionMetadataId;
+            this.paramId = paramMetadataId;
+            this.ruleType = ruleType;
+            const metaConditionUrl = `${this.endpointSubscription}/metadata/${this.conditionId}`;
+            const metaParamUrl = `${this.endpointSubscription}/metadata/${this.paramId}`;
+            const [conditionConfig, paramConfig] = await Promise.allSettled([fetchRequest(metaConditionUrl), fetchRequest(metaParamUrl)]);
+            if (conditionConfig.status === 'fulfilled' && paramConfig.status === 'fulfilled') {
+                this.conditionRule = conditionConfig.value;
+                this.paramRule = paramConfig.value;
+                if (this.conditionRule.fields) {
+                    this.peroidRule = this.conditionRule.fields.find((field) => field.code === 'Period');
+                    this.startDateRule = this.conditionRule.fields.find((field) => field.code === 'StartDate');
+                    this.endDateRule = this.conditionRule.fields.find((field) => field.code === 'EndDate');
+                    this.gameNameRule = this.conditionRule.fields.find((field) => field.code === 'GameName');
+                    this.frequenceList = this.peroidRule.enums.map((item) => {
+                        return {
+                            label: item.text,
+                            value: item.key
+                        };
+                    });
+                }
+            }
+            else {
+                throw new Error('Failed to get subscription data');
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    handleCheckboxchange(e) {
+        this.isSubscribed = e.target.checked;
+        this.subscriptionCheckChange.emit(this.isSubscribed);
+    }
+    handleSelectionChange(event) {
+        this.frequenceState = event.detail.value;
+        if (this.frequenceState === 'NeverMissADraw' && this.isSubscribed) {
+            const ruleDefinitionParams = {
+                conditionMetadata: this.conditionRule,
+                paramMetadata: this.paramRule,
+                conditions: [
+                    {
+                        value: this.frequenceState,
+                        fieldId: this.peroidRule.id
+                    },
+                    {
+                        fieldId: this.gameNameRule.id,
+                        value: this.gameName
+                    }
+                ],
+                params: [],
+                ruleType: this.ruleType
+            };
+            ruleDefinitionParams.params = this.paramRule.fields.map((field) => {
+                return {
+                    value: '',
+                    fieldId: field.id
+                };
+            });
+            this.subscriptionCompleted.emit(ruleDefinitionParams);
+        }
+        else if (this.frequenceState === 'Custom' && this.isSubscribed) {
+            this.subscriptionCompleted.emit('Subscription start date is required.');
+        }
+    }
+    formateDate(dateParts) {
+        const { year, month, day } = dateParts;
+        const date = new Date(year, month, day);
+        return format(date, 'dd/MM/yyyy');
+    }
+    parseDate(inputValue) {
+        const [day, month, year] = inputValue.split('/');
+        return { year, month: parseInt(month) - 1, day };
+    }
+    changeFormate(str) {
+        const [day, month, year] = str.split('/');
+        return `${year}-${month}-${day}`;
+    }
+    setDateFormate(dom) {
+        if (dom) {
+            dom.i18n = Object.assign(Object.assign({}, dom.i18n), { formatDate: this.formateDate, parseDate: this.parseDate });
+        }
+    }
+    render() {
+        return (h("div", { key: '1bf289722935c5d2b574ba18f322830c81335585', class: "subscripitonContainer", ref: el => this.stylingContainer = el }, h("vaadin-checkbox", { key: '5f62fb61bccecd3632525ab0b28a41e45487c7ec', label: "Subscription", checked: this.isSubscribed, onChange: this.handleCheckboxchange.bind(this) }), this.isSubscribed &&
+            h("div", { key: 'd8e56e346ca8f275866738ab9c6d8eb14437d84a', class: "secondConditon" }, h("span", { key: '13c61d7582b1e0716395bd06c410a621b8af97d8', style: { 'margin-right': '8px' } }, "Occurrence: "), h("vaadin-select", { key: 'cf8d9c4176f66d2095798cae79b82b748e7ffb0b', items: this.frequenceList, value: this.frequenceState, "on-value-changed": this.handleSelectionChange.bind(this) }), this.frequenceState === 'Custom' &&
+                h("div", { key: 'c1496adac7e295830074da0b096bf4bbc0af8247', class: "thirdCondition" }, h("div", { key: '2aa4f92c84ab37edee56640ae0657f59e92c3719', class: "filterCalenderWrap" }, h("div", { key: '6665e3f2bd28650794eb174db6081ab4a9f514f0', class: "filterText" }, "Subscription Start Date*"), h("div", { key: '50a05e684bf068ab00d6d4298e65a6b94c44b79a', class: "filter" }, h("vaadin-date-picker", { value: this.filterData.from, key: "filterFromCalendar", max: this.filterData.to === undefined ? undefined : this.changeFormate(this.filterData.to), onChange: this.handleFilterFrom, placeholder: translate('filterFromCalendar', this.language), ref: el => this.setDateFormate(el), class: "VaadinDatePicker" }))), h("div", { key: '85c4bf037ad7bc9797f809aa7e71fcbfbc80c298', class: "filterCalenderWrap" }, h("div", { key: '87b446788202ae55ad698c8455c9a6d09a9d22d6', class: "filterText" }, "Subscription End Date"), h("div", { key: '5700c92b2f0c57959f84b5f7ac7a3488d1d0d096', class: "filter" }, h("vaadin-date-picker", { value: this.filterData.to, key: "filterToCalendar", min: this.filterData.from === undefined ? undefined : this.changeFormate(this.filterData.from), onChange: this.handleFilterTo, placeholder: translate('filterToCalendar', this.language), ref: el => this.setDateFormate(el), class: "VaadinDatePicker" })))))));
+    }
+    static get is() { return "lottery-subscription"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["lottery-subscription.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["lottery-subscription.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "translationUrl": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Translation via url"
+                },
+                "attribute": "translation-url",
+                "reflect": true
+            },
+            "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": "''"
+            },
+            "clientStylingUrlContent": {
+                "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-content",
+                "reflect": true,
+                "defaultValue": "''"
+            },
+            "endpoint": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Endpoint URL for the source of data"
+                },
+                "attribute": "endpoint",
+                "reflect": true
+            },
+            "endpointTicket": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "EndpointTicket URL for the source of ticket data"
+                },
+                "attribute": "endpoint-ticket",
+                "reflect": true
+            },
+            "endpointSubscription": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Endpoint URL for the source of subscription data"
+                },
+                "attribute": "endpoint-subscription",
+                "reflect": true
+            },
+            "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": true,
+                "defaultValue": "'en'"
+            },
+            "gameName": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "the name of the game"
+                },
+                "attribute": "game-name",
+                "reflect": true
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isSubscribed": {},
+            "frequenceList": {},
+            "frequenceState": {},
+            "filterData": {},
+            "subscriptionCode": {},
+            "conditionId": {},
+            "paramId": {},
+            "conditionRule": {},
+            "paramRule": {},
+            "peroidRule": {},
+            "startDateRule": {},
+            "endDateRule": {},
+            "gameNameRule": {},
+            "ruleType": {},
+            "limitStylingAppends": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "subscriptionCompleted",
+                "name": "subscriptionCompleted",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "subscriptionCheckChange",
+                "name": "subscriptionCheckChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }];
+    }
+}

package/dist/collection/components/lottery-subscription/lottery-subscription.type.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/index.js

@@ -0,0 +1 @@
+export * from './components/lottery-subscription';

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

@@ -0,0 +1,35 @@
+const DEFAULT_LANGUAGE = 'en';
+const SUPPORTED_LANGUAGES = ['ro', 'en', 'hr'];
+const TRANSLATIONS = {
+    en: {
+        filterFromCalendar: 'Start Date',
+        filterToCalendar: 'End Date'
+    },
+    ro: {
+        filterFromCalendar: 'Start Date',
+        filterToCalendar: 'End Date'
+    },
+    fr: {
+        filterFromCalendar: 'Start Date',
+        filterToCalendar: 'End Date'
+    },
+    ar: {
+        filterFromCalendar: 'Start Date',
+        filterToCalendar: 'End Date'
+    },
+    hr: {
+        filterFromCalendar: 'Start Date',
+        filterToCalendar: 'End Date'
+    }
+};
+export const translate = (key, customLang) => {
+    const lang = customLang;
+    return TRANSLATIONS[lang !== undefined && SUPPORTED_LANGUAGES.includes(lang) ? lang : DEFAULT_LANGUAGE][key];
+};
+export const getTranslations = (data) => {
+    Object.keys(data).forEach((item) => {
+        for (let key in data[item]) {
+            TRANSLATIONS[item][key] = data[item][key];
+        }
+    });
+};

package/dist/collection/utils/utils.js

@@ -0,0 +1,28 @@
+export const generateUUID = () => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+};
+export function fetchRequest(url, method = 'GET', body = null, headers = {}) {
+    return new Promise((resolve, reject) => {
+        const uuid = generateUUID();
+        const options = {
+            method,
+            headers: Object.assign({ 'Content-Type': 'application/json', 'X-Idempotency-Key': uuid }, headers),
+            body: null
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        fetch(url, options)
+            .then(response => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            return response.json();
+        })
+            .then(data => resolve(data))
+            .catch(error => reject(error));
+    });
+}

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

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