@xbibzlibrary/telebibz 0.4.4 → 3.0.1

package/dist-cjs/src/storage/storage.js

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoStorage = exports.SqlStorage = exports.RedisStorage = exports.JsonFileStorage = exports.MemoryStorage = void 0;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-function expiration(ttlMs) {
-    if (ttlMs === undefined)
-        return undefined;
-    if (!Number.isFinite(ttlMs) || ttlMs < 0)
-        throw new RangeError("ttlMs must be a finite non-negative number");
-    return Date.now() + ttlMs;
-}
-class MemoryStorage {
-    valuesMap = new Map();
-    locks = new Map();
-    async get(key) {
-        const entry = this.valuesMap.get(key);
-        if (!entry)
-            return undefined;
-        if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {
-            this.valuesMap.delete(key);
-            return undefined;
-        }
-        return entry.value;
-    }
-    /**
-     * Reads the raw entry including expiry metadata. Intended for storage adapters
-     * (such as `JsonFileStorage`) that need to persist TTL information across restarts.
-     */
-    async readEntry(key) {
-        const entry = this.valuesMap.get(key);
-        if (!entry)
-            return undefined;
-        if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {
-            this.valuesMap.delete(key);
-            return undefined;
-        }
-        return entry.expiresAt === undefined ? { value: entry.value } : { value: entry.value, expiresAt: entry.expiresAt };
-    }
-    async set(key, value, options = {}) {
-        const expiresAt = expiration(options.ttlMs);
-        this.valuesMap.set(key, expiresAt === undefined ? { value } : { value, expiresAt });
-    }
-    async delete(key) { return this.valuesMap.delete(key); }
-    async has(key) { return (await this.get(key)) !== undefined; }
-    async clear() { this.valuesMap.clear(); }
-    async *keys() { for (const key of this.valuesMap.keys())
-        if (await this.has(key))
-            yield key; }
-    async *values() { for await (const [, value] of this.entries())
-        yield value; }
-    async *entries() { for (const key of this.valuesMap.keys()) {
-        const value = await this.get(key);
-        if (value !== undefined)
-            yield [key, value];
-    } }
-    async update(key, updater, options = {}) {
-        const previous = this.locks.get(key) ?? Promise.resolve();
-        let release;
-        const currentLock = new Promise((resolve) => { release = resolve; });
-        this.locks.set(key, currentLock);
-        await previous;
-        try {
-            const value = await updater(await this.get(key));
-            await this.set(key, value, options);
-            return value;
-        }
-        finally {
-            release();
-            if (this.locks.get(key) === currentLock)
-                this.locks.delete(key);
-        }
-    }
-}
-exports.MemoryStorage = MemoryStorage;
-class JsonFileStorage {
-    filePath;
-    memory = new MemoryStorage();
-    ready;
-    writeChain = Promise.resolve();
-    constructor(filePath) {
-        this.filePath = filePath;
-        this.ready = this.load();
-    }
-    async load() {
-        try {
-            const raw = await (0, promises_1.readFile)(this.filePath, "utf8");
-            const values = JSON.parse(raw);
-            for (const [key, entry] of Object.entries(values))
-                await this.memory.set(key, entry.value, entry.expiresAt === undefined ? {} : { ttlMs: Math.max(0, entry.expiresAt - Date.now()) });
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    async persist() {
-        await this.ready;
-        this.writeChain = this.writeChain.then(async () => {
-            const output = {};
-            for await (const key of this.memory.keys()) {
-                const entry = await this.memory.readEntry(key);
-                if (entry === undefined)
-                    continue;
-                output[key] = entry.expiresAt === undefined ? { value: entry.value } : { value: entry.value, expiresAt: entry.expiresAt };
-            }
-            await (0, promises_1.mkdir)((0, node_path_1.dirname)(this.filePath), { recursive: true });
-            const temporary = `${this.filePath}.${process.pid}.tmp`;
-            await (0, promises_1.writeFile)(temporary, JSON.stringify(output, null, 2), "utf8");
-            await (0, promises_1.rename)(temporary, this.filePath);
-        });
-        await this.writeChain;
-    }
-    async get(key) { await this.ready; return this.memory.get(key); }
-    async set(key, value, options) { await this.ready; await this.memory.set(key, value, options); await this.persist(); }
-    async delete(key) { await this.ready; const deleted = await this.memory.delete(key); if (deleted)
-        await this.persist(); return deleted; }
-    async has(key) { await this.ready; return this.memory.has(key); }
-    async clear() { await this.ready; await this.memory.clear(); await this.persist(); }
-    async *keys() { await this.ready; yield* this.memory.keys(); }
-    async *values() { await this.ready; yield* this.memory.values(); }
-    async *entries() { await this.ready; yield* this.memory.entries(); }
-    async update(key, updater, options) { await this.ready; const result = await this.memory.update(key, updater, options); await this.persist(); return result; }
-}
-exports.JsonFileStorage = JsonFileStorage;
-class RedisStorage {
-    client;
-    prefix;
-    constructor(client, prefix = "telebibz:") {
-        this.client = client;
-        this.prefix = prefix;
-    }
-    key(key) { return `${this.prefix}${key}`; }
-    unkey(key) { return key.slice(this.prefix.length); }
-    async get(key) { const value = await this.client.get(this.key(key)); return value === null ? undefined : JSON.parse(value); }
-    async set(key, value, options = {}) { const ttl = options.ttlMs; const redisOptions = ttl === undefined ? {} : { PX: Math.max(1, Math.floor(ttl)) }; await this.client.set(this.key(key), JSON.stringify(value), redisOptions); }
-    async delete(key) { return (await this.client.del(this.key(key))) > 0; }
-    async has(key) { return (await this.client.exists(this.key(key))) > 0; }
-    async clear() { const keys = await this.client.keys(`${this.prefix}*`); if (keys.length)
-        await Promise.all(keys.map((key) => this.client.del(key))); }
-    async *keys() { for (const key of await this.client.keys(`${this.prefix}*`))
-        yield this.unkey(key); }
-    async *values() { for await (const [, value] of this.entries())
-        yield value; }
-    async *entries() { for await (const key of this.keys()) {
-        const value = await this.get(key);
-        if (value !== undefined)
-            yield [key, value];
-    } }
-    async update(key, updater, options) { const value = await updater(await this.get(key)); await this.set(key, value, options); return value; }
-}
-exports.RedisStorage = RedisStorage;
-class SqlStorage {
-    driver;
-    constructor(driver) {
-        this.driver = driver;
-    }
-    async get(key) { return this.driver.get(key); }
-    async set(key, value, options = {}) { await this.driver.set(key, value, expiration(options.ttlMs)); }
-    async delete(key) { return this.driver.delete(key); }
-    async has(key) { return this.driver.has(key); }
-    async clear() { return this.driver.clear(); }
-    async *keys() { for (const [key] of await this.driver.entries())
-        yield key; }
-    async *values() { for (const [, value] of await this.driver.entries())
-        yield value; }
-    async *entries() { for (const [key, value, expiresAt] of await this.driver.entries()) {
-        if (expiresAt !== undefined && expiresAt <= Date.now()) {
-            await this.driver.delete(key);
-            continue;
-        }
-        yield [key, value];
-    } }
-    async update(key, updater, options) { const value = await updater(await this.get(key)); await this.set(key, value, options); return value; }
-}
-exports.SqlStorage = SqlStorage;
-class MongoStorage {
-    collection;
-    constructor(collection) {
-        this.collection = collection;
-    }
-    async get(key) { const document = await this.collection.findOne({ key }); if (!document || (document.expiresAt !== undefined && document.expiresAt <= Date.now()))
-        return undefined; return document.value; }
-    async set(key, value, options = {}) {
-        const expiresAt = expiration(options.ttlMs);
-        const document = expiresAt === undefined ? { key, value } : { key, value, expiresAt };
-        await this.collection.replaceOne({ key }, document, { upsert: true });
-    }
-    async delete(key) { return (await this.collection.deleteOne({ key })).deletedCount === 1; }
-    async has(key) { return (await this.get(key)) !== undefined; }
-    async clear() { await this.collection.deleteMany({}); }
-    async *keys() { for (const document of await this.collection.find({}).toArray())
-        if (document.expiresAt === undefined || document.expiresAt > Date.now())
-            yield document.key; }
-    async *values() { for await (const [, value] of this.entries())
-        yield value; }
-    async *entries() { for (const document of await this.collection.find({}).toArray())
-        if (document.expiresAt === undefined || document.expiresAt > Date.now())
-            yield [document.key, document.value]; }
-    async update(key, updater, options) { const value = await updater(await this.get(key)); await this.set(key, value, options); return value; }
-}
-exports.MongoStorage = MongoStorage;

package/dist-cjs/src/telegram-features.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentsClient = void 0;
-exports.parseWebAppInitData = parseWebAppInitData;
-exports.validateWebAppInitData = validateWebAppInitData;
-const node_crypto_1 = require("node:crypto");
-function parseWebAppInitData(initData) {
-    const params = new URLSearchParams(initData);
-    const hash = params.get("hash");
-    if (!hash)
-        throw new Error("Web App init data is missing hash");
-    const data = {};
-    for (const [key, value] of params.entries())
-        if (key !== "hash")
-            data[key] = value;
-    const authDateRaw = data.auth_date;
-    const authDate = authDateRaw === undefined ? undefined : Number(authDateRaw);
-    if (authDate !== undefined && (!Number.isInteger(authDate) || authDate <= 0))
-        throw new Error("Web App init data has an invalid auth_date");
-    const parseObject = (key) => {
-        const value = data[key];
-        if (value === undefined)
-            return undefined;
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            throw new Error(`Web App init data field ${key} is not valid JSON`);
-        }
-    };
-    const result = { raw: initData, hash, data };
-    if (authDate !== undefined)
-        result.authDate = authDate;
-    const user = parseObject("user");
-    const receiver = parseObject("receiver");
-    const chat = parseObject("chat");
-    if (user !== undefined)
-        result.user = user;
-    if (receiver !== undefined)
-        result.receiver = receiver;
-    if (chat !== undefined)
-        result.chat = chat;
-    return result;
-}
-function validateWebAppInitData(initData, botToken, maxAgeSeconds = 86_400, nowMs = Date.now()) {
-    if (!botToken)
-        throw new Error("botToken is required");
-    if (!Number.isFinite(maxAgeSeconds) || maxAgeSeconds < 0)
-        throw new RangeError("maxAgeSeconds must be non-negative");
-    const parsed = parseWebAppInitData(initData);
-    if (!/^[0-9a-fA-F]{64}$/.test(parsed.hash))
-        throw new Error("Web App init data hash must be a 64-character hexadecimal string");
-    const checkString = Object.entries(parsed.data).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join("\n");
-    const secret = (0, node_crypto_1.createHmac)("sha256", "WebAppData").update(botToken).digest();
-    const expected = (0, node_crypto_1.createHmac)("sha256", secret).update(checkString).digest("hex");
-    const actual = Buffer.from(parsed.hash, "hex");
-    const expectedBuffer = Buffer.from(expected, "hex");
-    if (actual.length !== expectedBuffer.length || !(0, node_crypto_1.timingSafeEqual)(actual, expectedBuffer))
-        throw new Error("Web App init data signature is invalid");
-    if (parsed.authDate !== undefined && nowMs / 1000 - parsed.authDate > maxAgeSeconds)
-        throw new Error("Web App init data has expired");
-    return parsed;
-}
-class PaymentsClient {
-    api;
-    constructor(api) {
-        this.api = api;
-    }
-    createInvoiceLink(payload) { return this.api.call("createInvoiceLink", payload); }
-    sendInvoice(payload) { return this.api.call("sendInvoice", payload); }
-    answerPreCheckoutQuery(payload) { return this.api.call("answerPreCheckoutQuery", payload); }
-    answerWebAppQuery(payload) { return this.api.call("answerWebAppQuery", payload); }
-    getStarTransactions(payload = {}) { return this.api.call("getStarTransactions", payload); }
-    refundStarPayment(payload) { return this.api.call("refundStarPayment", payload); }
-}
-exports.PaymentsClient = PaymentsClient;

package/dist-cjs/src/testing.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockTransport = void 0;
-exports.createMockUpdate = createMockUpdate;
-exports.createMockCallbackUpdate = createMockCallbackUpdate;
-exports.createTestBot = createTestBot;
-exports.createMockContext = createMockContext;
-const bot_js_1 = require("./core/bot.js");
-const context_js_1 = require("./context/context.js");
-class MockTransport {
-    calls = [];
-    /** Downloads recorded through `download()` (the `file_path` values, in order). */
-    downloads = [];
-    /** Bytes returned by `download()`; defaults to the UTF-8 encoding of the file path. */
-    downloadBytes;
-    responses = new Map();
-    respond(method, response) { this.responses.set(method, response); return this; }
-    async request(request) { this.calls.push(request); const configured = this.responses.get(request.method); const data = typeof configured === "function" ? configured(request.payload) : configured ?? { ok: true, result: true }; return { status: data.ok ? 200 : (data.error_code ?? 500), headers: new Headers(), data: data }; }
-    fileUrl(filePath) { return `mock://files/${filePath}`; }
-    async download(filePath) { this.downloads.push(filePath); return this.downloadBytes ?? new TextEncoder().encode(filePath); }
-}
-exports.MockTransport = MockTransport;
-function createMockUpdate(overrides = {}) { return { update_id: 1, message: { message_id: 1, date: Date.now(), chat: { id: 1, type: "private" }, from: { id: 2, is_bot: false, first_name: "Test" }, text: "/start" }, ...overrides }; }
-function createMockCallbackUpdate(overrides = {}) {
-    const base = createMockUpdate();
-    delete base.message;
-    return {
-        ...base,
-        update_id: 2,
-        callback_query: {
-            id: "callback-1",
-            from: { id: 2, is_bot: false, first_name: "Test" },
-            message: { message_id: 10, date: Date.now(), chat: { id: 1, type: "private" }, text: "Choose" },
-            chat_instance: "chat-instance",
-            data: "action",
-        },
-        ...overrides,
-    };
-}
-function createTestBot() {
-    const transport = new MockTransport();
-    transport.respond("getMe", { ok: true, result: { id: 99, is_bot: true, first_name: "TestBot", username: "test_bot" } });
-    return { bot: new bot_js_1.Bot({ token: "123456:TEST_TOKEN", transport }), transport };
-}
-function createMockContext(bot, update = createMockUpdate()) { return new context_js_1.Context({ update, api: bot.api, session: {}, services: {} }); }

package/dist-cjs/src/utils/concurrency.js

@@ -1,57 +0,0 @@
-"use strict";
-/**
- * Minimal concurrency primitives with zero dependencies.
- *
- * These helpers never add proactive delays: they only cap how many async tasks
- * run at the same time. `Infinity` means fully parallel execution.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Limiter = void 0;
-exports.validateConcurrency = validateConcurrency;
-exports.mapWithConcurrency = mapWithConcurrency;
-function validateConcurrency(value, label = "concurrency") {
-    if (value === Infinity)
-        return;
-    if (!Number.isInteger(value) || value < 1)
-        throw new RangeError(`${label} must be a positive integer or Infinity`);
-}
-/** Promise semaphore: runs tasks immediately while a slot is free, queues the rest in FIFO order. */
-class Limiter {
-    limit;
-    active = 0;
-    waiters = [];
-    constructor(limit) {
-        this.limit = limit;
-        validateConcurrency(limit);
-    }
-    /** Number of tasks currently running. */
-    get activeCount() { return this.active; }
-    /** Number of tasks waiting for a free slot. */
-    get queuedCount() { return this.waiters.length; }
-    async run(task) {
-        if (this.active >= this.limit)
-            await new Promise((resolve) => { this.waiters.push(resolve); });
-        this.active += 1;
-        try {
-            return await task();
-        }
-        finally {
-            this.active -= 1;
-            this.waiters.shift()?.();
-        }
-    }
-}
-exports.Limiter = Limiter;
-/**
- * Maps items through an async worker with a concurrency cap.
- * Results keep the input order; `Infinity` runs everything in parallel.
- */
-async function mapWithConcurrency(items, limit, worker) {
-    validateConcurrency(limit);
-    const results = new Array(items.length);
-    const limiter = new Limiter(limit);
-    await Promise.all(items.map((item, index) => limiter.run(async () => {
-        results[index] = await worker(item, index);
-    })));
-    return results;
-}

package/dist-cjs/src/utils/files.js

@@ -1,58 +0,0 @@
-"use strict";
-/**
- * File-upload validation helpers. Telegram caps uploads at 50 MB for most
- * methods (10 MB for photos) and rejects mismatches between content and
- * declared type; these helpers let applications enforce their own limits
- * before a byte leaves the process.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UploadValidationError = void 0;
-exports.validateUpload = validateUpload;
-exports.assertValidUpload = assertValidUpload;
-/** Thrown by {@link assertValidUpload} when an upload violates the rules. */
-class UploadValidationError extends Error {
-    name = "UploadValidationError";
-    issues;
-    constructor(issues) {
-        super(`Upload rejected: ${issues.map((issue) => issue.message).join("; ")}`);
-        this.issues = issues;
-    }
-}
-exports.UploadValidationError = UploadValidationError;
-function normalizeExtension(extension) {
-    const value = extension.trim().toLowerCase();
-    return value.startsWith(".") ? value.slice(1) : value;
-}
-function mimeMatches(pattern, mimeType) {
-    const normalizedPattern = pattern.trim().toLowerCase();
-    if (normalizedPattern.endsWith("/*"))
-        return mimeType.toLowerCase().startsWith(normalizedPattern.slice(0, -1));
-    return mimeType.toLowerCase() === normalizedPattern;
-}
-/**
- * Validates an upload against the rules and returns every violation found
- * (an empty array means the upload is acceptable).
- */
-function validateUpload(upload, rules) {
-    const issues = [];
-    if (rules.maxBytes !== undefined && upload.sizeBytes !== undefined && upload.sizeBytes > rules.maxBytes) {
-        issues.push({ code: "too_large", field: "sizeBytes", message: `size ${upload.sizeBytes} bytes exceeds the ${rules.maxBytes} byte limit`, actual: upload.sizeBytes, limit: rules.maxBytes });
-    }
-    if (rules.allowedMimeTypes !== undefined && rules.allowedMimeTypes.length > 0 && upload.mimeType !== undefined && !rules.allowedMimeTypes.some((pattern) => mimeMatches(pattern, upload.mimeType))) {
-        issues.push({ code: "mime_not_allowed", field: "mimeType", message: `MIME type ${upload.mimeType} is not allowed (allowed: ${rules.allowedMimeTypes.join(", ")})`, actual: upload.mimeType, limit: rules.allowedMimeTypes.join(", ") });
-    }
-    if (rules.allowedExtensions !== undefined && rules.allowedExtensions.length > 0 && upload.fileName !== undefined) {
-        const extension = upload.fileName.includes(".") ? upload.fileName.slice(upload.fileName.lastIndexOf(".") + 1) : "";
-        const normalized = normalizeExtension(extension);
-        if (!normalized || !rules.allowedExtensions.some((allowed) => normalizeExtension(allowed) === normalized)) {
-            issues.push({ code: "extension_not_allowed", field: "fileName", message: `extension .${normalized || "?"} is not allowed (allowed: ${rules.allowedExtensions.join(", ")})`, actual: upload.fileName, limit: rules.allowedExtensions.join(", ") });
-        }
-    }
-    return issues;
-}
-/** Like {@link validateUpload} but throws {@link UploadValidationError} when any rule is violated. */
-function assertValidUpload(upload, rules) {
-    const issues = validateUpload(upload, rules);
-    if (issues.length > 0)
-        throw new UploadValidationError(issues);
-}

package/dist-cjs/src/utils/text.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.html = exports.md = void 0;
-exports.escapeMarkdownV2 = escapeMarkdownV2;
-exports.escapeHtml = escapeHtml;
-exports.splitMessage = splitMessage;
-exports.splitCaption = splitCaption;
-exports.template = template;
-const TELEGRAM_TEXT_LIMIT = 4096;
-const TELEGRAM_CAPTION_LIMIT = 1024;
-function escapeMarkdownV2(value) { return value.replace(/[\\_*\[\]()~`>#+\-=|{}.!]/g, "\\$&"); }
-function escapeHtml(value) { return value.replace(/[&<>\"]/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;" })[character] ?? character); }
-exports.md = {
-    bold: (value) => `*${escapeMarkdownV2(value)}*`,
-    italic: (value) => `_${escapeMarkdownV2(value)}_`,
-    underline: (value) => `__${escapeMarkdownV2(value)}__`,
-    strikethrough: (value) => `~${escapeMarkdownV2(value)}~`,
-    spoiler: (value) => `||${escapeMarkdownV2(value)}||`,
-    link: (label, url) => `[${escapeMarkdownV2(label)}](${url.replace(/[()\\]/g, "\\$&")})`,
-    code: (value) => `\`${value.replace(/[`\\]/g, "\\$&")}\``,
-    pre: (value, language = "") => `\`\`\`${language}\n${value.replace(/[`\\]/g, "\\$&")}\n\`\`\``,
-    blockquote: (value) => value.split("\n").map((line) => `>${escapeMarkdownV2(line)}`).join("\n"),
-    expandableBlockquote: (value) => `**>${value.split("\n").map((line) => escapeMarkdownV2(line)).join("\n>")}||`,
-    customEmoji: (emoji, customEmojiId) => `![${escapeMarkdownV2(emoji)}](tg://emoji?id=${customEmojiId})`,
-    userMention: (label, userId) => `[${escapeMarkdownV2(label)}](tg://user?id=${userId})`,
-    escape: escapeMarkdownV2,
-};
-exports.html = {
-    escape: escapeHtml,
-    bold: (value) => `<b>${escapeHtml(value)}</b>`,
-    italic: (value) => `<i>${escapeHtml(value)}</i>`,
-    underline: (value) => `<u>${escapeHtml(value)}</u>`,
-    strikethrough: (value) => `<s>${escapeHtml(value)}</s>`,
-    spoiler: (value) => `<tg-spoiler>${escapeHtml(value)}</tg-spoiler>`,
-    link: (label, url) => `<a href="${escapeHtml(url)}">${escapeHtml(label)}</a>`,
-    code: (value) => `<code>${escapeHtml(value)}</code>`,
-    pre: (value, language) => language ? `<pre><code class="language-${escapeHtml(language)}">${escapeHtml(value)}</code></pre>` : `<pre>${escapeHtml(value)}</pre>`,
-    blockquote: (value) => `<blockquote>${escapeHtml(value)}</blockquote>`,
-    expandableBlockquote: (value) => `<blockquote expandable>${escapeHtml(value)}</blockquote>`,
-    customEmoji: (emoji, customEmojiId) => `<tg-emoji emoji-id="${escapeHtml(customEmojiId)}">${escapeHtml(emoji)}</tg-emoji>`,
-    userMention: (label, userId) => `<a href="tg://user?id=${userId}">${escapeHtml(label)}</a>`,
-};
-function splitMessage(text, options = {}) {
-    const limit = options.limit ?? TELEGRAM_TEXT_LIMIT;
-    if (limit < 1)
-        throw new RangeError("limit must be positive");
-    if (text.length <= limit)
-        return [text];
-    const chunks = [];
-    let remaining = text;
-    while (remaining.length > limit) {
-        const window = remaining.slice(0, limit);
-        const boundary = Math.max(window.lastIndexOf("\n\n"), window.lastIndexOf("\n"), window.lastIndexOf(" "));
-        const cut = boundary > Math.floor(limit * 0.5) ? boundary : limit;
-        chunks.push(remaining.slice(0, cut));
-        remaining = remaining.slice(cut).replace(/^\s+/, "");
-    }
-    if (remaining)
-        chunks.push(remaining);
-    return chunks;
-}
-function splitCaption(text) { return splitMessage(text, { limit: TELEGRAM_CAPTION_LIMIT }); }
-function template(templateText, values) { return templateText.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_match, key) => { const value = key.split(".").reduce((current, part) => current && typeof current === "object" ? current[part] : undefined, values); return value === undefined || value === null ? "" : String(value); }); }

package/dist-cjs/src/webhook/handler.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWebhookHandler = createWebhookHandler;
-exports.webhookCallback = webhookCallback;
-const node_crypto_1 = require("node:crypto");
-/** Runs the update, optionally claiming the webhook response for the first API call. */
-async function processWithOptionalReply(bot, update, sink) {
-    if (sink === undefined) {
-        await bot.handleUpdate(update);
-        return;
-    }
-    await bot.handleUpdate(update, { webhookReply: sink });
-}
-function replyResponse(payload) {
-    if (payload !== undefined)
-        return new Response(JSON.stringify(payload), { status: 200, headers: { "content-type": "application/json" } });
-    return new Response("OK", { status: 200 });
-}
-function createWebhookHandler(bot, options = {}) {
-    const maxBodyBytes = options.maxBodyBytes ?? 1_048_576;
-    return async (request) => {
-        if (request.method !== "POST")
-            return new Response("Method Not Allowed", { status: 405, headers: { allow: "POST" } });
-        if (options.secretToken && !secureEqual(request.headers.get("x-telegram-bot-api-secret-token") ?? "", options.secretToken))
-            return new Response("Unauthorized", { status: 401 });
-        const contentType = request.headers.get("content-type") ?? "";
-        if (!/^application\/json(?:\s*;|\s*$)/i.test(contentType))
-            return new Response("Unsupported Media Type", { status: 415 });
-        const contentLength = Number(request.headers.get("content-length") ?? 0);
-        if (contentLength > maxBodyBytes)
-            return new Response("Payload Too Large", { status: 413 });
-        try {
-            const raw = await request.arrayBuffer();
-            if (raw.byteLength > maxBodyBytes)
-                return new Response("Payload Too Large", { status: 413 });
-            const update = JSON.parse(new TextDecoder().decode(raw));
-            if (!Number.isInteger(update.update_id))
-                return new Response("Bad Request", { status: 400 });
-            let replyPayload;
-            const sink = options.webhookReply === true ? (payload) => { replyPayload = payload; } : undefined;
-            await processWithOptionalReply(bot, update, sink);
-            return replyResponse(replyPayload);
-        }
-        catch (error) {
-            await options.onError?.(error);
-            return new Response("Internal Server Error", { status: 500 });
-        }
-    };
-}
-function webhookCallback(bot, _framework = "express", options = {}) {
-    const maxBodyBytes = options.maxBodyBytes ?? 1_048_576;
-    return async (req, res) => {
-        const rawReq = req;
-        const rawRes = res;
-        const sendResponse = (status, message, contentType = "text/plain") => {
-            if (rawRes && typeof rawRes.writeHead === "function" && typeof rawRes.end === "function") {
-                rawRes.writeHead(status, { "Content-Type": contentType });
-                rawRes.end(message);
-                return;
-            }
-            const expressLike = rawRes;
-            if (typeof expressLike?.status === "function" && typeof expressLike.send === "function") {
-                expressLike.status(status).send(message);
-                return;
-            }
-            const koaLike = rawRes;
-            if (koaLike !== undefined) {
-                koaLike.status = status;
-                koaLike.body = message;
-            }
-        };
-        if (rawReq.method !== "POST") {
-            sendResponse(405, "Method Not Allowed");
-            return;
-        }
-        if (options.secretToken) {
-            if (!secureEqual(readHeader(rawReq, "x-telegram-bot-api-secret-token"), options.secretToken)) {
-                sendResponse(401, "Unauthorized");
-                return;
-            }
-        }
-        try {
-            let update;
-            if (typeof rawReq.arrayBuffer === "function") {
-                // Web-standard Request objects (e.g. Deno, Bun, WinterCG runtimes, or
-                // a converted fetch Request) expose the body through arrayBuffer().
-                // Checked before `body` because a Request's `body` is a ReadableStream.
-                const raw = await rawReq.arrayBuffer();
-                if (raw.byteLength > maxBodyBytes) {
-                    sendResponse(413, "Payload Too Large");
-                    return;
-                }
-                update = JSON.parse(new TextDecoder().decode(raw));
-            }
-            else if (rawReq.body && typeof rawReq.body === "object") {
-                update = rawReq.body;
-            }
-            else {
-                const chunks = [];
-                let totalBytes = 0;
-                for await (const chunk of rawReq) {
-                    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-                    totalBytes += buffer.length;
-                    if (totalBytes > maxBodyBytes) {
-                        sendResponse(413, "Payload Too Large");
-                        return;
-                    }
-                    chunks.push(buffer);
-                }
-                const raw = Buffer.concat(chunks).toString("utf8");
-                update = JSON.parse(raw);
-            }
-            if (!Number.isInteger(update?.update_id)) {
-                sendResponse(400, "Bad Request");
-                return;
-            }
-            let replyPayload;
-            const sink = options.webhookReply === true ? (payload) => { replyPayload = payload; } : undefined;
-            await processWithOptionalReply(bot, update, sink);
-            if (replyPayload !== undefined)
-                sendResponse(200, JSON.stringify(replyPayload), "application/json");
-            else
-                sendResponse(200, "OK");
-        }
-        catch (error) {
-            await options.onError?.(error);
-            sendResponse(500, "Internal Server Error");
-        }
-    };
-}
-function readHeader(req, name) {
-    const headers = req.headers;
-    if (!headers || typeof headers !== "object")
-        return "";
-    if (typeof headers.get === "function")
-        return headers.get(name) ?? "";
-    const value = headers[name];
-    return Array.isArray(value) ? value[0] ?? "" : value ?? "";
-}
-function secureEqual(left, right) {
-    const leftBuffer = Buffer.from(left, "utf8");
-    const rightBuffer = Buffer.from(right, "utf8");
-    return leftBuffer.length === rightBuffer.length && (0, node_crypto_1.timingSafeEqual)(leftBuffer, rightBuffer);
-}