@xbibzlibrary/telebibz 0.4.4 → 3.0.1

package/dist-cjs/src/core/bot.js

@@ -1,510 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bot = exports.UpdateTimeoutError = void 0;
-const client_js_1 = require("../api/client.js");
-const transport_js_1 = require("../api/transport.js");
-const context_js_1 = require("../context/context.js");
-const compose_js_1 = require("../middleware/compose.js");
-const router_js_1 = require("../router/router.js");
-const events_js_1 = require("./events.js");
-const storage_js_1 = require("../storage/storage.js");
-const plugin_js_1 = require("../plugins/plugin.js");
-const logger_js_1 = require("../observability/logger.js");
-const terminal_js_1 = require("../branding/terminal.js");
-const conversation_js_1 = require("../state/conversation.js");
-const broadcast_js_1 = require("../broadcast/broadcast.js");
-const concurrency_js_1 = require("../utils/concurrency.js");
-const webhook_reply_js_1 = require("./webhook-reply.js");
-const node_async_hooks_1 = require("node:async_hooks");
-const promises_1 = require("node:fs/promises");
-/** Thrown when a single update exceeds `handlerTimeout`; the handler keeps running in the background. */
-class UpdateTimeoutError extends Error {
-    name = "UpdateTimeoutError";
-    updateId;
-    constructor(updateId, timeoutMs) {
-        super(`Update ${updateId} handler timed out after ${timeoutMs}ms`);
-        this.updateId = updateId;
-    }
-}
-exports.UpdateTimeoutError = UpdateTimeoutError;
-class Bot {
-    api;
-    router;
-    events = new events_js_1.EventBus();
-    plugins;
-    session;
-    services;
-    token;
-    logger;
-    middlewares = [];
-    pollingOptions;
-    statusValue = "created";
-    pollingAbort;
-    offset = 0;
-    me;
-    /** Caps how many updates run at once (default: unlimited). */
-    updateLimiter;
-    /** Per-update timeout in ms; `Infinity` disables. */
-    handlerTimeoutMs;
-    /** Context class instantiated per update (default `Context`). */
-    contextType;
-    /** Per-chat processing chains: parallel across chats, ordered within a chat. */
-    chatChains = new Map();
-    /**
-     * Identifies the update chain executing in the current async context so
-     * `stop()` called from inside a handler never deadlocks waiting on itself
-     * (Telegraf allows `bot.stop()` from within a handler).
-     */
-    currentUpdateChain = new node_async_hooks_1.AsyncLocalStorage();
-    /** Memoized init so a burst of updates triggers exactly one getMe call. */
-    initOnce;
-    brandingEnabled;
-    /** Branding effects run only on an interactive TTY; structured logs stay untouched otherwise. */
-    brandingActive;
-    activeBanner;
-    errorHandler;
-    constructor(options) {
-        const config = typeof options === "string" ? { token: options } : options;
-        if (!config.token || !/^\d+:[\w-]+$/.test(config.token))
-            throw new Error("A valid Telegram bot token is required.");
-        this.token = config.token;
-        this.brandingEnabled = config.branding ?? true;
-        this.brandingActive = this.brandingEnabled && process.stdout.isTTY === true;
-        this.logger = config.logger instanceof logger_js_1.Logger ? config.logger : (0, logger_js_1.createLogger)(config.logger);
-        this.router = new router_js_1.Router(config.router);
-        this.session = config.session ?? new storage_js_1.MemoryStorage();
-        this.services = { ...(config.services ?? {}) };
-        const transport = config.transport ?? new transport_js_1.FetchTransport({ baseUrl: `${config.apiBaseUrl ?? "https://api.telegram.org"}/bot${config.token}`, ...(config.transportOptions ?? {}) });
-        this.api = new client_js_1.ApiClient({
-            hooks: {
-                onRequest: (context) => { this.logger.trace("api.request", { method: context.method, payload: context.payload }); return this.events.emit("api:request", { method: context.method, payload: context.payload }); },
-                onResponse: (context) => { this.logger.debug("api.response", { method: context.method, durationMs: context.durationMs ?? 0, ok: context.response?.ok }); return this.events.emit("api:response", { method: context.method, durationMs: context.durationMs ?? 0, response: context.response }); },
-                onError: (context) => { this.logger.error("api.error", { method: context.method, durationMs: context.durationMs ?? 0, error: context.error }); return this.events.emit("api:error", { method: context.method, durationMs: context.durationMs ?? 0, error: context.error }); },
-            },
-            transport,
-        });
-        this.plugins = new plugin_js_1.PluginManager(this);
-        this.updateLimiter = new concurrency_js_1.Limiter(config.updates?.concurrency ?? Infinity);
-        this.handlerTimeoutMs = config.handlerTimeout ?? 90_000;
-        this.contextType = config.contextType ?? context_js_1.Context;
-        this.pollingOptions = {
-            allowedUpdates: config.polling?.allowedUpdates ?? [],
-            limit: config.polling?.limit ?? 100,
-            maxRetryDelayMs: config.polling?.maxRetryDelayMs ?? 30_000,
-            retryDelayMs: config.polling?.retryDelayMs ?? 500,
-            timeout: config.polling?.timeout ?? 30,
-        };
-        this.startupLog("bot.created", { status: this.statusValue });
-        void this.events.emit("bot:created", { bot: this });
-    }
-    /** Startup info logs are demoted to debug while the branding sequence owns the terminal. */
-    startupLog(event, context) {
-        if (this.brandingActive)
-            this.logger.debug(event, context);
-        else
-            this.logger.info(event, context);
-    }
-    get status() { return this.statusValue; }
-    get botInfo() { return this.me; }
-    use(...middleware) { this.middlewares.push(...middleware); return this; }
-    command(name, handler) { this.router.command(name, handler); return this; }
-    callback(pattern, handler) { this.router.callback(pattern, handler); return this; }
-    /** Telegraf-style alias for `callback()`: registers a handler for callback-query button data. */
-    action(pattern, handler) { this.router.callback(pattern, handler); return this; }
-    onText(text, handler) { this.router.text(text, handler); return this; }
-    onRegex(expression, handler) { this.router.regex(expression, handler); return this; }
-    /** Registers a handler for update types: `bot.on("message:photo", handler)` or `bot.on(["message:text", "callback_query:data"], handler)`. */
-    on(filter, handler) { this.router.on(filter, handler); return this; }
-    /** Registers a handler for exact text or a regular expression, mirroring familiar frameworks. */
-    hears(trigger, handler) {
-        if (trigger instanceof RegExp)
-            this.router.regex(trigger, handler);
-        else
-            this.router.text(trigger, handler);
-        return this;
-    }
-    /**
-     * Sets the error boundary for update handlers. When set, handler failures are
-     * passed here instead of rejecting `handleUpdate()` (webhooks answer 200).
-     */
-    catch(handler) { this.errorHandler = handler; return this; }
-    usePlugin(plugin) { this.plugins.use(plugin); return this; }
-    /**
-     * Routes subsequent messages to the active Wizard step for the same chat/user.
-     * The application starts the wizard once with `wizard.run(ctx, key)`; this
-     * middleware keeps routing replies until the wizard is completed or cancelled.
-     */
-    useWizard(wizard, options = {}) {
-        const cancelCommand = options.cancelCommand ?? "/cancel";
-        this.use(async (ctx, next) => {
-            const message = ctx.message;
-            const key = (0, conversation_js_1.conversationKeyFromContext)(ctx);
-            const state = await wizard.manager.getAsync(key);
-            if (!message?.text || state?.status !== "active") {
-                await next();
-                return;
-            }
-            if (message.text.trim() === cancelCommand) {
-                wizard.manager.cancel(key);
-                await ctx.reply("Conversation cancelled.");
-                return;
-            }
-            await wizard.run(ctx, key);
-        });
-        return this;
-    }
-    async init() {
-        if (this.statusValue === "initialized" || this.statusValue === "running")
-            return this;
-        this.startupLog("bot.initializing", {});
-        const standaloneBanner = this.brandingActive && !this.activeBanner;
-        const animation = this.brandingActive ? undefined : (0, terminal_js_1.startTerminalAnimation)("Connecting to Telegram and initializing bot");
-        if (standaloneBanner)
-            (0, terminal_js_1.printTeleBibzBanner)({ subtitle: "Connecting to Telegram..." });
-        try {
-            this.me = await this.api.methods.getMe();
-            this.statusValue = "initialized";
-            this.startupLog("bot.initialized", { botId: this.me.id, username: this.me.username });
-            await this.events.emit("bot:initialized", { bot: this });
-            await this.plugins.setup();
-            await this.plugins.start();
-            if (standaloneBanner)
-                (0, terminal_js_1.printStatusLine)(`✓ Bot initialized as @${this.me.username ?? this.me.id}`);
-            else
-                animation?.stop("Bot initialized; ready to start");
-            return this;
-        }
-        catch (error) {
-            if (standaloneBanner)
-                (0, terminal_js_1.printStatusLine)(`✗ Bot could not initialize: ${error instanceof Error ? error.message : String(error)}`);
-            else
-                animation?.stop("Error: bot could not initialize");
-            throw error;
-        }
-    }
-    async start(options = {}) { await this.launch({ mode: "polling", ...options }); }
-    async launch(options = { mode: "polling" }) {
-        if (options.mode !== "polling")
-            throw new Error("Use createWebhookHandler() for webhook mode.");
-        const runBrandingSequence = this.brandingActive && !this.activeBanner && (this.statusValue === "created" || this.statusValue === "stopped");
-        if (runBrandingSequence) {
-            await (0, terminal_js_1.runStartupSequence)();
-            this.activeBanner = (0, terminal_js_1.startTeleBibzBanner)({ subtitle: "Connecting to Telegram..." });
-        }
-        try {
-            await this.init();
-        }
-        catch (error) {
-            if (this.activeBanner) {
-                this.activeBanner.stop(`Connection failed: ${error instanceof Error ? error.message : String(error)}`, "error");
-                this.activeBanner = undefined;
-            }
-            throw error;
-        }
-        if (this.activeBanner) {
-            this.activeBanner.stop(`Connected as @${this.me?.username ?? this.me?.id}`);
-            this.activeBanner = undefined;
-        }
-        if (this.statusValue === "running")
-            return;
-        if (options.dropPendingUpdates) {
-            // Same mechanism Telegraf uses: drop everything Telegram is holding for
-            // this bot before the first getUpdates call.
-            await this.api.call("deleteWebhook", { drop_pending_updates: true });
-        }
-        this.statusValue = "starting";
-        this.startupLog("bot.starting", { mode: options.mode });
-        await this.events.emit("bot:starting", { bot: this });
-        this.pollingAbort = new AbortController();
-        this.statusValue = "running";
-        await this.events.emit("bot:started", { bot: this });
-        if (this.brandingActive)
-            (0, terminal_js_1.printStatusLine)("Listening for updates...");
-        await this.poll(options.timeout ?? this.pollingOptions.timeout, options.allowedUpdates ?? this.pollingOptions.allowedUpdates, this.pollingAbort.signal);
-    }
-    async stop() {
-        if (this.statusValue === "stopped" || this.statusValue === "created")
-            return;
-        this.statusValue = "stopping";
-        await this.events.emit("bot:stopping", { bot: this });
-        this.pollingAbort?.abort();
-        this.pollingAbort = undefined;
-        // Graceful shutdown: wait for updates still being processed (bounded by
-        // handlerTimeout) so sessions finish writing before plugins are disposed.
-        await this.drainInFlightUpdates();
-        await this.plugins.stop();
-        await this.plugins.dispose();
-        this.statusValue = "stopped";
-        if (this.brandingActive)
-            (0, terminal_js_1.printStatusLine)("Bot stopped.");
-        else
-            this.logger.info("bot.stopped");
-        await this.events.emit("bot:stopped", { bot: this });
-    }
-    /** Waits (bounded by `handlerTimeout`) for updates that are still processing. */
-    async drainInFlightUpdates() {
-        // A handler calling stop() must not wait on its own chain (deadlock); it
-        // keeps running in the background, exactly like Telegraf.
-        const current = this.currentUpdateChain.getStore();
-        const inFlight = [...this.chatChains.values()].filter((chain) => chain !== current);
-        if (inFlight.length === 0)
-            return;
-        this.logger.info("bot.draining_updates", { inFlight: inFlight.length });
-        await this.withTimeout(Promise.allSettled(inFlight), this.handlerTimeoutMs, -1);
-    }
-    async restart() { await this.stop(); await this.start(); }
-    async health() {
-        try {
-            const bot = await this.api.methods.getMe();
-            return { status: this.statusValue, apiReachable: true, bot, checkedAt: new Date().toISOString() };
-        }
-        catch (error) {
-            return { status: this.statusValue, apiReachable: false, checkedAt: new Date().toISOString(), error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    async getMe() { const me = await this.api.methods.getMe(); this.me = me; return me; }
-    async setCommands(commands, scope, languageCode) { return this.api.call("setMyCommands", { commands, scope, language_code: languageCode }); }
-    async deleteCommands(scope, languageCode) { return this.api.call("deleteMyCommands", { scope, language_code: languageCode }); }
-    /**
-     * Downloads a Telegram file by `file_id`: resolves it with `getFile`, then
-     * fetches the raw bytes via the transport's download endpoint. Pass
-     * `destination` to also persist the bytes to a local file path. The
-     * returned `url` is valid for at least one hour; Telegram caps downloads
-     * at 20 MB.
-     */
-    async downloadFile(fileId, options = {}) {
-        const downloaded = await this.api.downloadFile(fileId, options.signal !== undefined ? { signal: options.signal } : {});
-        if (options.destination !== undefined) {
-            await (0, promises_1.writeFile)(options.destination, downloaded.bytes);
-            return { ...downloaded, savedTo: options.destination };
-        }
-        return downloaded;
-    }
-    /**
-     * Handles a single update. Updates for different chats run in parallel;
-     * updates for the same chat are processed strictly in arrival order so
-     * sessions, wizards, and conversations never interleave. Rejects for this
-     * update's failure (as before) without affecting other updates.
-     *
-     * `options.webhookReply` installs a Telegraf-style responder: the first
-     * outgoing API call during this update is answered through the webhook HTTP
-     * response instead of a separate request, and resolves with `true` because
-     * Telegram never sends the method result back to a webhook response.
-     */
-    async handleUpdate(update, options = {}) {
-        const key = this.conversationKey(update);
-        const previous = this.chatChains.get(key);
-        const execute = options.webhookReply === undefined
-            ? () => this.processUpdate(update)
-            : () => (0, webhook_reply_js_1.runWithWebhookReply)(options.webhookReply, () => this.processUpdate(update));
-        // The chain waits for the real completion so same-chat ordering holds
-        // even when the caller-facing await below is released by a timeout. The
-        // chain is installed as the current AsyncLocalStorage value so a handler
-        // calling bot.stop() is excluded from the drain set.
-        const run = (previous ?? Promise.resolve()).catch(() => undefined).then(() => this.currentUpdateChain.run(tail, execute));
-        const tail = run.then(() => undefined, () => undefined);
-        this.chatChains.set(key, tail);
-        void tail.then(() => {
-            if (this.chatChains.get(key) === tail)
-                this.chatChains.delete(key);
-        });
-        try {
-            await this.withTimeout(run, this.handlerTimeoutMs, update.update_id);
-        }
-        catch (error) {
-            if (!(error instanceof UpdateTimeoutError))
-                throw error;
-            // A timed-out update follows the same error flow as a failed handler;
-            // the handler itself keeps running to completion in the background.
-            this.logger.error("update.handler_timeout", { updateId: update.update_id, timeoutMs: this.handlerTimeoutMs });
-            await this.events.emit("update:error", { update, error });
-            await this.events.emit("bot:error", { bot: this, error });
-            if (this.errorHandler) {
-                await this.errorHandler(error, new context_js_1.Context({ update, api: this.api, session: {}, services: this.services, me: this.me }));
-                return;
-            }
-            throw error;
-        }
-    }
-    /** Rejects with `UpdateTimeoutError` after `timeoutMs` unless `promise` settles first; `timeoutMs <= 0` or a non-finite value disables the guard. */
-    async withTimeout(promise, timeoutMs, updateId) {
-        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-            return promise;
-        let timer;
-        const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new UpdateTimeoutError(updateId, timeoutMs)), timeoutMs);
-        });
-        try {
-            return await Promise.race([promise, timeout]);
-        }
-        finally {
-            if (timer !== undefined)
-                clearTimeout(timer);
-        }
-    }
-    /**
-     * Handles a whole batch of updates at once: every chat in the batch is
-     * processed immediately (parallel across chats, ordered per chat), so a
-     * burst of 1000 messages is not stuck behind one slow handler. Individual
-     * handler failures are logged, emitted as `update:error`, and passed to the
-     * `catch()` error boundary; they never reject this promise.
-     */
-    async handleUpdates(updates) {
-        await Promise.all(updates.map(async (update) => {
-            try {
-                await this.handleUpdate(update);
-            }
-            catch {
-                // Already logged and emitted by processUpdate; the polling loop must
-                // keep flowing no matter how many handlers failed.
-            }
-        }));
-    }
-    /**
-     * Sends to many chats in parallel — built for broadcasts to 1000+ users.
-     * There is no proactive cooldown: every chat is attempted at once (up to
-     * `concurrency`). When Telegram answers 429, the send is retried
-     * automatically after exactly the `retry_after` delay Telegram ordered, so
-     * bursts deliver completely instead of failing.
-     */
-    async broadcast(chatIds, send, options) {
-        return (0, broadcast_js_1.runBroadcast)(chatIds, send, options);
-    }
-    /** Runs init() once even when many updates arrive concurrently; never claims a webhook reply slot. */
-    ensureInitialized() {
-        if (this.me)
-            return Promise.resolve();
-        if (!this.initOnce) {
-            this.initOnce = (0, webhook_reply_js_1.runWithoutWebhookReply)(() => this.init()).then(() => { this.initOnce = undefined; }, (error) => {
-                this.initOnce = undefined;
-                throw error;
-            });
-        }
-        return this.initOnce;
-    }
-    async processUpdate(update) {
-        await this.updateLimiter.run(() => this.runUpdate(update));
-    }
-    async runUpdate(update) {
-        this.logger.incoming((0, logger_js_1.describeIncomingUpdate)(update));
-        const message = update.message
-            ?? update.edited_message
-            ?? update.channel_post
-            ?? update.edited_channel_post
-            ?? update.business_message
-            ?? update.edited_business_message
-            ?? update.guest_message
-            ?? update.callback_query?.message;
-        const key = this.conversationKey(update);
-        const session = await this.session.get(key) ?? {};
-        if (!this.me)
-            await this.ensureInitialized();
-        if (!this.me)
-            return;
-        const ctx = new this.contextType({ update, api: this.api, session, services: this.services, me: this.me });
-        await this.events.emit("update", { update });
-        if (message) {
-            await this.events.emit("message", { message });
-            if (message.text?.startsWith("/")) {
-                const command = message.text.slice(1).split(/[\s@]/, 1)[0] ?? "";
-                await this.events.emit("command", { name: command, update });
-            }
-        }
-        if (update.callback_query)
-            await this.events.emit("callback", { data: update.callback_query.data ?? "", update });
-        const pipeline = (0, compose_js_1.compose)([...this.middlewares, async (context) => this.router.handle(context)]);
-        try {
-            await this.plugins.update(ctx);
-            await pipeline(ctx);
-            await this.session.set(key, ctx.session);
-        }
-        catch (error) {
-            // A handler failure belongs to this update. It must remain observable and reject
-            // direct handleUpdate() callers, but it must not poison the polling lifecycle.
-            this.logger.error("update.handler_error", { update: (0, logger_js_1.summarizeUpdate)(update, this.logger.includeUpdateContent), error });
-            await this.events.emit("update:error", { update, error });
-            await this.events.emit("bot:error", { bot: this, error });
-            if (this.errorHandler) {
-                // With an error boundary registered, the failure is considered handled:
-                // webhooks answer 200 and polling continues without rethrowing.
-                await this.errorHandler(error, ctx);
-                return;
-            }
-            throw error;
-        }
-    }
-    conversationKey(update) {
-        if (update.callback_query) {
-            const chat = update.callback_query.message?.chat;
-            const userId = update.callback_query.from.id;
-            if (chat?.id !== undefined)
-                return `${chat.id}:${userId}`;
-            return `user:${userId}`;
-        }
-        if (update.inline_query?.from?.id !== undefined)
-            return `user:${update.inline_query.from.id}`;
-        if (update.chosen_inline_result?.from?.id !== undefined)
-            return `user:${update.chosen_inline_result.from.id}`;
-        const message = update.message
-            ?? update.edited_message
-            ?? update.channel_post
-            ?? update.edited_channel_post
-            ?? update.business_message
-            ?? update.edited_business_message
-            ?? update.guest_message;
-        if (message?.chat?.id !== undefined)
-            return `${message.chat.id}:${message.from?.id ?? "anonymous"}`;
-        if (update.chat_member?.chat?.id !== undefined)
-            return `${update.chat_member.chat.id}:${update.chat_member.from.id}`;
-        if (update.my_chat_member?.chat?.id !== undefined)
-            return `${update.my_chat_member.chat.id}:${update.my_chat_member.from.id}`;
-        if (update.chat_join_request?.chat?.id !== undefined)
-            return `${update.chat_join_request.chat.id}:${update.chat_join_request.from.id}`;
-        return `update:${update.update_id}`;
-    }
-    async waitForRetry(delayMs, signal) {
-        if (signal.aborted)
-            return false;
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                signal.removeEventListener("abort", onAbort);
-                resolve(true);
-            }, delayMs);
-            const onAbort = () => {
-                clearTimeout(timer);
-                signal.removeEventListener("abort", onAbort);
-                resolve(false);
-            };
-            signal.addEventListener("abort", onAbort, { once: true });
-        });
-    }
-    async poll(timeout, allowedUpdates, signal) {
-        let delay = this.pollingOptions.retryDelayMs;
-        // Telegram holds a long-poll connection open for `timeout` seconds, so the
-        // request timeout must exceed it to avoid aborting a healthy connection.
-        const requestTimeoutMs = timeout * 1_000 + 10_000;
-        while (!signal.aborted) {
-            try {
-                const updates = await this.api.request("getUpdates", { offset: this.offset, limit: this.pollingOptions.limit, timeout, allowed_updates: allowedUpdates }, signal, { timeoutMs: requestTimeoutMs });
-                delay = this.pollingOptions.retryDelayMs;
-                // Confirm the whole batch first, then process it: updates run in
-                // parallel across chats (ordered per chat) instead of one by one.
-                for (const update of updates) {
-                    this.offset = Math.max(this.offset, update.update_id + 1);
-                }
-                await this.handleUpdates(updates);
-            }
-            catch (error) {
-                if (signal.aborted)
-                    break;
-                const attempt = Math.max(1, Math.round(Math.log2(delay / this.pollingOptions.retryDelayMs) + 1));
-                this.logger.warn("polling.reconnect", { attempt, delayMs: delay, error });
-                await this.events.emit("polling:reconnect", { error, attempt });
-                if (!(await this.waitForRetry(delay, signal)))
-                    break;
-                delay = Math.min(this.pollingOptions.maxRetryDelayMs, delay * 2);
-            }
-        }
-    }
-}
-exports.Bot = Bot;

package/dist-cjs/src/core/events.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventBus = void 0;
-class EventBus {
-    listeners = new Map();
-    on(event, listener) {
-        const bucket = this.listeners.get(event) ?? new Set();
-        bucket.add(listener);
-        this.listeners.set(event, bucket);
-        return () => this.off(event, listener);
-    }
-    once(event, listener) {
-        const dispose = this.on(event, async (payload) => { dispose(); await listener(payload); });
-        return dispose;
-    }
-    off(event, listener) {
-        this.listeners.get(event)?.delete(listener);
-    }
-    async emit(event, payload) {
-        const listeners = [...(this.listeners.get(event) ?? [])];
-        const errors = [];
-        for (const listener of listeners) {
-            try {
-                await listener(payload);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-        if (errors.length === 1)
-            throw errors[0];
-        if (errors.length > 1)
-            throw new AggregateError(errors, `One or more listeners failed for event ${String(event)}`);
-    }
-    removeAllListeners() { this.listeners.clear(); }
-    listenerCount(event) { return this.listeners.get(event)?.size ?? 0; }
-}
-exports.EventBus = EventBus;

package/dist-cjs/src/core/webhook-reply.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runWithWebhookReply = runWithWebhookReply;
-exports.runWithoutWebhookReply = runWithoutWebhookReply;
-exports.claimWebhookReply = claimWebhookReply;
-exports.hasWebhookReply = hasWebhookReply;
-const node_async_hooks_1 = require("node:async_hooks");
-const storage = new node_async_hooks_1.AsyncLocalStorage();
-/** Runs `fn` with a webhook reply sink active for every API call inside it. */
-function runWithWebhookReply(sink, fn) {
-    return storage.run({ sink, claimed: false, suppressed: false }, fn);
-}
-/**
- * Runs `fn` with webhook replies suppressed (library-internal calls such as
- * the lazy `getMe` initialization must never claim the response slot).
- */
-function runWithoutWebhookReply(fn) {
-    const state = storage.getStore();
-    if (!state)
-        return fn();
-    return storage.run({ ...state, suppressed: true }, fn);
-}
-/**
- * Claims the webhook reply for `method`/`payload` if a sink is active and not
- * yet used. Returns the synthesized transport response the caller should
- * resolve with, or `undefined` when the call must go through the transport.
- */
-function claimWebhookReply(method, payload) {
-    const state = storage.getStore();
-    if (!state || state.claimed || state.suppressed)
-        return undefined;
-    state.claimed = true;
-    state.sink({ method, ...(payload ?? {}) });
-    // Telegram never sends the method result back to the webhook response, so
-    // the caller resolves with a synthetic success (same as Telegraf).
-    return { status: 200, data: { ok: true, result: true } };
-}
-/** True while an unclaimed webhook reply is available (diagnostics/testing). */
-function hasWebhookReply() {
-    const state = storage.getStore();
-    return state !== undefined && !state.claimed;
-}

package/dist-cjs/src/index.js

@@ -1,47 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startTeleBibzBanner = exports.runStartupSequence = exports.printStatusLine = exports.paintRainbow = exports.printTeleBibzBanner = exports.printTerminalBranding = exports.buildTerminalBranding = void 0;
-__exportStar(require("./core/bot.js"), exports);
-__exportStar(require("./core/webhook-reply.js"), exports);
-__exportStar(require("./core/events.js"), exports);
-__exportStar(require("./api/index.js"), exports);
-__exportStar(require("./context/context.js"), exports);
-__exportStar(require("./middleware/compose.js"), exports);
-__exportStar(require("./router/router.js"), exports);
-__exportStar(require("./keyboard/index.js"), exports);
-__exportStar(require("./storage/storage.js"), exports);
-__exportStar(require("./cache/cache.js"), exports);
-__exportStar(require("./queue/queue.js"), exports);
-__exportStar(require("./plugins/plugin.js"), exports);
-__exportStar(require("./webhook/handler.js"), exports);
-__exportStar(require("./utils/text.js"), exports);
-__exportStar(require("./utils/files.js"), exports);
-__exportStar(require("./utils/concurrency.js"), exports);
-__exportStar(require("./broadcast/broadcast.js"), exports);
-__exportStar(require("./state/conversation.js"), exports);
-__exportStar(require("./state/forms.js"), exports);
-__exportStar(require("./state/menu.js"), exports);
-__exportStar(require("./telegram-features.js"), exports);
-var terminal_js_1 = require("./branding/terminal.js");
-Object.defineProperty(exports, "buildTerminalBranding", { enumerable: true, get: function () { return terminal_js_1.buildTerminalBranding; } });
-Object.defineProperty(exports, "printTerminalBranding", { enumerable: true, get: function () { return terminal_js_1.printTerminalBranding; } });
-Object.defineProperty(exports, "printTeleBibzBanner", { enumerable: true, get: function () { return terminal_js_1.printTeleBibzBanner; } });
-Object.defineProperty(exports, "paintRainbow", { enumerable: true, get: function () { return terminal_js_1.paintRainbow; } });
-Object.defineProperty(exports, "printStatusLine", { enumerable: true, get: function () { return terminal_js_1.printStatusLine; } });
-Object.defineProperty(exports, "runStartupSequence", { enumerable: true, get: function () { return terminal_js_1.runStartupSequence; } });
-Object.defineProperty(exports, "startTeleBibzBanner", { enumerable: true, get: function () { return terminal_js_1.startTeleBibzBanner; } });
-__exportStar(require("./observability/logger.js"), exports);