@xbibzlibrary/telebibz 0.1.0

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

@@ -0,0 +1,27 @@
+"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) ?? [])];
+        for (const listener of listeners)
+            await listener(payload);
+    }
+    removeAllListeners() { this.listeners.clear(); }
+    listenerCount(event) { return this.listeners.get(event)?.size ?? 0; }
+}
+exports.EventBus = EventBus;

package/dist-cjs/src/index.js

@@ -0,0 +1,33 @@
+"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 });
+__exportStar(require("./core/bot.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("./state/conversation.js"), exports);
+__exportStar(require("./state/forms.js"), exports);
+__exportStar(require("./state/menu.js"), exports);
+__exportStar(require("./approval/approval.js"), exports);

package/dist-cjs/src/keyboard/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplyKeyboard = exports.InlineKeyboard = void 0;
+exports.removeKeyboard = removeKeyboard;
+exports.forceReply = forceReply;
+class InlineKeyboard {
+    rows = [];
+    static from(rows) { const keyboard = new InlineKeyboard(); keyboard.rows.push(...rows.map((row) => [...row])); return keyboard; }
+    text(text, callbackData) { return this.button({ text, callback_data: callbackData }); }
+    url(text, url) { return this.button({ text, url }); }
+    webApp(text, url) { return this.button({ text, web_app: { url } }); }
+    pay(text = "Pay") { return this.button({ text, pay: true }); }
+    copy(text, copiedText) { return this.button({ text, copy_text: { text: copiedText } }); }
+    button(button) { this.ensureRow().push(validateInlineButton(button)); return this; }
+    row(...buttons) { this.rows.push(buttons.map(validateInlineButton)); return this; }
+    conditional(condition, factory) { return condition ? factory(this) : this; }
+    grid(buttons, columns) { if (!Number.isInteger(columns) || columns < 1)
+        throw new RangeError("columns must be a positive integer"); for (let index = 0; index < buttons.length; index += columns)
+        this.rows.push(buttons.slice(index, index + columns).map(validateInlineButton)); return this; }
+    build() { return { inline_keyboard: this.rows.map((row) => [...row]) }; }
+    asReplyMarkup() { return this.build(); }
+    ensureRow() { const row = this.rows.at(-1); if (row)
+        return row; const next = []; this.rows.push(next); return next; }
+}
+exports.InlineKeyboard = InlineKeyboard;
+class ReplyKeyboard {
+    rows = [];
+    text(text) { return this.button({ text }); }
+    contact(text) { return this.button({ text, request_contact: true }); }
+    location(text) { return this.button({ text, request_location: true }); }
+    poll(text, type) { return this.button({ text, request_poll: type ? { type } : {} }); }
+    webApp(text, url) { return this.button({ text, web_app: { url } }); }
+    button(button) { this.ensureRow().push(button); return this; }
+    row(...buttons) { this.rows.push([...buttons]); return this; }
+    grid(buttons, columns) { if (!Number.isInteger(columns) || columns < 1)
+        throw new RangeError("columns must be a positive integer"); for (let index = 0; index < buttons.length; index += columns)
+        this.rows.push(buttons.slice(index, index + columns)); return this; }
+    build(options = {}) { return { keyboard: this.rows.map((row) => [...row]), ...options }; }
+    asReplyMarkup() { return this.build(); }
+    ensureRow() { const row = this.rows.at(-1); if (row)
+        return row; const next = []; this.rows.push(next); return next; }
+}
+exports.ReplyKeyboard = ReplyKeyboard;
+function removeKeyboard(selective = false) { return { remove_keyboard: true, ...(selective ? { selective: true } : {}) }; }
+function forceReply(placeholder, selective = false) { return { force_reply: true, ...(placeholder ? { input_field_placeholder: placeholder } : {}), ...(selective ? { selective: true } : {}) }; }
+function validateInlineButton(button) { if (!button.text)
+    throw new Error("Inline keyboard button text is required."); const actions = [button.url, button.callback_data, button.web_app, button.login_url, button.switch_inline_query, button.switch_inline_query_current_chat, button.callback_game, button.pay, button.copy_text].filter((value) => value !== undefined); if (actions.length !== 1)
+    throw new Error(`Inline button ${button.text} must contain exactly one action.`); if (button.callback_data && new TextEncoder().encode(button.callback_data).length > 64)
+    throw new RangeError("callback_data must be at most 64 bytes."); return { ...button }; }

package/dist-cjs/src/middleware/compose.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = compose;
+exports.middleware = middleware;
+function compose(middleware) {
+    return async function run(ctx) {
+        let index = -1;
+        const dispatch = async (position) => {
+            if (position <= index)
+                throw new Error("next() called multiple times");
+            index = position;
+            const handler = middleware[position];
+            if (!handler)
+                return;
+            await handler(ctx, () => dispatch(position + 1));
+        };
+        await dispatch(0);
+    };
+}
+function middleware(handler) { return handler; }

package/dist-cjs/src/plugins/plugin.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = exports.ServiceContainer = void 0;
+class ServiceContainer {
+    values = new Map();
+    register(name, value) { this.values.set(name, value); return this; }
+    get(name) { if (!this.values.has(name))
+        throw new Error(`Service not registered: ${String(name)}`); return this.values.get(name); }
+    has(name) { return this.values.has(name); }
+    delete(name) { return this.values.delete(name); }
+}
+exports.ServiceContainer = ServiceContainer;
+class PluginManager {
+    plugins = [];
+    api;
+    constructor(bot) {
+        this.api = { bot, services: new ServiceContainer(), registerMiddleware: () => undefined, registerRoute: () => undefined };
+    }
+    use(plugin) { if (this.plugins.some((existing) => existing.name === plugin.name))
+        throw new Error(`Plugin already registered: ${plugin.name}`); this.plugins.push(plugin); return this; }
+    async setup() { for (const plugin of this.plugins) {
+        await plugin.install?.(this.api);
+        await plugin.setup?.(this.api);
+    } }
+    async start() { for (const plugin of this.plugins)
+        await plugin.onStart?.(this.api); }
+    async update(context) { for (const plugin of this.plugins)
+        await plugin.onUpdate?.(context); }
+    async stop() { for (const plugin of this.plugins)
+        await plugin.onStop?.(this.api); }
+    async dispose() { for (const plugin of [...this.plugins].reverse())
+        await plugin.dispose?.(this.api); }
+    list() { return this.plugins; }
+}
+exports.PluginManager = PluginManager;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = exports.TaskQueue = void 0;
+class TaskQueue {
+    worker;
+    options;
+    pending = [];
+    jobs = new Map();
+    controllers = new Map();
+    active = 0;
+    sequence = 0;
+    draining = false;
+    constructor(worker, options = {}) {
+        this.worker = worker;
+        this.options = options;
+    }
+    add(data, options = {}) { const id = options.id ?? `job_${Date.now()}_${this.sequence++}`; if (this.jobs.has(id))
+        throw new Error(`Job already exists: ${id}`); const job = { id, data, attempts: 0, priority: options.priority ?? 0, runAt: Date.now() + (options.delayMs ?? 0), status: "queued" }; this.jobs.set(id, job); this.pending.push(job); this.pending.sort((a, b) => b.priority - a.priority || a.runAt - b.runAt); void this.drain(); return { ...job }; }
+    get(id) { const job = this.jobs.get(id); return job ? { ...job } : undefined; }
+    cancel(id) { const job = this.jobs.get(id); if (!job || ["completed", "failed", "cancelled"].includes(job.status))
+        return false; job.status = "cancelled"; this.controllers.get(id)?.abort(); return true; }
+    async onIdle() { while (this.pending.length || this.active)
+        await new Promise((resolve) => setTimeout(resolve, 10)); }
+    async close() { this.draining = false; for (const id of this.controllers.keys())
+        this.cancel(id); }
+    async drain() { if (this.draining)
+        return; this.draining = true; try {
+        while (this.pending.length && this.active < (this.options.concurrency ?? 1)) {
+            const index = this.pending.findIndex((job) => job.runAt <= Date.now() && job.status === "queued");
+            if (index < 0) {
+                const wait = Math.max(1, Math.min(...this.pending.map((job) => job.runAt - Date.now())));
+                await new Promise((resolve) => setTimeout(resolve, wait));
+                continue;
+            }
+            const [job] = this.pending.splice(index, 1);
+            if (!job)
+                continue;
+            this.active += 1;
+            void this.run(job).finally(() => { this.active -= 1; void this.drain(); });
+        }
+    }
+    finally {
+        this.draining = false;
+    } }
+    async run(job) { const maxAttempts = this.options.retries ?? 0; const controller = new AbortController(); this.controllers.set(job.id, controller); try {
+        while (job.attempts <= maxAttempts && job.status !== "cancelled") {
+            job.status = "running";
+            job.attempts += 1;
+            try {
+                await this.worker(job, controller.signal);
+                job.status = "completed";
+                return;
+            }
+            catch (error) {
+                job.error = error;
+                if (job.attempts > maxAttempts) {
+                    job.status = "failed";
+                    return;
+                }
+                const delay = Math.min(this.options.maxBackoffMs ?? 30_000, (this.options.backoffMs ?? 250) * 2 ** (job.attempts - 1));
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    finally {
+        this.controllers.delete(job.id);
+    } }
+}
+exports.TaskQueue = TaskQueue;
+class Scheduler {
+    timers = new Map();
+    every(id, intervalMs, task) { if (intervalMs <= 0)
+        throw new RangeError("intervalMs must be positive"); this.cancel(id); const timer = setInterval(() => { void task(); }, intervalMs); this.timers.set(id, timer); return { id, cancel: () => this.cancel(id) }; }
+    after(id, delayMs, task) { this.cancel(id); const timer = setTimeout(() => { this.timers.delete(id); void task(); }, delayMs); this.timers.set(id, timer); return { id, cancel: () => this.cancel(id) }; }
+    cron(id, expression, task) { const interval = parseSimpleCronInterval(expression); return this.every(id, interval, task); }
+    cancel(id) { const timer = this.timers.get(id); if (!timer)
+        return false; clearTimeout(timer); clearInterval(timer); this.timers.delete(id); return true; }
+    clear() { for (const id of [...this.timers.keys()])
+        this.cancel(id); }
+}
+exports.Scheduler = Scheduler;
+function parseSimpleCronInterval(expression) { const minute = expression.trim().split(/\s+/)[0]; if (minute?.startsWith("*/")) {
+    const value = Number(minute.slice(2));
+    if (Number.isInteger(value) && value > 0)
+        return value * 60_000;
+} throw new Error("Only interval cron expressions such as */5 are supported by the built-in scheduler; use an adapter for full cron syntax."); }

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const compose_js_1 = require("../middleware/compose.js");
+class Router {
+    routes = [];
+    sequence = 0;
+    use(...middleware) { this.routes.push({ priority: -1_000_000 + this.sequence++, matcher: () => true, middleware }); return this; }
+    route(matcher, ...middleware) { this.routes.push({ priority: this.sequence++, matcher, middleware }); return this; }
+    command(name, ...middleware) { return this.route(async (ctx) => { const text = ctx.message?.text; if (!text?.startsWith("/"))
+        return false; const command = text.slice(1).split(/[\s@]/, 1)[0] ?? ""; return typeof name === "string" ? command === name.replace(/^\//, "") : name.test(command); }, ...middleware); }
+    text(value, ...middleware) { return this.route((ctx) => ctx.message?.text === value, ...middleware); }
+    regex(expression, ...middleware) { return this.route((ctx) => expression.test(ctx.message?.text ?? ""), ...middleware); }
+    callback(pattern, ...middleware) { return this.route((ctx) => { const data = ctx.callbackQuery?.data ?? ""; return typeof pattern === "string" ? pattern.endsWith("*") ? data.startsWith(pattern.slice(0, -1)) : data === pattern : pattern.test(data); }, ...middleware); }
+    chat(chatId, ...middleware) { return this.route((ctx) => { const id = ctx.message?.chat?.id; return id === chatId || String(id) === String(chatId); }, ...middleware); }
+    predicate(matcher, ...middleware) { return this.route(matcher, ...middleware); }
+    nest(child) { return this.route(() => true, async (ctx, next) => { await child.handle(ctx, next); }); }
+    async handle(ctx, terminal) { const ordered = [...this.routes].sort((left, right) => left.priority - right.priority); let matched = false; for (const route of ordered) {
+        if (!(await route.matcher(ctx)))
+            continue;
+        matched = true;
+        await (0, compose_js_1.compose)(route.middleware)(ctx);
+    } if (!matched)
+        await terminal?.(); }
+}
+exports.Router = Router;

package/dist-cjs/src/state/conversation.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wizard = exports.ConversationManager = exports.ConversationFlow = void 0;
+class ConversationFlow {
+    ctx;
+    state;
+    constructor(ctx, state) {
+        this.ctx = ctx;
+        this.state = state;
+    }
+    get values() { return this.state.values; }
+    set(key, value) { this.state.values[key] = value; this.state.updatedAt = Date.now(); return this; }
+    get(key) { return this.state.values[key]; }
+    next() { this.state.step += 1; this.state.updatedAt = Date.now(); return this; }
+    previous() { this.state.step = Math.max(0, this.state.step - 1); this.state.updatedAt = Date.now(); return this; }
+    complete() { this.state.status = "completed"; this.state.updatedAt = Date.now(); }
+    cancel() { this.state.status = "cancelled"; this.state.updatedAt = Date.now(); }
+}
+exports.ConversationFlow = ConversationFlow;
+class ConversationManager {
+    active = new Map();
+    start(key, name, values = {}) { const state = { name, step: 0, values, status: "active", updatedAt: Date.now() }; this.active.set(key, state); return state; }
+    get(key) { return this.active.get(key); }
+    cancel(key) { const state = this.active.get(key); if (!state)
+        return false; state.status = "cancelled"; state.updatedAt = Date.now(); return true; }
+    clearExpired(maxAgeMs) { const threshold = Date.now() - maxAgeMs; let removed = 0; for (const [key, state] of this.active)
+        if (state.updatedAt < threshold) {
+            this.active.delete(key);
+            removed += 1;
+        } return removed; }
+    async run(ctx, key, name, steps) { const state = this.active.get(key) ?? this.start(key, name); const flow = new ConversationFlow(ctx, state); const step = steps[state.step]; if (!step) {
+        state.status = "completed";
+        return state;
+    } await step(flow); return state; }
+}
+exports.ConversationManager = ConversationManager;
+class Wizard {
+    stepsList = [];
+    step(step) { this.stepsList.push(step); return this; }
+    async run(ctx, key, manager = new ConversationManager()) { return manager.run(ctx, key, "wizard", this.stepsList.map((step) => step.run)); }
+    get steps() { return this.stepsList; }
+}
+exports.Wizard = Wizard;

package/dist-cjs/src/state/forms.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validators = exports.Form = void 0;
+class Form {
+    fields = new Map();
+    values = {};
+    field(definition) { this.fields.set(definition.name, definition); return this; }
+    async parse(input) { const issues = []; for (const [name, field] of this.fields) {
+        const raw = input[name];
+        if ((raw === undefined || raw === null || raw === "") && field.required) {
+            issues.push({ path: name, message: "Field is required", code: "required" });
+            continue;
+        }
+        if (raw === undefined || raw === null || raw === "")
+            continue;
+        try {
+            let value = field.parse(raw);
+            if (field.transform)
+                value = await field.transform(value);
+            const error = await field.validate?.(value);
+            if (error)
+                issues.push({ path: name, message: error, code: "invalid" });
+            else
+                this.values[name] = value;
+        }
+        catch (error) {
+            issues.push({ path: name, message: error instanceof Error ? error.message : "Invalid value", code: "parse" });
+        }
+    } return issues.length ? { success: false, issues } : { success: true, data: this.values }; }
+    reset() { for (const key of Object.keys(this.values))
+        delete this.values[key]; }
+}
+exports.Form = Form;
+exports.validators = { string: (value) => { if (typeof value !== "string")
+        throw new TypeError("Expected string"); return value; }, number: (value) => { const number = typeof value === "number" ? value : Number(value); if (!Number.isFinite(number))
+        throw new TypeError("Expected number"); return number; }, integer: (value) => { const number = exports.validators.number(value); if (!Number.isInteger(number))
+        throw new TypeError("Expected integer"); return number; }, email: (value) => { const email = exports.validators.string(value); if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email))
+        throw new TypeError("Expected email"); return email; }, url: (value) => { const url = exports.validators.string(value); try {
+        new URL(url);
+        return url;
+    }
+    catch {
+        throw new TypeError("Expected URL");
+    } } };

package/dist-cjs/src/state/menu.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Menu = void 0;
+exports.paginate = paginate;
+exports.paginationButtons = paginationButtons;
+const index_js_1 = require("../keyboard/index.js");
+function paginate(items, page, pageSize) { if (!Number.isInteger(page) || page < 0)
+    throw new RangeError("page must be a non-negative integer"); if (!Number.isInteger(pageSize) || pageSize < 1)
+    throw new RangeError("pageSize must be a positive integer"); const pageCount = Math.max(1, Math.ceil(items.length / pageSize)); const safePage = Math.min(page, pageCount - 1); const start = safePage * pageSize; return { items: items.slice(start, start + pageSize), page: safePage, pageCount, hasPrevious: safePage > 0, hasNext: safePage < pageCount - 1 }; }
+function paginationButtons(page, prefix) { const buttons = []; if (page.hasPrevious)
+    buttons.push({ text: "Previous", callback_data: `${prefix}:page:${page.page - 1}` }); buttons.push({ text: `${page.page + 1}/${page.pageCount}`, callback_data: `${prefix}:noop` }); if (page.hasNext)
+    buttons.push({ text: "Next", callback_data: `${prefix}:page:${page.page + 1}` }); return buttons; }
+class Menu {
+    id;
+    itemsList = [];
+    parents = [];
+    constructor(id) {
+        this.id = id;
+    }
+    item(item) { this.itemsList.push(item); return this; }
+    breadcrumb(label) { this.parents.push(label); return this; }
+    async build() { const keyboard = new index_js_1.InlineKeyboard(); for (const item of this.itemsList) {
+        const visible = typeof item.visible === "function" ? await item.visible() : item.visible ?? true;
+        if (!visible)
+            continue;
+        if (item.url)
+            keyboard.url(item.label, item.url);
+        else
+            keyboard.text(item.label, item.callbackData ?? `${this.id}:${item.id}`);
+    } return keyboard; }
+    get breadcrumbs() { return this.parents; }
+}
+exports.Menu = Menu;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+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;
+    }
+    async set(key, value, options = {}) {
+        const entry = { value };
+        if (options.ttlMs !== undefined)
+            entry.expiresAt = Date.now() + options.ttlMs;
+        this.valuesMap.set(key, entry);
+    }
+    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;

package/dist-cjs/src/testing.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockTransport = void 0;
+exports.createMockUpdate = createMockUpdate;
+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 = [];
+    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 }; }
+}
+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 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/webhook/handler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookHandler = createWebhookHandler;
+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 && request.headers.get("x-telegram-bot-api-secret-token") !== options.secretToken)
+            return new Response("Unauthorized", { status: 401 });
+        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 });
+            await bot.handleUpdate(update);
+            return new Response("OK", { status: 200 });
+        }
+        catch (error) {
+            await options.onError?.(error);
+            return new Response("Internal Server Error", { status: 500 });
+        }
+    };
+}

package/docs/README.md

@@ -0,0 +1,21 @@
+# Dokumentasi telebibz
+
+Dokumentasi ini disusun menurut lifecycle aplikasi: mulai dari bot paling sederhana, API client dan transport, update routing, middleware dan context, state/session, interaction UI, background work, deployment, lalu testing dan migration.
+
+| Area | Status |
+|---|---|
+| Getting started | Tersedia di `README.md` |
+| Bot lifecycle, polling, webhook | Core implementation dan tests tersedia |
+| API client dan generated method list | Tersedia; object type generation masih partial |
+| Router, middleware, context | Tersedia dan diuji |
+| Keyboard, callback, menus, pagination | Keyboard/callback core tersedia; menu/pagination lanjutan partial |
+| Sessions, conversations, scenes, wizard, forms | Memory session dan primitives forms/conversation tersedia; integration lanjutan partial |
+| Storage, cache, queue, scheduler | Memory primitives tersedia; distributed adapters belum tersedia |
+| Plugins, services, observability | Lifecycle/plugin/service hooks tersedia |
+| Mini Apps, payments, business features | Raw API access tersedia; high-level subsystem belum lengkap |
+| Testing dan security | Unit, integration, type-level, gated E2E, CI, security policy tersedia |
+| Deployment dan migration | Roadmap dan package boundaries perlu diperluas sebelum stable release |
+
+## Prinsip dokumentasi
+
+Dokumentasi tidak akan menyebut fitur `production-ready` jika implementasi, test, atau adapter-nya belum benar-benar tersedia. Batas native Telegram dan kemampuan Mini App/Web App harus dijelaskan terpisah agar API tidak menjanjikan kemampuan yang tidak dimiliki Telegram.

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@xbibzlibrary/telebibz",
+  "version": "0.1.0",
+  "description": "Production-grade, strongly typed Telegram Bot API SDK and framework for Node.js and TypeScript.",
+  "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "generate": "node scripts/generate-api.mjs",
+    "update:telegram": "node scripts/fetch-telegram-api.mjs && npm run generate",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/create-cjs-package.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "tsc -p tsconfig.json --noEmit && eslint scripts/*.mjs bin/*.mjs --no-error-on-unmatched-pattern",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run tests/integration/**/*.test.ts",
+    "test:e2e": "vitest run tests/e2e",
+    "test:types": "tsc -p tests/tsconfig.json --noEmit",
+    "benchmark": "tsx tests/benchmark.ts",
+    "package:check": "npm run build && npm pack --dry-run",
+    "security": "npm audit --audit-level=high --package-lock-only",
+    "release:check": "node scripts/release-check.mjs",
+    "doctor": "tsx src/cli.ts doctor",
+    "dev": "tsx examples/minimal.ts",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm run test:types && npm run lint && npm test && npm run build && npm run security && npm run release:check"
+  },
+  "bin": {
+    "telebibz": "./bin/telebibz.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "require": "./dist-cjs/src/index.js"
+    },
+    "./api": {
+      "types": "./dist/src/api/index.d.ts",
+      "import": "./dist/src/api/index.js",
+      "require": "./dist-cjs/src/api/index.js"
+    },
+    "./keyboard": {
+      "types": "./dist/src/keyboard/index.d.ts",
+      "import": "./dist/src/keyboard/index.js",
+      "require": "./dist-cjs/src/keyboard/index.js"
+    },
+    "./testing": {
+      "types": "./dist/src/testing.d.ts",
+      "import": "./dist/src/testing.js",
+      "require": "./dist-cjs/src/testing.js"
+    }
+  },
+  "files": [
+    "dist",
+    "dist-cjs",
+    "bin",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "APPROVAL_FEATURE.md",
+    "docs"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "eslint": "^9.17.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^4.1.11"
+  }
+}