@elcrm/tb 0.0.1

package/README.md

@@ -0,0 +1,523 @@
+# @elcrm/tb - Telegram Bot библиотека
+
+Библиотека для работы с Telegram Bot API на основе Bun runtime. Предоставляет простой и удобный интерфейс для создания Telegram ботов без использования классов.
+
+## Особенности
+
+-   🚀 Простое использование без создания экземпляров
+-   🔧 Автоматическое использование токена из переменных окружения
+-   📦 Типизированный API с полной поддержкой TypeScript
+-   ⚡ Ленивая инициализация - экземпляр создается при первом использовании
+-   🎯 Поддержка webhook для получения обновлений
+-   🔐 Валидация данных Telegram WebApp
+-   ⏱️ Автоматическое ограничение скорости - максимум 30 запросов в секунду
+-   📋 Очередь запросов - все запросы автоматически ставятся в очередь и обрабатываются последовательно
+
+## Установка
+
+```bash
+npm install @elcrm/tb
+# или
+bun add @elcrm/tb
+```
+
+## Быстрый старт
+
+```typescript
+import { tb } from "@elcrm/tb";
+
+// Использование напрямую без создания экземпляра
+// Токен автоматически берется из process.env.TELEGRAM
+
+// Регистрация обработчика сообщений
+tb.onMessage(async (update) => {
+    if (update.message?.text) {
+        const chatId = update.message.from!.id;
+        await tb.sendMessage(chatId, `Вы написали: ${update.message.text}`);
+    }
+});
+
+// Использование webhook
+const routes = tb.webhook("telegram-webhook");
+```
+
+## API Документация
+
+### `tb` - Объект Telegram Bot
+
+Глобальный объект для работы с Telegram Bot API. Токен автоматически берется из переменной окружения `process.env.TELEGRAM`.
+
+**Использование:**
+
+```typescript
+import { tb } from "@elcrm/tb";
+
+// Использование напрямую без создания экземпляра
+tb.onMessage(async (update) => {
+    // обработка сообщений
+});
+
+tb.sendMessage(123456789, "Привет!");
+```
+
+**Примечание:** Если нужно создать несколько экземпляров с разными токенами, используйте функцию `createTelegramBot(token)`:
+
+```typescript
+import { createTelegramBot } from "@elcrm/tb";
+
+const bot1 = createTelegramBot("TOKEN_1");
+const bot2 = createTelegramBot("TOKEN_2");
+```
+
+---
+
+### Методы TelegramBot
+
+#### `onMessage(callback: (update: TelegramUpdate) => void | Promise<void>): void`
+
+Регистрирует обработчик для всех входящих сообщений.
+
+**Параметры:**
+
+-   `callback` - Функция-обработчик, которая вызывается при получении сообщения
+
+**Пример:**
+
+```typescript
+tb.onMessage(async (update) => {
+    if (update.message?.text === "/start") {
+        const chatId = update.message.from!.id;
+        await tb.sendMessage(chatId, "Добро пожаловать!");
+    }
+});
+```
+
+---
+
+#### `onCallbackQuery(name: string, callback: (data: CallbackQueryData) => void | Promise<void>): void`
+
+Регистрирует обработчик для callback query (нажатие на inline-кнопки).
+
+**Параметры:**
+
+-   `name` (string) - Имя обработчика, должно совпадать с `data` кнопки
+-   `callback` - Функция-обработчик, вызываемая при нажатии на кнопку
+
+**Пример:**
+
+```typescript
+// Регистрация обработчика
+tb.onCallbackQuery("button_click", async (data) => {
+    const chatId = data.from.id;
+    await tb.sendMessage(chatId, "Кнопка нажата!");
+});
+
+// Отправка сообщения с inline-кнопкой
+await tb.sendMessage(chatId, "Нажмите кнопку", {
+    inline_keyboard: [[{ text: "Нажми меня", callback_data: "button_click" }]],
+});
+```
+
+---
+
+#### `sendMessage(chat_id: number, text: string, reply_markup?: ReplyMarkup): Promise<any>`
+
+Отправляет текстовое сообщение пользователю.
+
+**Параметры:**
+
+-   `chat_id` (number) - ID чата или пользователя
+-   `text` (string) - Текст сообщения (поддерживает HTML)
+-   `reply_markup` (ReplyMarkup, опционально) - Клавиатура или inline-кнопки
+
+**Пример:**
+
+```typescript
+// Простое сообщение
+await tb.sendMessage(123456789, "Привет!");
+
+// Сообщение с inline-кнопками
+await tb.sendMessage(123456789, "Выберите действие:", {
+    inline_keyboard: [
+        [{ text: "Кнопка 1", callback_data: "action1" }],
+        [{ text: "Кнопка 2", callback_data: "action2" }],
+    ],
+});
+
+// Сообщение с обычной клавиатурой
+await tb.sendMessage(123456789, "Нажмите кнопку:", {
+    keyboard: [[{ text: "Отправить контакт", request_contact: true }]],
+    resize_keyboard: true,
+});
+```
+
+---
+
+#### `sendPhoto(chat_id: number, photo: string, caption?: string, reply_markup?: ReplyMarkup): Promise<any>`
+
+Отправляет фотографию пользователю.
+
+**Параметры:**
+
+-   `chat_id` (number) - ID чата или пользователя
+-   `photo` (string) - URL или file_id фотографии
+-   `caption` (string, опционально) - Подпись к фотографии
+-   `reply_markup` (ReplyMarkup, опционально) - Клавиатура или inline-кнопки
+
+**Пример:**
+
+```typescript
+await tb.sendPhoto(
+    123456789,
+    "https://example.com/image.jpg",
+    "Описание фотографии",
+    {
+        inline_keyboard: [[{ text: "Подробнее", callback_data: "photo_info" }]],
+    }
+);
+```
+
+---
+
+#### `editMessageText(chatId: number, messageId: number, text: string, replyMarkup?: ReplyMarkup): Promise<any>`
+
+Редактирует текст существующего сообщения.
+
+**Параметры:**
+
+-   `chatId` (number) - ID чата
+-   `messageId` (number) - ID сообщения для редактирования
+-   `text` (string) - Новый текст сообщения
+-   `replyMarkup` (ReplyMarkup, опционально) - Новая клавиатура или inline-кнопки
+
+**Пример:**
+
+```typescript
+tb.onCallbackQuery("edit_message", async (data) => {
+    await tb.editMessageText(
+        data.message.chat.id,
+        data.message.message_id,
+        "Сообщение обновлено!"
+    );
+});
+```
+
+---
+
+#### `answerCallbackQuery(callbackId: string, text?: string): Promise<any>`
+
+Отвечает на callback query. Вызывается автоматически при обработке callback_query, но можно вызвать вручную.
+
+**Параметры:**
+
+-   `callbackId` (string) - ID callback query
+-   `text` (string, опционально) - Текст уведомления (если указан, показывается alert)
+
+**Пример:**
+
+```typescript
+tb.onCallbackQuery("show_alert", async (data) => {
+    await tb.answerCallbackQuery(data.id, "Это уведомление!");
+});
+```
+
+---
+
+#### `setWebhook(url: string): Promise<any>`
+
+Устанавливает webhook URL для получения обновлений от Telegram.
+
+**Параметры:**
+
+-   `url` (string) - HTTPS URL для получения обновлений
+
+**Пример:**
+
+```typescript
+const result = await tb.setWebhook("https://example.com/webhook");
+console.log(result);
+```
+
+---
+
+#### `webhook(router: string): Record<string, (req: Request) => Promise<Response>>`
+
+Создает роутер для обработки webhook запросов от Telegram.
+
+**Параметры:**
+
+-   `router` (string) - Путь для webhook (например, 'telegram-webhook')
+
+**Возвращает:** Объект с методом для обработки запросов
+
+**Пример использования с Bun:**
+
+```typescript
+// Регистрация обработчиков
+tb.onMessage(async (update) => {
+    // Обработка сообщений
+});
+
+tb.onCallbackQuery("action", async (data) => {
+    // Обработка callback query
+});
+
+// Создание роутера
+const routes = tb.webhook("telegram-webhook");
+
+// Использование в Bun server
+Bun.serve({
+    port: 3000,
+    fetch(req) {
+        const url = new URL(req.url);
+        const handler = routes[url.pathname];
+        if (handler) {
+            return handler(req);
+        }
+        return new Response("Not found", { status: 404 });
+    },
+});
+```
+
+**Примечание:**
+
+-   GET запросы автоматически устанавливают webhook на URL запроса
+-   POST запросы обрабатывают обновления от Telegram
+
+---
+
+#### `validatingData(body: string | URLSearchParams): boolean`
+
+Валидирует данные от Telegram WebApp.
+
+**Параметры:**
+
+-   `body` (string | URLSearchParams) - Данные от Telegram WebApp
+
+**Возвращает:** `true` если данные валидны, иначе `false`
+
+**Пример:**
+
+```typescript
+// В обработчике запроса от WebApp
+const isValid = tb.validatingData(requestBody);
+if (isValid) {
+    // Данные валидны, можно использовать
+} else {
+    // Данные невалидны
+}
+```
+
+---
+
+#### `handleUpdate(update: TelegramUpdate): Promise<void>`
+
+Обрабатывает обновление от Telegram. Обычно вызывается автоматически через webhook, но можно вызвать вручную.
+
+**Параметры:**
+
+-   `update` (TelegramUpdate) - Объект обновления от Telegram API
+
+**Пример:**
+
+```typescript
+// Ручная обработка обновления
+const update = await fetch("...").then((r) => r.json());
+await tb.handleUpdate(update);
+```
+
+---
+
+## Типы
+
+### `TelegramUpdate`
+
+Интерфейс для обновления от Telegram API.
+
+```typescript
+interface TelegramUpdate {
+    message?: {
+        from?: {
+            id: number;
+            [key: string]: any;
+        };
+        contact?: {
+            phone_number: string;
+            user_id: number;
+            [key: string]: any;
+        };
+        text?: string;
+        [key: string]: any;
+    };
+    callback_query?: {
+        id: string;
+        data: string;
+        from: any;
+        message: any;
+    };
+    [key: string]: any;
+}
+```
+
+### `CallbackQueryData`
+
+Данные callback query.
+
+```typescript
+interface CallbackQueryData {
+    id: string;
+    data: string;
+    from: any;
+    message: any;
+}
+```
+
+### `ReplyMarkup`
+
+Клавиатура или inline-кнопки.
+
+```typescript
+interface ReplyMarkup {
+    inline_keyboard?: any[][];
+    keyboard?: any[][];
+    [key: string]: any;
+}
+```
+
+### `TelegramBot`
+
+Интерфейс объекта бота со всеми методами.
+
+---
+
+## Полный пример
+
+```typescript
+import { tb } from "@elcrm/tb";
+
+// Использование напрямую (токен берется из process.env.TELEGRAM)
+
+// Обработчик сообщений
+tb.onMessage(async (update) => {
+    if (!update.message?.text || !update.message.from) return;
+
+    const chatId = update.message.from.id;
+    const text = update.message.text;
+
+    if (text === "/start") {
+        await tb.sendMessage(chatId, "Добро пожаловать!", {
+            inline_keyboard: [
+                [{ text: "Начать", callback_data: "start_action" }],
+            ],
+        });
+    } else if (text === "/help") {
+        await tb.sendMessage(chatId, "Это справочное сообщение");
+    } else {
+        await tb.sendMessage(chatId, `Вы написали: ${text}`);
+    }
+});
+
+// Обработчик callback query
+tb.onCallbackQuery("start_action", async (data) => {
+    const chatId = data.from.id;
+    await tb.sendMessage(chatId, "Действие выполнено!");
+    await tb.answerCallbackQuery(data.id, "Готово!");
+});
+
+// Создание webhook роутера
+const routes = tb.webhook("telegram-webhook");
+
+// Запуск сервера (Bun)
+Bun.serve({
+    port: 3000,
+    fetch(req) {
+        const url = new URL(req.url);
+        const handler = routes[url.pathname];
+        if (handler) {
+            return handler(req);
+        }
+        return new Response("Not found", { status: 404 });
+    },
+});
+```
+
+---
+
+## Экспорты
+
+Библиотека экспортирует следующие элементы:
+
+-   `tb` - Основной объект для работы с Telegram Bot API (синглтон)
+-   `createTelegramBot(token: string)` - Функция для создания дополнительных экземпляров бота
+-   `TelegramBot` - Интерфейс объекта бота
+-   `TelegramUpdate` - Интерфейс для обновлений от Telegram
+-   `CallbackQueryData` - Интерфейс для данных callback query
+-   `ReplyMarkup` - Интерфейс для клавиатур и кнопок
+-   `TelegramWebAppData` - Интерфейс для данных Telegram WebApp
+
+**Пример импорта типов:**
+
+```typescript
+import {
+    tb,
+    createTelegramBot,
+    type TelegramUpdate,
+    type CallbackQueryData,
+} from "@elcrm/tb";
+```
+
+---
+
+## Требования
+
+-   Bun runtime (для работы с `Bun.CryptoHasher` в методе `validatingData`)
+-   Node.js/Bun для выполнения
+
+## Переменные окружения
+
+Библиотека использует переменную окружения `TELEGRAM` для получения токена бота:
+
+```bash
+export TELEGRAM="123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
+```
+
+Или создайте файл `.env`:
+
+```
+TELEGRAM=123456789:ABCdefGHIjklMNOpqrsTUVwxyz
+```
+
+**Важно:** Если переменная `TELEGRAM` не установлена, при первом использовании `tb` будет выброшена ошибка. В этом случае используйте функцию `createTelegramBot(token)` для создания экземпляра с явным токеном.
+
+---
+
+## Ограничение скорости запросов
+
+Библиотека автоматически ограничивает скорость запросов к Telegram API до **30 запросов в секунду** (лимит Telegram Bot API). Все запросы автоматически ставятся в очередь и обрабатываются последовательно с необходимой задержкой.
+
+### Как это работает:
+
+-   Все запросы к API (кроме `setWebhook`) попадают в очередь перед выполнением
+-   Запросы обрабатываются последовательно с минимальной задержкой ~33.33 мс между ними
+-   Если запрос выполняется дольше задержки, дополнительная задержка не добавляется
+-   Ограничение применяется автоматически ко всем методам: `sendMessage`, `sendPhoto`, `editMessageText`, `answerCallbackQuery`
+
+**Пример:**
+
+```typescript
+// Все эти запросы автоматически будут обработаны с правильной скоростью
+for (let i = 0; i < 100; i++) {
+    await tb.sendMessage(chatId, `Сообщение ${i}`);
+    // Запросы будут обработаны последовательно, не превышая лимит 30 запросов/сек
+}
+```
+
+---
+
+## Лицензия
+
+MIT
+
+## Автор
+
+MaSkal <dev@elcrm.online>

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+export interface TelegramWebAppData {
+    hash: string;
+    user: Record<string, any>;
+    [key: string]: any;
+}
+export interface TelegramUpdate {
+    message?: {
+        from?: {
+            id: number;
+            [key: string]: any;
+        };
+        contact?: {
+            phone_number: string;
+            user_id: number;
+            [key: string]: any;
+        };
+        text?: string;
+        [key: string]: any;
+    };
+    callback_query?: {
+        id: string;
+        data: string;
+        from: any;
+        message: any;
+    };
+    [key: string]: any;
+}
+export interface CallbackQueryData {
+    id: string;
+    data: string;
+    from: any;
+    message: any;
+}
+export interface ReplyMarkup {
+    inline_keyboard?: any[][];
+    keyboard?: any[][];
+    [key: string]: any;
+}
+export interface TelegramBot {
+    validatingData: (body: string | URLSearchParams) => boolean;
+    setWebhook: (url: string) => Promise<any>;
+    handleUpdate: (update: TelegramUpdate) => Promise<void>;
+    webhook: (
+        router: string
+    ) => Record<string, (req: Request) => Promise<Response>>;
+    onCallbackQuery: (
+        name: string,
+        callback: (data: CallbackQueryData) => void | Promise<void>
+    ) => void;
+    onMessage: (
+        callback: (update: TelegramUpdate) => void | Promise<void>
+    ) => void;
+    answerCallbackQuery: (callbackId: string, text?: string) => Promise<any>;
+    editMessageText: (
+        chatId: number,
+        messageId: number,
+        text: string,
+        replyMarkup?: ReplyMarkup
+    ) => Promise<any>;
+    sendMessage: (
+        chat_id: number,
+        text: string,
+        reply_markup?: ReplyMarkup
+    ) => Promise<any>;
+    sendPhoto: (
+        chat_id: number,
+        photo: string,
+        caption?: string,
+        reply_markup?: ReplyMarkup
+    ) => Promise<any>;
+}
+declare function createTelegramBot(token: string): TelegramBot;
+export declare const tb: TelegramBot;
+export { createTelegramBot };

package/dist/index.es.js

@@ -0,0 +1,180 @@
+function e(e) {
+    if (!e) throw new Error("Telegram bot token is required");
+    const a = e,
+        t = { callback_query: {} },
+        s = [];
+    let n = !1;
+    const r = 1e3 / 30,
+        o = async (e, t) =>
+            new Promise((o, c) => {
+                s.push({ method: e, body: t, resolve: o, reject: c }),
+                    (async () => {
+                        if (!n && 0 !== s.length) {
+                            for (n = !0; s.length > 0; ) {
+                                const t = s.shift();
+                                if (!t) break;
+                                try {
+                                    const e = Date.now(),
+                                        s = await fetch(
+                                            `https://api.telegram.org/bot${a}/${t.method}`,
+                                            {
+                                                method: "POST",
+                                                headers: {
+                                                    "Content-Type":
+                                                        "application/json",
+                                                },
+                                                body: JSON.stringify(t.body),
+                                            }
+                                        ),
+                                        n = await s.json();
+                                    t.resolve(n);
+                                    const o = Date.now() - e,
+                                        c = Math.max(0, r - o);
+                                    c > 0 &&
+                                        (await new Promise((e) =>
+                                            setTimeout(e, c)
+                                        ));
+                                } catch (e) {
+                                    console.error(
+                                        `Error calling Telegram API (${t.method}):`,
+                                        e
+                                    ),
+                                        t.reject(e);
+                                }
+                            }
+                            n = !1;
+                        }
+                    })();
+            }),
+        c = {
+            setWebhook: async (e) => {
+                const t = e.replace("http://", "https://"),
+                    s = await fetch(
+                        `https://api.telegram.org/bot${a}/setWebhook?url=${t}`
+                    );
+                return await s.json();
+            },
+            webhook: (e) => ({
+                [`/${e}`]: async (e) => {
+                    try {
+                        const a = e.method,
+                            t = new URL(e.url);
+                        if ("GET" === a) {
+                            const e = await c.setWebhook(t.href);
+                            return new Response(JSON.stringify(e), {
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                        if ("POST" === a) {
+                            const a = await e.json();
+                            return await c.handleUpdate(a), new Response("OK");
+                        }
+                        return new Response("Method not allowed", {
+                            status: 405,
+                        });
+                    } catch (a) {
+                        return (
+                            console.error("Error handling webhook:", a),
+                            new Response("Internal Server Error", {
+                                status: 500,
+                            })
+                        );
+                    }
+                },
+            }),
+            handleUpdate: async (e) => {
+                if (
+                    (e.message && t.message && (await t.message(e)),
+                    e.callback_query)
+                ) {
+                    const {
+                        id: a,
+                        data: s,
+                        from: n,
+                        message: r,
+                    } = e.callback_query;
+                    await c.answerCallbackQuery(a),
+                        t.callback_query[s] &&
+                            (await t.callback_query[s]({
+                                id: a,
+                                data: s,
+                                from: n,
+                                message: r,
+                            }));
+                }
+            },
+            sendMessage: async (e, a, t) => {
+                const s = { chat_id: e, text: a, parse_mode: "HTML" };
+                return t && (s.reply_markup = t), o("sendMessage", s);
+            },
+            sendPhoto: async (e, a, t, s) => {
+                const n = { chat_id: e, photo: a };
+                return (
+                    t && (n.caption = t),
+                    s && (n.reply_markup = s),
+                    o("sendPhoto", n)
+                );
+            },
+            answerCallbackQuery: async (e, a) => {
+                const t = { callback_query_id: e };
+                return (
+                    a && ((t.text = a), (t.show_alert = !0)),
+                    o("answerCallbackQuery", t)
+                );
+            },
+            validatingData: (e) => {
+                const t = "string" == typeof e ? new URLSearchParams(e) : e,
+                    s = new URLSearchParams(t);
+                s.sort();
+                const n = s.get("hash");
+                s.delete("hash");
+                const r = [...s.entries()]
+                        .map(([e, a]) => `${e}=${a}`)
+                        .join("\n"),
+                    o = new Bun.CryptoHasher("sha256", "WebAppData")
+                        .update(a)
+                        .digest();
+                return (
+                    new Bun.CryptoHasher("sha256", o)
+                        .update(r)
+                        .digest("hex") === n
+                );
+            },
+            editMessageText: async (e, a, t, s) => {
+                const n = { chat_id: e, message_id: a, text: t };
+                return s && (n.reply_markup = s), o("editMessageText", n);
+            },
+            onCallbackQuery: (e, a) => {
+                t.callback_query[e] = a;
+            },
+            onMessage: (e) => {
+                t.message = e;
+            },
+        };
+    return c;
+}
+let a = null;
+function t() {
+    if (!a) {
+        const t = process.env.TELEGRAM;
+        if (!t)
+            throw new Error(
+                "TELEGRAM environment variable is required. Set TELEGRAM environment variable or use createTelegramBot(token) function"
+            );
+        a = e(t);
+    }
+    return a;
+}
+const s = {
+    validatingData: (...e) => t().validatingData(...e),
+    setWebhook: (...e) => t().setWebhook(...e),
+    handleUpdate: (...e) => t().handleUpdate(...e),
+    webhook: (...e) => t().webhook(...e),
+    onCallbackQuery: (...e) => t().onCallbackQuery(...e),
+    onMessage: (...e) => t().onMessage(...e),
+    answerCallbackQuery: (...e) => t().answerCallbackQuery(...e),
+    editMessageText: (...e) => t().editMessageText(...e),
+    sendMessage: (...e) => t().sendMessage(...e),
+    sendPhoto: (...e) => t().sendPhoto(...e),
+};
+export { e as createTelegramBot, s as tb };

package/dist/index.umd.js

@@ -0,0 +1,203 @@
+!(function (e, t) {
+    "object" == typeof exports && "undefined" != typeof module
+        ? t(exports)
+        : "function" == typeof define && define.amd
+        ? define(["exports"], t)
+        : t(
+              (((e =
+                  "undefined" != typeof globalThis
+                      ? globalThis
+                      : e || self).elcrm = e.elcrm || {}),
+              (e.elcrm.tb = {}))
+          );
+})(this, function (e) {
+    "use strict";
+    function t(e) {
+        if (!e) throw new Error("Telegram bot token is required");
+        const t = e,
+            a = { callback_query: {} },
+            n = [];
+        let s = !1;
+        const o = 1e3 / 30,
+            r = async (e, a) =>
+                new Promise((r, c) => {
+                    n.push({ method: e, body: a, resolve: r, reject: c }),
+                        (async () => {
+                            if (!s && 0 !== n.length) {
+                                for (s = !0; n.length > 0; ) {
+                                    const a = n.shift();
+                                    if (!a) break;
+                                    try {
+                                        const e = Date.now(),
+                                            n = await fetch(
+                                                `https://api.telegram.org/bot${t}/${a.method}`,
+                                                {
+                                                    method: "POST",
+                                                    headers: {
+                                                        "Content-Type":
+                                                            "application/json",
+                                                    },
+                                                    body: JSON.stringify(
+                                                        a.body
+                                                    ),
+                                                }
+                                            ),
+                                            s = await n.json();
+                                        a.resolve(s);
+                                        const r = Date.now() - e,
+                                            c = Math.max(0, o - r);
+                                        c > 0 &&
+                                            (await new Promise((e) =>
+                                                setTimeout(e, c)
+                                            ));
+                                    } catch (e) {
+                                        console.error(
+                                            `Error calling Telegram API (${a.method}):`,
+                                            e
+                                        ),
+                                            a.reject(e);
+                                    }
+                                }
+                                s = !1;
+                            }
+                        })();
+                }),
+            c = {
+                setWebhook: async (e) => {
+                    const a = e.replace("http://", "https://"),
+                        n = await fetch(
+                            `https://api.telegram.org/bot${t}/setWebhook?url=${a}`
+                        );
+                    return await n.json();
+                },
+                webhook: (e) => ({
+                    [`/${e}`]: async (e) => {
+                        try {
+                            const t = e.method,
+                                a = new URL(e.url);
+                            if ("GET" === t) {
+                                const e = await c.setWebhook(a.href);
+                                return new Response(JSON.stringify(e), {
+                                    headers: {
+                                        "Content-Type": "application/json",
+                                    },
+                                });
+                            }
+                            if ("POST" === t) {
+                                const t = await e.json();
+                                return (
+                                    await c.handleUpdate(t), new Response("OK")
+                                );
+                            }
+                            return new Response("Method not allowed", {
+                                status: 405,
+                            });
+                        } catch (t) {
+                            return (
+                                console.error("Error handling webhook:", t),
+                                new Response("Internal Server Error", {
+                                    status: 500,
+                                })
+                            );
+                        }
+                    },
+                }),
+                handleUpdate: async (e) => {
+                    if (
+                        (e.message && a.message && (await a.message(e)),
+                        e.callback_query)
+                    ) {
+                        const {
+                            id: t,
+                            data: n,
+                            from: s,
+                            message: o,
+                        } = e.callback_query;
+                        await c.answerCallbackQuery(t),
+                            a.callback_query[n] &&
+                                (await a.callback_query[n]({
+                                    id: t,
+                                    data: n,
+                                    from: s,
+                                    message: o,
+                                }));
+                    }
+                },
+                sendMessage: async (e, t, a) => {
+                    const n = { chat_id: e, text: t, parse_mode: "HTML" };
+                    return a && (n.reply_markup = a), r("sendMessage", n);
+                },
+                sendPhoto: async (e, t, a, n) => {
+                    const s = { chat_id: e, photo: t };
+                    return (
+                        a && (s.caption = a),
+                        n && (s.reply_markup = n),
+                        r("sendPhoto", s)
+                    );
+                },
+                answerCallbackQuery: async (e, t) => {
+                    const a = { callback_query_id: e };
+                    return (
+                        t && ((a.text = t), (a.show_alert = !0)),
+                        r("answerCallbackQuery", a)
+                    );
+                },
+                validatingData: (e) => {
+                    const a = "string" == typeof e ? new URLSearchParams(e) : e,
+                        n = new URLSearchParams(a);
+                    n.sort();
+                    const s = n.get("hash");
+                    n.delete("hash");
+                    const o = [...n.entries()]
+                            .map(([e, t]) => `${e}=${t}`)
+                            .join("\n"),
+                        r = new Bun.CryptoHasher("sha256", "WebAppData")
+                            .update(t)
+                            .digest();
+                    return (
+                        new Bun.CryptoHasher("sha256", r)
+                            .update(o)
+                            .digest("hex") === s
+                    );
+                },
+                editMessageText: async (e, t, a, n) => {
+                    const s = { chat_id: e, message_id: t, text: a };
+                    return n && (s.reply_markup = n), r("editMessageText", s);
+                },
+                onCallbackQuery: (e, t) => {
+                    a.callback_query[e] = t;
+                },
+                onMessage: (e) => {
+                    a.message = e;
+                },
+            };
+        return c;
+    }
+    let a = null;
+    function n() {
+        if (!a) {
+            const e = process.env.TELEGRAM;
+            if (!e)
+                throw new Error(
+                    "TELEGRAM environment variable is required. Set TELEGRAM environment variable or use createTelegramBot(token) function"
+                );
+            a = t(e);
+        }
+        return a;
+    }
+    const s = {
+        validatingData: (...e) => n().validatingData(...e),
+        setWebhook: (...e) => n().setWebhook(...e),
+        handleUpdate: (...e) => n().handleUpdate(...e),
+        webhook: (...e) => n().webhook(...e),
+        onCallbackQuery: (...e) => n().onCallbackQuery(...e),
+        onMessage: (...e) => n().onMessage(...e),
+        answerCallbackQuery: (...e) => n().answerCallbackQuery(...e),
+        editMessageText: (...e) => n().editMessageText(...e),
+        sendMessage: (...e) => n().sendMessage(...e),
+        sendPhoto: (...e) => n().sendPhoto(...e),
+    };
+    (e.createTelegramBot = t),
+        (e.tb = s),
+        Object.defineProperty(e, Symbol.toStringTag, { value: "Module" });
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "@elcrm/tb",
+    "version": "0.0.1",
+    "description": "plugin for elCRM",
+    "type": "module",
+    "author": "MaSkal <dev@elcrm.online>",
+    "license": "MIT",
+    "files": [
+        "dist"
+    ],
+    "keywords": [
+        "elcrm",
+        "tb",
+        "bun"
+    ],
+    "main": "./dist/index.umd.js",
+    "module": "./dist/index.es.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.es.js",
+            "require": "./dist/index.umd.js"
+        }
+    }
+}