@xbibzlibrary/telebibz 0.4.4 → 3.0.1

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

@@ -1,186 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = exports.UPDATE_FILTER_TYPES = void 0;
-const compose_js_1 = require("../middleware/compose.js");
-function testRegExp(expression, value) {
-    expression.lastIndex = 0;
-    return expression.test(value);
-}
-/** Update types accepted by `on()` filters, mirroring the Telegram `Update` object. */
-exports.UPDATE_FILTER_TYPES = [
-    "message",
-    "edited_message",
-    "channel_post",
-    "edited_channel_post",
-    "business_connection",
-    "business_message",
-    "edited_business_message",
-    "deleted_business_messages",
-    "guest_message",
-    "message_reaction",
-    "message_reaction_count",
-    "inline_query",
-    "chosen_inline_result",
-    "callback_query",
-    "shipping_query",
-    "pre_checkout_query",
-    "purchased_paid_media",
-    "poll",
-    "poll_answer",
-    "my_chat_member",
-    "chat_member",
-    "chat_join_request",
-    "chat_boost",
-    "removed_chat_boost",
-];
-const updateFilterTypes = new Set(exports.UPDATE_FILTER_TYPES);
-function assertValidFilter(filter) {
-    const type = filter.split(":", 1)[0] ?? "";
-    if (!updateFilterTypes.has(type))
-        throw new TypeError(`Unknown update type in filter "${filter}". Expected one of: ${exports.UPDATE_FILTER_TYPES.join(", ")}.`);
-}
-function matchesFilter(ctx, filter) {
-    const separator = filter.indexOf(":");
-    const type = separator < 0 ? filter : filter.slice(0, separator);
-    const field = separator < 0 ? undefined : filter.slice(separator + 1);
-    const payload = ctx.update[type];
-    if (payload === undefined || payload === null)
-        return false;
-    if (field === undefined || field === "")
-        return true;
-    return typeof payload === "object" && payload[field] !== undefined;
-}
-class Router {
-    middlewares = [];
-    routes = [];
-    sequence = 0;
-    matchMode;
-    constructor(options = {}) {
-        this.matchMode = options.matchMode ?? "first";
-    }
-    use(...middleware) {
-        if (middleware.length === 0)
-            return this;
-        this.middlewares.push(...middleware);
-        return this;
-    }
-    route(matcher, ...middleware) {
-        if (middleware.length === 0)
-            throw new Error("A route requires at least one middleware handler.");
-        this.routes.push({ priority: this.sequence++, matcher, middleware });
-        return this;
-    }
-    command(name, ...middleware) {
-        return this.route(async (ctx) => {
-            const text = ctx.message?.text ?? ctx.message?.caption;
-            if (!text?.startsWith("/"))
-                return false;
-            const parts = text.slice(1).split(/\s+/);
-            const commandWithBot = parts[0] ?? "";
-            const [command, botUsername] = commandWithBot.split("@");
-            if (botUsername && ctx.me?.username && botUsername.toLowerCase() !== ctx.me.username.toLowerCase()) {
-                return false;
-            }
-            const matched = typeof name === "string"
-                ? command === name.replace(/^\//, "")
-                : testRegExp(name, command ?? "");
-            if (matched) {
-                ctx.args = parts.slice(1);
-            }
-            return matched;
-        }, ...middleware);
-    }
-    text(value, ...middleware) {
-        return this.route((ctx) => {
-            const text = ctx.message?.text ?? ctx.message?.caption;
-            return text === value;
-        }, ...middleware);
-    }
-    regex(expression, ...middleware) {
-        return this.route((ctx) => {
-            const text = ctx.message?.text ?? ctx.message?.caption ?? "";
-            const match = text.match(expression);
-            if (match) {
-                ctx.match = match;
-                return true;
-            }
-            return false;
-        }, ...middleware);
-    }
-    callback(pattern, ...middleware) {
-        return this.route((ctx) => {
-            const data = ctx.callbackQuery?.data ?? "";
-            if (typeof pattern === "string") {
-                if (pattern.endsWith("*")) {
-                    const prefix = pattern.slice(0, -1);
-                    if (data.startsWith(prefix)) {
-                        ctx.params = { ...ctx.params, wildcard: data.slice(prefix.length) };
-                        return true;
-                    }
-                    return false;
-                }
-                return data === pattern;
-            }
-            const match = data.match(pattern);
-            if (match) {
-                ctx.match = match;
-                return true;
-            }
-            return false;
-        }, ...middleware);
-    }
-    chat(chatId, ...middleware) {
-        return this.route((ctx) => {
-            const id = ctx.message?.chat?.id;
-            return id !== undefined && (id === chatId || String(id) === String(chatId));
-        }, ...middleware);
-    }
-    /**
-     * Registers handlers for update types, with optional payload narrowing:
-     * `on("message")`, `on("message:photo")`, `on("callback_query:data")`,
-     * or an array such as `["message:text", "callback_query:data"]`.
-     */
-    on(filter, ...middleware) {
-        const filters = (Array.isArray(filter) ? filter : [filter]).map((value) => String(value));
-        if (filters.length === 0)
-            throw new Error("At least one update filter is required.");
-        for (const value of filters)
-            assertValidFilter(value);
-        return this.route((ctx) => filters.some((value) => matchesFilter(ctx, value)), ...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 routeDispatcher = async (currentCtx, next) => {
-            const ordered = [...this.routes].sort((left, right) => left.priority - right.priority);
-            let matched = false;
-            for (const route of ordered) {
-                if (!(await route.matcher(currentCtx)))
-                    continue;
-                matched = true;
-                await (0, compose_js_1.compose)(route.middleware)(currentCtx);
-                if (this.matchMode === "first")
-                    break;
-            }
-            if (!matched) {
-                if (terminal)
-                    await terminal();
-                else
-                    await next();
-            }
-        };
-        if (this.middlewares.length === 0) {
-            await routeDispatcher(ctx, async () => { });
-        }
-        else {
-            await (0, compose_js_1.compose)([...this.middlewares, routeDispatcher])(ctx);
-        }
-    }
-}
-exports.Router = Router;

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

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Wizard = exports.ConversationManager = exports.ConversationFlow = void 0;
-exports.conversationKeyFromContext = conversationKeyFromContext;
-const storage_js_1 = require("../storage/storage.js");
-function conversationKeyFromContext(ctx) {
-    return ctx.chat?.id !== undefined ? `${ctx.chat.id}:${ctx.from?.id ?? "anonymous"}` : `update:${ctx.update.update_id}`;
-}
-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();
-    storage;
-    constructor(storage = new storage_js_1.MemoryStorage()) {
-        this.storage = storage;
-    }
-    start(key, name, values = {}) {
-        const state = { name, step: 0, values, status: "active", updatedAt: Date.now() };
-        this.active.set(key, state);
-        void this.storage.set(key, state).catch(() => undefined);
-        return state;
-    }
-    async startAsync(key, name, values = {}) {
-        const state = { name, step: 0, values, status: "active", updatedAt: Date.now() };
-        this.active.set(key, state);
-        await this.storage.set(key, state);
-        return state;
-    }
-    get(key) { return this.active.get(key); }
-    async getAsync(key) {
-        const cached = this.active.get(key);
-        if (cached)
-            return cached;
-        const stored = await this.storage.get(key);
-        if (stored)
-            this.active.set(key, stored);
-        return stored;
-    }
-    cancel(key) {
-        const state = this.active.get(key);
-        if (!state)
-            return false;
-        state.status = "cancelled";
-        state.updatedAt = Date.now();
-        void this.storage.set(key, state).catch(() => undefined);
-        return true;
-    }
-    async cancelAsync(key) {
-        const state = await this.getAsync(key);
-        if (!state)
-            return false;
-        state.status = "cancelled";
-        state.updatedAt = Date.now();
-        await this.storage.set(key, state);
-        return true;
-    }
-    clearExpired(maxAgeMs) {
-        if (!Number.isFinite(maxAgeMs) || maxAgeMs < 0)
-            throw new RangeError("maxAgeMs must be non-negative");
-        const threshold = Date.now() - maxAgeMs;
-        let removed = 0;
-        for (const [key, state] of this.active)
-            if (state.updatedAt < threshold) {
-                this.active.delete(key);
-                void this.storage.delete(key);
-                removed += 1;
-            }
-        return removed;
-    }
-    async clearExpiredAsync(maxAgeMs) {
-        if (!Number.isFinite(maxAgeMs) || maxAgeMs < 0)
-            throw new RangeError("maxAgeMs must be non-negative");
-        const threshold = Date.now() - maxAgeMs;
-        let removed = 0;
-        for await (const [key, state] of this.storage.entries()) {
-            if (state.updatedAt < threshold) {
-                await this.storage.delete(key);
-                this.active.delete(key);
-                removed += 1;
-            }
-        }
-        return removed;
-    }
-    async run(ctx, key, name, steps) {
-        const existing = await this.getAsync(key);
-        const state = existing ?? await this.startAsync(key, name);
-        if (state.name !== name)
-            throw new Error(`Conversation ${key} belongs to ${state.name}, not ${name}`);
-        if (state.status !== "active")
-            return state;
-        const flow = new ConversationFlow(ctx, state);
-        const step = steps[state.step];
-        if (!step)
-            state.status = "completed";
-        else {
-            await step(flow);
-            if (state.step >= steps.length)
-                state.status = "completed";
-        }
-        state.updatedAt = Date.now();
-        await this.storage.set(key, state);
-        this.active.set(key, state);
-        return state;
-    }
-}
-exports.ConversationManager = ConversationManager;
-class Wizard {
-    stepsList = [];
-    defaultManager;
-    constructor(manager) {
-        this.defaultManager = manager ?? new ConversationManager();
-    }
-    step(step) { this.stepsList.push(step); return this; }
-    /**
-     * Runs the active step for a conversation key. The default manager belongs to
-     * this Wizard instance and is intentionally reused across updates; passing a
-     * manager is useful when the application owns persistent storage explicitly.
-     */
-    async run(ctx, key = conversationKeyFromContext(ctx), manager) {
-        return (manager ?? this.defaultManager).run(ctx, key, "wizard", this.stepsList.map((step) => step.run));
-    }
-    get steps() { return this.stepsList; }
-    get manager() { return this.defaultManager; }
-}
-exports.Wizard = Wizard;

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

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validators = exports.Form = void 0;
-class Form {
-    fields = new Map();
-    field(definition) { this.fields.set(definition.name, definition); return this; }
-    async parse(input) {
-        const issues = [];
-        const values = {};
-        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
-                    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: values };
-    }
-    reset() { }
-}
-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

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MenuController = 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, labels = {}) {
-    const buttons = [];
-    if (page.hasPrevious)
-        buttons.push({ text: labels.previous ?? "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: labels.next ?? "Next", callback_data: `${prefix}:page:${page.page + 1}` });
-    return buttons;
-}
-class Menu {
-    id;
-    itemsList = [];
-    parents = [];
-    constructor(id) {
-        this.id = id;
-    }
-    item(item) {
-        if (!item.id || !item.label)
-            throw new Error("Menu item id and label are required.");
-        if (item.url !== undefined && item.callbackData !== undefined)
-            throw new Error("A menu item cannot have both url and callbackData.");
-        this.itemsList.push(item);
-        return this;
-    }
-    breadcrumb(label) { if (label)
-        this.parents.push(label); return this; }
-    get items() { return this.itemsList; }
-    get breadcrumbs() { return this.parents; }
-    async visibleItems(context = {}) {
-        const permissions = context.permissions ? new Set(context.permissions) : undefined;
-        const result = [];
-        for (const item of this.itemsList) {
-            const visible = typeof item.visible === "function" ? await item.visible(context, item) : item.visible ?? true;
-            if (!visible)
-                continue;
-            const allowed = typeof item.permission === "function"
-                ? await item.permission(context, item)
-                : item.permission === undefined
-                    ? true
-                    : permissions?.has(item.permission) ?? false;
-            if (allowed)
-                result.push(item);
-        }
-        return result;
-    }
-    async build(context = {}, options = {}) {
-        const columns = options.columns ?? 1;
-        if (!Number.isInteger(columns) || columns < 1)
-            throw new RangeError("columns must be a positive integer");
-        const keyboard = new index_js_1.InlineKeyboard();
-        if (options.includeBreadcrumbs && this.parents.length)
-            keyboard.text(this.parents.join(" / "), `${this.id}:breadcrumb`);
-        const buttons = (await this.visibleItems(context)).map((item) => item.url
-            ? { text: item.label, url: item.url }
-            : { text: item.label, callback_data: item.callbackData ?? `${this.id}:${item.id}` });
-        keyboard.grid(buttons, columns);
-        return keyboard;
-    }
-}
-exports.Menu = Menu;
-class MenuController {
-    currentPage = 0;
-    options;
-    constructor(options) {
-        if (!options.id || !options.id.trim())
-            throw new Error("MenuController id is required.");
-        if (!Number.isInteger(options.pageSize) || options.pageSize < 1)
-            throw new RangeError("pageSize must be a positive integer");
-        this.options = options;
-    }
-    get page() { return this.currentPage; }
-    async allItems() { return typeof this.options.items === "function" ? await this.options.items() : this.options.items; }
-    async render(context = this.options.context ?? {}) {
-        const items = await this.allItems();
-        const page = paginate(items, this.currentPage, this.options.pageSize);
-        this.currentPage = page.page;
-        const keyboard = new index_js_1.InlineKeyboard();
-        for (let index = 0; index < page.items.length; index += 1) {
-            const absoluteIndex = page.page * this.options.pageSize + index;
-            keyboard.text(this.options.label(page.items[index], absoluteIndex), `${this.options.id}:select:${absoluteIndex}`);
-        }
-        const navigation = paginationButtons(page, this.options.id, this.options.labels);
-        if (navigation.length)
-            keyboard.row(...navigation);
-        void context;
-        return keyboard.build();
-    }
-    async handle(data, context = this.options.context ?? {}) {
-        const prefix = `${this.options.id}:`;
-        if (!data.startsWith(prefix))
-            return undefined;
-        const action = data.slice(prefix.length);
-        if (action === "noop" || action === "breadcrumb")
-            return { type: "noop" };
-        if (action.startsWith("page:")) {
-            const page = Number(action.slice("page:".length));
-            if (!Number.isInteger(page) || page < 0)
-                return undefined;
-            this.currentPage = page;
-            const items = await this.allItems();
-            const pageData = paginate(items, this.currentPage, this.options.pageSize);
-            this.currentPage = pageData.page;
-            return { type: "page", page: pageData, keyboard: await this.render(context) };
-        }
-        if (action.startsWith("select:")) {
-            const index = Number(action.slice("select:".length));
-            const items = await this.allItems();
-            const item = items[index];
-            if (item === undefined || !Number.isInteger(index) || index < 0)
-                return undefined;
-            await this.options.callback?.(item, context);
-            return { type: "select", item, index };
-        }
-        return undefined;
-    }
-}
-exports.MenuController = MenuController;