@coinmeca/wallet-provider/dist/telegram.jsx

This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).

"use client";
import Script from "next/script";
import React, { createContext, useContext, useEffect, useMemo, useState } from "react";
import CryptoJS from "crypto-js";
export const encrypt = (data, salt) => {
    if (!data || !salt)
        return data;
    return CryptoJS.AES.encrypt(data, CryptoJS.SHA256(salt), {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
    }).toString();
};
export const decrypt = (data, salt) => {
    if (!data)
        return undefined;
    else if (!salt)
        return data;
    return CryptoJS.AES.decrypt(data, CryptoJS.SHA256(salt), {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
    }).toString(CryptoJS.enc.Utf8);
};
export const format = (value) => {
    if (!value || typeof value === "undefined")
        return value;
    if (typeof value === "boolean" || typeof value === "number")
        return value.toString();
    return JSON.stringify(value);
};
export const parse = (value) => {
    if (!value || typeof value === "undefined")
        return value;
    if (value === "true" || value === "false")
        return value === "true";
    if (/^[0-9]*\.[0-9]+$/.test(value))
        return parseFloat(value);
    return JSON.parse(value);
};
export const loadStorage = (prefix, storage, isTelegram, salt) => ({
    get: (key) => {
        return parse(decrypt(storage?.getItem(encrypt(`${prefix}:${key}`, salt)), salt));
    },
    gets: (keys) => {
        const values = {};
        if (isTelegram) {
            const items = storage?.getItems(keys?.map((k) => encrypt(`${prefix}:${k}`, salt)));
            items.forEach((v, i) => {
                if (v)
                    values[keys[i]] = parse(decrypt(v, salt));
            });
        }
        else {
            keys.forEach((key) => {
                const value = storage?.getItem(encrypt(`${prefix}:${key}`, salt));
                if (value)
                    values[key] = parse(decrypt(value, salt));
            });
        }
        return values;
    },
    getAll: () => {
        const values = {};
        if (isTelegram) {
            const keys = storage?.getKeys();
            const items = storage?.getItems(keys?.map((k) => decrypt(k, salt)));
            items.forEach((v, i) => {
                if (v)
                    values[keys[i].replace(`${prefix}:`, "")] = parse(decrypt(v, salt));
            });
        }
        else {
            if (storage?.length)
                for (let i = 0; i < storage.length; i++) {
                    const key = decrypt(storage?.key(i), salt);
                    if (key && key.startsWith(`${prefix}:`)) {
                        const value = storage?.getItem(key);
                        if (value)
                            values[key.replace(`${prefix}:`, "")] = parse(decrypt(value, salt));
                    }
                }
        }
        return values;
    },
    set: (key, value) => {
        value = encrypt(format(value), salt);
        return value && storage?.setItem(encrypt(`${prefix}:${key}`, salt), value);
    },
    sets: (map) => {
        return (map &&
            Array.isArray(map) &&
            Array?.isArray(map?.[0]) &&
            map?.map((item) => {
                if (item?.[0] && item?.[1]) {
                    const value = encrypt(format(item[1]), salt);
                    if (value)
                        storage?.setItem(encrypt(`${prefix}:${item[0]}`, salt), value);
                }
            }));
    },
    remove: (key) => {
        return storage?.removeItem(encrypt(`${prefix}:${key}`, salt));
    },
    removes: (keys) => {
        if (isTelegram) {
            storage?.removeItems(keys?.map((k) => encrypt(`${prefix}:${k}`, salt)));
        }
        else {
            keys.forEach((key) => localStorage.removeItem(encrypt(`${prefix}:${key}`, salt)));
        }
    },
    clear: () => {
        try {
            return isTelegram ? storage?.removeItems(storage?.getKeys()?.map((k) => encrypt(k, salt))) : storage?.clear();
        }
        catch (e) {
            console.error(e);
        }
    },
});
export const loadTelegram = (telegram) => ({
    telegram,
    user: telegram?.initDataUnsafe?.user,
    isInApp: telegram && telegram?.platform !== "unknown",
    isExpanded: telegram?.isExpanded || false,
    isVerticalSwipe: telegram?.isVerticalSwipesEnabled,
    isCloseConfirm: telegram?.isClosingConfirmationEnabled,
    storage: telegram?.CloudStorage,
    send: (text) => telegram && telegram?.sendData(text),
    enable: {
        vertical: () => telegram?.enableVerticalSwipes?.(),
        closeConfirm: () => telegram?.enableClosingConfirmation?.(),
    },
    disable: {
        vertical: () => telegram?.disableVerticalSwipes?.(),
        closeConfirm: () => telegram?.disableClosingConfirmation?.(),
    },
    bio: {
        request: (reason) => telegram && telegram.BiometricManager.requestAccess({ reason }),
        auth: (reason) => telegram && telegram.BiometricManager.authenticate({ reason }),
    },
    show: {
        alert: (message, callback) => telegram && telegram?.showAlert(message, callback),
        confirm: (title, callback) => telegram && telegram?.showConfirm(title, callback),
        popup: (popup, callback) => telegram && telegram?.showPopup(popup, callback),
        scanQR: (text, callback) => telegram && telegram?.showScanQrPopup({ text }, callback),
    },
    open: {
        internal: (url, callback) => {
            if (telegram) {
                telegram?.openTelegramLink(url);
                callback?.();
            }
        },
        external: (url, try_instant_view, callback) => {
            if (telegram) {
                telegram?.openLink(url, { try_instant_view });
                callback?.();
            }
        },
    },
    expand: (callback) => {
        if (telegram) {
            telegram?.expand();
            callback?.();
        }
    },
    exit: (callback) => {
        if (telegram) {
            telegram?.close();
            telegram?.MainButton?.offClick(() => {
                callback?.();
            });
        }
    },
});
const TelegramContext = createContext(undefined);
export const useTelegram = () => {
    const context = useContext(TelegramContext);
    if (!context)
        throw new Error("useTelegram must be used within a TelegramProvider");
    return context;
};
export const TelegramProvider = ({ src = "https://telegram.org/js/telegram-web-app.js", children }) => {
    const [telegram, setTelegram] = useState();
    const [user, setUser] = useState();
    const onLoad = () => {
        const telegram = typeof window !== "undefined" ? window.Telegram?.WebApp || window.Telegram?.WebView : undefined;
        if (telegram) {
            telegram.ready();
            // Assuming BiometricManager exists and has an init method
            if (telegram.BiometricManager)
                telegram.BiometricManager.init();
            telegram.enableVerticalSwipes();
            setTelegram(telegram);
            setUser(telegram.initDataUnsafe?.user);
        }
    };
    const modules = useMemo(() => loadTelegram(telegram), [telegram]);
    useEffect(() => {
        if (telegram) {
            // Define a cleanup function that does not return a value
            return () => {
                if (telegram?.MainButton)
                    telegram?.MainButton?.offClick(() => setUser(undefined));
            };
        }
    }, [telegram]);
    return (<>
            <Script src={src} onLoad={onLoad}/>
            <TelegramContext.Provider value={{
            ...{
                ...modules,
                exit: (callback) => {
                    modules.exit(callback);
                    setUser(undefined);
                },
            },
            telegram,
            user,
        }}>
                {children}
            </TelegramContext.Provider>
        </>);
};
//# sourceMappingURL=telegram.jsx.map