@everymatrix/lottery-oddsbom-ticket-result 0.0.1

package/dist/collection/utils/api.js

@@ -0,0 +1,55 @@
+import { fetchRequest } from "./utils";
+async function fetchTicketMatch({ endpoint, gameId, drawId }) {
+    try {
+        const res = await fetchRequest(`${endpoint}/games/${gameId}/draws/${drawId}/findDrawEvents`);
+        return res || [];
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+function getTeamsFromEventName(eventName) {
+    if (!eventName)
+        return '';
+    return eventName.split('vs').map((i) => i.trim());
+}
+function resolveSelections(resInMatch) {
+    const mySet1 = new Set();
+    const mySet2 = new Set();
+    for (const resInLine of resInMatch) {
+        const [team1Score, team2Score] = resInLine.split(':');
+        if (!mySet1.has(team1Score))
+            mySet1.add(team1Score);
+        if (!mySet2.has(team1Score))
+            mySet2.add(team2Score);
+    }
+    return [Array.from(mySet1), Array.from(mySet2)];
+}
+export async function buildTicketBetDataSource({ endpoint, gameId, drawId, results, splitView = false }) {
+    const res = await fetchTicketMatch({ endpoint, gameId, drawId });
+    if (splitView) {
+        return (res.reduce((pre, item, index) => {
+            const [team1Name, team2Name] = getTeamsFromEventName(item.eventName);
+            const [team1Res, team2Res] = resolveSelections(results[index] || []);
+            pre === null || pre === void 0 ? void 0 : pre.push({
+                index: index + 1,
+                teamName: team1Name,
+                startTime: item.startTime,
+                results: team1Res
+            });
+            pre === null || pre === void 0 ? void 0 : pre.push({
+                index: index + 1,
+                teamName: team2Name,
+                startTime: item.startTime,
+                results: team2Res
+            });
+            return pre;
+        }, []) || []);
+    }
+    return res.map((item, index) => ({
+        index: index + 1,
+        eventName: item.eventName,
+        startTime: item.startTime,
+        results: results[index] || []
+    }));
+}

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

@@ -0,0 +1,142 @@
+const DEFAULT_LANGUAGE = 'en';
+const SUPPORTED_LANGUAGES = ['ro', 'en', 'fr', 'ar', 'hr'];
+const TRANSLATIONS = {
+    en: {
+        filter: 'Filter',
+        clear: 'Clear',
+        searchByTicketId: 'Search by Ticket ID',
+        enterTicketId: 'Enter Ticket ID',
+        searchByTicketType: 'Search by Ticket Type',
+        selectTicketType: 'Select Ticket Type',
+        searchByDate: 'Search by Date',
+        from: 'From',
+        to: 'To',
+        normal: 'Normal',
+        subscription: 'Subscription',
+        ticketsHistory: 'Tickets History',
+        settled: 'Settled',
+        purchased: 'Purchased',
+        canceled: 'Canceled',
+        noData: 'No data Avaliable.',
+        ticketId: 'Ticket ID:',
+        ticketType: 'Ticket Type:',
+        ticketAmount: 'Ticket Amount:',
+        lineDetail: 'Line Detail:',
+        seeDetails: 'See Details',
+        numberOfDraw: 'Number of Draw:',
+        ticketResult: 'Ticket Result:',
+        drawId: 'Draw ID:',
+        drawDate: 'Draw Date:',
+        result: 'Result:',
+        prize: 'Prize:',
+        bettingType: 'Betting Type:'
+    },
+    ro: {
+        ticketsHistory: 'Istoric bilete',
+        settled: 'Decontat',
+        purchased: 'Achiziționat',
+        canceled: 'Anulat',
+        noData: 'Nu sunt date disponibile.',
+        ticketId: 'ID bilet:',
+        ticketType: 'Tip bilet:',
+        ticketAmount: 'Suma biletului:',
+        lineDetail: 'Detaliu linie:',
+        seeDetails: 'Vezi detalii',
+        numberOfDraw: 'Număr de extrageri:',
+        ticketResult: 'Rezultat bilet:',
+        drawId: 'ID extragere:',
+        drawDate: 'Data extragerii:',
+        result: 'Rezultat:',
+        prize: 'Premiu:',
+        bettingType: 'Tip de pariu:'
+    },
+    fr: {
+        ticketsHistory: 'Historique des billets',
+        settled: 'Réglé',
+        purchased: 'Acheté',
+        canceled: 'Annulé',
+        noData: 'Aucune donnée disponible.',
+        ticketId: 'ID du billet:',
+        ticketType: 'Type de billet:',
+        ticketAmount: 'Montant du billet:',
+        lineDetail: 'Détail de la ligne:',
+        seeDetails: 'Voir les détails',
+        numberOfDraw: 'Nombre de tirages:',
+        ticketResult: 'Résultat du billet:',
+        drawId: 'ID du tirage:',
+        drawDate: 'Date du tirage:',
+        result: 'Résultat:',
+        prize: 'Prix:',
+        bettingType: 'Type de pari:'
+    },
+    ar: {
+        ticketsHistory: 'سجل التذاكر',
+        settled: 'تمت التسوية',
+        purchased: 'تم شراؤها',
+        canceled: 'تم الإلغاء',
+        noData: 'لا توجد بيانات متاحة.',
+        ticketId: 'معرف التذكرة:',
+        ticketType: 'نوع التذكرة:',
+        ticketAmount: 'مبلغ التذكرة:',
+        lineDetail: 'تفاصيل الخط:',
+        seeDetails: 'انظر التفاصيل',
+        numberOfDraw: 'عدد السحوبات:',
+        ticketResult: 'نتيجة التذكرة:',
+        drawId: 'معرف السحب:',
+        drawDate: 'تاريخ السحب:',
+        result: 'النتيجة:',
+        prize: 'الجائزة:',
+        bettingType: 'نوع الرهان:'
+    },
+    hr: {
+        ticketsHistory: 'Povijest listića',
+        settled: 'Riješeno',
+        purchased: 'Kupljeno',
+        canceled: 'Otkazano',
+        noData: 'Nema dostupnih podataka.',
+        ticketId: 'ID listića:',
+        ticketType: 'Vrsta listića:',
+        ticketAmount: 'Iznos listića:',
+        lineDetail: 'Detalji linije:',
+        seeDetails: 'Vidi detalje',
+        numberOfDraw: 'Broj izvlačenja:',
+        ticketResult: 'Rezultat listića:',
+        drawId: 'ID izvlačenja:',
+        drawDate: 'Datum izvlačenja:',
+        result: 'Rezultat:',
+        prize: 'Nagrada:',
+        bettingType: 'Vrsta oklade:'
+    }
+};
+export const translate = (key, customLang, replacements) => {
+    const lang = customLang;
+    let translation = TRANSLATIONS[lang !== undefined && SUPPORTED_LANGUAGES.includes(lang) ? lang : DEFAULT_LANGUAGE][key];
+    if (replacements) {
+        Object.keys(replacements).forEach((placeholder) => {
+            translation = translation === null || translation === void 0 ? void 0 : translation.replace(`{${placeholder}}`, replacements[placeholder]);
+        });
+    }
+    return translation;
+};
+const getTranslations = (data) => {
+    Object.keys(data).forEach((item) => {
+        for (let key in data[item]) {
+            TRANSLATIONS[item][key] = data[item][key];
+        }
+    });
+};
+export const resolveTranslationUrl = async (translationUrl) => {
+    if (translationUrl) {
+        try {
+            const response = await fetch(translationUrl);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const translations = await response.json();
+            getTranslations(translations);
+        }
+        catch (error) {
+            console.error('Failed to fetch or parse translations from URL:', error);
+        }
+    }
+};

package/dist/collection/utils/utils.js

@@ -0,0 +1,133 @@
+import { format as _format, parseISO } from "date-fns";
+export function format(first, middle, last) {
+    return (first || '') + (middle ? ` ${middle}` : '') + (last ? ` ${last}` : '');
+}
+export const formatDate = ({ date, type = 'date', format }) => {
+    try {
+        const parsedDate = parseISO(date);
+        if (isNaN(parsedDate.getTime())) {
+            throw new Error(`Invalid date: ${date}`);
+        }
+        if (format)
+            return _format(parsedDate, format);
+        let formatStr = 'dd/MM/yyyy';
+        if (type === 'time') {
+            formatStr = 'dd/MM/yyyy HH:mm:ss';
+        }
+        else if (type === 'week') {
+            formatStr = 'ccc dd/MM/yyyy HH:mm:ss';
+        }
+        return _format(parsedDate, formatStr);
+    }
+    catch (error) {
+        console.error('Error formatting date:', error.message);
+        return '';
+    }
+};
+export function toQueryParams(params) {
+    const finalParams = {};
+    Object.entries(params).forEach(([key, value]) => {
+        if (!isEmptyValue(value, true)) {
+            finalParams[key] = value;
+        }
+    });
+    const queryString = Object.entries(finalParams)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join('&');
+    return queryString ? `?${queryString}` : '';
+}
+function isEmptyValue(value, allowZero) {
+    if (value === null || value === undefined || value === '') {
+        return true;
+    }
+    else if (value === 0 && allowZero) {
+        return false;
+    }
+    else if (Array.isArray(value)) {
+        return isEmptyValueOfArray(value);
+    }
+    else if (Object.prototype.toString.call(value) === '[object Object]') {
+        return isEmptyValueOfObject(value);
+    }
+    else {
+        return !value;
+    }
+}
+function isEmptyValueOfArray(arr) {
+    if (arr.length === 0) {
+        return true;
+    }
+    const len = arr.length;
+    let count = 0;
+    for (let i = 0; i < len; i++) {
+        if (isEmptyValue(arr[i])) {
+            count++;
+        }
+        else {
+            return false;
+        }
+    }
+    if (count === len) {
+        return true;
+    }
+    return false;
+}
+function isEmptyValueOfObject(obj) {
+    if (Object.keys(obj).length === 0) {
+        return true;
+    }
+    const len = Object.keys(obj).length;
+    let count = 0;
+    for (const val of Object.values(obj)) {
+        if (isEmptyValue(val)) {
+            count++;
+        }
+        else {
+            return false;
+        }
+    }
+    if (count === len) {
+        return true;
+    }
+    return false;
+}
+export function fetchRequest(url, method = 'GET', body = null, headers = {}) {
+    return new Promise((resolve, reject) => {
+        const headersOrigin = Object.assign({ 'Content-Type': 'application/json' }, headers);
+        const options = {
+            method,
+            headers: headersOrigin,
+            body: null
+        };
+        if (body && method !== 'GET' && method !== 'HEAD') {
+            options.body = JSON.stringify(body);
+        }
+        else {
+            delete options.body;
+        }
+        fetch(url, options)
+            .then((response) => {
+            if (!response.ok) {
+                return response.json().then((errorData) => {
+                    const error = {
+                        status: response.status,
+                        statusText: response.statusText,
+                        code: errorData.code || 'UNKNOWN_ERROR',
+                        message: errorData.message || 'An unknown error occurred',
+                        data: errorData.data || null
+                    };
+                    reject(error);
+                }, () => reject({
+                    status: response.status,
+                    statusText: response.statusText,
+                    code: 'PARSE_ERROR',
+                    message: 'Failed to parse error response'
+                }));
+            }
+            else {
+                return response.json();
+            }
+        })
+            .then((data) => resolve(data), (error) => reject(error));
+    });
+}

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

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