teledzik 1.0.0

package/lib/core/helpers/ai-stream.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIStreamAdapter = void 0;
+/**
+ * AI Live Stream Adapter for Telegram Bots.
+ * Throttles live token stream edits to prevent Telegram rate limit bans.
+ */
+class AIStreamAdapter {
+    constructor(ctx, options = {}) {
+        this.buffer = '';
+        this.lastUpdate = 0;
+        this.timer = null;
+        this.ctx = ctx;
+        this.options = options;
+        this.minInterval = options.minUpdateIntervalMs ?? 800;
+    }
+    /**
+     * Append new token chunk from LLM stream.
+     */
+    async push(chunk) {
+        this.buffer += chunk;
+        await this.scheduleUpdate();
+    }
+    /**
+     * Finalize the stream and send the full final content.
+     */
+    async end(finalContent) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (finalContent !== undefined) {
+            this.buffer = finalContent;
+        }
+        return this.flush(true);
+    }
+    async scheduleUpdate() {
+        const now = Date.now();
+        const elapsed = now - this.lastUpdate;
+        if (elapsed >= this.minInterval) {
+            await this.flush();
+        }
+        else if (!this.timer) {
+            this.timer = setTimeout(async () => {
+                this.timer = null;
+                await this.flush();
+            }, this.minInterval - elapsed);
+        }
+    }
+    async flush(isFinal = false) {
+        if (!this.buffer)
+            return;
+        this.lastUpdate = Date.now();
+        if (this.options.useDraft && this.options.draftId) {
+            const richMsg = { html: `<p>${this.buffer}${isFinal ? '' : ' ▍'}</p>` };
+            return this.ctx.sendRichMessageDraft(this.options.draftId, richMsg);
+        }
+        const text = `${this.buffer}${isFinal ? '' : ' ▍'}`;
+        if (!this.sentMessageId) {
+            const sent = await this.ctx.reply(text, { parse_mode: 'HTML' });
+            this.sentMessageId = sent.message_id;
+            return sent;
+        }
+        else {
+            return this.ctx.telegram.editMessageText(this.ctx.chat?.id, this.sentMessageId, undefined, text, { parse_mode: 'HTML' });
+        }
+    }
+}
+exports.AIStreamAdapter = AIStreamAdapter;

package/lib/core/helpers/args.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argsParser = void 0;
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = '"';
+function argsParser(str, entities = [], entityOffset = 0) {
+    const mentions = {};
+    for (const entity of entities) // extract all text_mentions into an { offset: length } map
+        if (entity.type === 'text_mention' || entity.type === 'text_link')
+            mentions[entity.offset - entityOffset] = entity.length;
+    const args = [];
+    let done = 0;
+    let inside = undefined;
+    let buf = '';
+    function flush(to) {
+        if (done !== to)
+            args.push(buf + str.slice(done, to)), (inside = undefined);
+        buf = '';
+        done = to + 1;
+    }
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        // quick lookup length of mention starting at i
+        const mention = mentions[i];
+        if (mention) {
+            // if we're inside a quote, eagerly flush existing state
+            flush(i);
+            // this also consumes current index, so decrement
+            done--;
+            // fast forward to end of mention
+            i += mention;
+            flush(i);
+        }
+        else if (char === SINGLE_QUOTE || char === DOUBLE_QUOTE)
+            if (inside)
+                if (inside === char)
+                    flush(i);
+                else
+                    continue;
+            else
+                flush(i), (inside = char);
+        else if (char === ' ')
+            if (inside)
+                continue;
+            else
+                flush(i);
+        else if (char === '\n')
+            flush(i);
+        else if (char === '\\')
+            (buf += str.slice(done, i)), (done = ++i); // skip parsing the next char
+        else
+            continue;
+    }
+    if (done < str.length)
+        flush(str.length);
+    return args;
+}
+exports.argsParser = argsParser;

package/lib/core/helpers/check.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.is2D = exports.hasPropType = exports.hasProp = void 0;
+/**
+ * Checks if a given object has a property with a given name.
+ *
+ * Example invocation:
+ * ```js
+ * let obj = { 'foo': 'bar', 'baz': () => {} }
+ * hasProp(obj, 'foo') // true
+ * hasProp(obj, 'baz') // true
+ * hasProp(obj, 'abc') // false
+ * ```
+ *
+ * @param obj An object to test
+ * @param prop The name of the property
+ */
+function hasProp(obj, prop) {
+    return obj !== undefined && prop in obj;
+}
+exports.hasProp = hasProp;
+/**
+ * Checks if a given object has a property with a given name.
+ * Furthermore performs a `typeof` check on the property if it exists.
+ *
+ * Example invocation:
+ * ```js
+ * let obj = { 'foo': 'bar', 'baz': () => {} }
+ * hasPropType(obj, 'foo', 'string') // true
+ * hasPropType(obj, 'baz', 'function') // true
+ * hasPropType(obj, 'abc', 'number') // false
+ * ```
+ *
+ * @param obj An object to test
+ * @param prop The name of the property
+ * @param type The type the property is expected to have
+ */
+function hasPropType(obj, prop, type) {
+    return hasProp(obj, prop) && type === typeof obj[prop];
+}
+exports.hasPropType = hasPropType;
+/**
+ * Checks if the supplied array has two dimensions or not.
+ *
+ * Example invocations:
+ * is2D([]) // false
+ * is2D([[]]) // true
+ * is2D([[], []]) // true
+ * is2D([42]) // false
+ *
+ * @param arr an array with one or two dimensions
+ */
+function is2D(arr) {
+    return Array.isArray(arr[0]);
+}
+exports.is2D = is2D;

package/lib/core/helpers/compact.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactOptions = void 0;
+function compactOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const compacted = {};
+    for (const key in options)
+        if (
+        // todo(mkr): replace with Object.hasOwn in v5 (Node 16+)
+        Object.prototype.hasOwnProperty.call(options, key) &&
+            options[key] !== undefined)
+            compacted[key] = options[key];
+    return compacted;
+}
+exports.compactOptions = compactOptions;

package/lib/core/helpers/deunionize.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deunionize = void 0;
+/**
+ * Expose properties from all union variants.
+ * @deprectated
+ * @see https://github.com/telegraf/telegraf/issues/1388#issuecomment-791573609
+ * @see https://millsp.github.io/ts-toolbelt/modules/union_strict.html
+ */
+function deunionize(t) {
+    return t;
+}
+exports.deunionize = deunionize;

package/lib/core/helpers/formatting.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkOrMention = exports.createFmt = exports.join = exports.FmtString = void 0;
+const util_1 = require("./util");
+class FmtString {
+    constructor(text, entities) {
+        this.text = text;
+        if (entities) {
+            this.entities = entities;
+            // force parse_mode to undefined if entities are present
+            this.parse_mode = undefined;
+        }
+    }
+    static normalise(content) {
+        if (content instanceof FmtString)
+            return content;
+        return new FmtString(String(content));
+    }
+}
+exports.FmtString = FmtString;
+const isArray = Array.isArray;
+/** Given a base FmtString and something to append to it, mutates the base */
+const _add = (base, next) => {
+    const len = base.text.length;
+    if (next instanceof FmtString) {
+        base.text = `${base.text}${next.text}`;
+        // next.entities could be undefined and condition will fail
+        for (let i = 0; i < (next.entities?.length || 0); i++) {
+            // because of the above condition, next.entities[i] cannot be undefined
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const entity = next.entities[i];
+            // base.entities is ensured by caller
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            base.entities.push({ ...entity, offset: entity.offset + len });
+        }
+    }
+    else
+        base.text = `${base.text}${next}`;
+};
+/**
+ * Given an `Iterable<FmtString | string | Any>` and a separator, flattens the list into a single FmtString.
+ * Analogous to Array#join -> string, but for FmtString
+ */
+const join = (fragments, separator) => {
+    const result = new FmtString('');
+    // ensure entities array so loop doesn't need to check
+    result.entities = [];
+    const iter = fragments[Symbol.iterator]();
+    let curr = iter.next();
+    while (!curr.done) {
+        _add(result, curr.value);
+        curr = iter.next();
+        if (separator && !curr.done)
+            _add(result, separator);
+    }
+    // set parse_mode: undefined if entities are present
+    if (result.entities.length)
+        result.parse_mode = undefined;
+    // remove entities array if not relevant
+    else
+        delete result.entities;
+    return result;
+};
+exports.join = join;
+/** Internal constructor for all fmt helpers */
+function createFmt(kind, opts) {
+    return function fmt(parts, ...items) {
+        parts = isArray(parts) ? parts : [parts];
+        const result = (0, exports.join)((0, util_1.zip)(parts, items));
+        if (kind) {
+            result.entities ??= [];
+            result.entities.unshift({
+                type: kind,
+                offset: 0,
+                length: result.text.length,
+                ...opts,
+            });
+            result.parse_mode = undefined;
+        }
+        return result;
+    };
+}
+exports.createFmt = createFmt;
+const linkOrMention = (content, data) => {
+    const { text, entities = [] } = FmtString.normalise(content);
+    entities.unshift(Object.assign(data, { offset: 0, length: text.length }));
+    return new FmtString(text, entities);
+};
+exports.linkOrMention = linkOrMention;

package/lib/core/helpers/input-box.js

@@ -0,0 +1,87 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputBox = void 0;
+const Markup = __importStar(require("../../markup"));
+/**
+ * Interactive In-Chat Form Box Card for Telegram Messages.
+ * Render boxed form cards with dynamic real-time field updates.
+ */
+class InputBox {
+    constructor(id) {
+        this.title = '📋 FORM INPUT';
+        this.fields = [];
+        this.id = id;
+    }
+    setTitle(title) {
+        this.title = title;
+        return this;
+    }
+    addField(key, label, options = {}) {
+        this.fields.push({ key, label, ...options });
+        return this;
+    }
+    onComplete(handler) {
+        this.completionHandler = handler;
+        return this;
+    }
+    /**
+     * Render formatted HTML box card text.
+     */
+    renderText(data = {}) {
+        const lines = [];
+        lines.push(`<b>┌─ ${this.title.toUpperCase()} ─┐</b>`);
+        this.fields.forEach((field, idx) => {
+            const val = data[field.key] ? `<b>${data[field.key]}</b>` : `<i>[ ${field.placeholder ?? 'Belum diisi'} ]</i>`;
+            lines.push(`│ ${idx + 1}. <b>${field.label}</b>: ${val}`);
+        });
+        const isComplete = this.fields.every((f) => Boolean(data[f.key]));
+        lines.push(`<b>└${'─'.repeat(30)}┘</b>`);
+        lines.push(isComplete ? '<b>Status:</b> ✅ <i>Lengkap (Siap Dikirim)</i>' : '<b>Status:</b> ⌛ <i>Menunggu Pengisian...</i>');
+        return lines.join('\n');
+    }
+    /**
+     * Render inline keyboard with field edit buttons and submit action.
+     */
+    renderKeyboard(data = {}) {
+        const buttons = [];
+        // Field buttons
+        this.fields.forEach((field) => {
+            const filled = Boolean(data[field.key]);
+            const icon = filled ? '✅' : '✏️';
+            buttons.push([Markup.button.callback(`${icon} ${field.label}`, `inputbox:${this.id}:edit:${field.key}`)]);
+        });
+        // Action row
+        const isComplete = this.fields.every((f) => Boolean(data[f.key]));
+        if (isComplete) {
+            buttons.push([
+                Markup.button.callback('🚀 Submit Form', `inputbox:${this.id}:submit`),
+                Markup.button.callback('🔄 Reset', `inputbox:${this.id}:reset`),
+            ]);
+        }
+        return Markup.inlineKeyboard(buttons);
+    }
+}
+exports.InputBox = InputBox;

package/lib/core/helpers/rich-sanitizer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeRichHtml = void 0;
+/**
+ * Converts Rich HTML strings containing tags like <h1>, <h2>, <p>, <hr>
+ * into standard Telegram HTML compatible with parse_mode: 'HTML' (editMessageText/sendMessage).
+ */
+function sanitizeRichHtml(html) {
+    if (!html)
+        return html;
+    let result = html;
+    // Convert H1: <h1>Text</h1> -> <b>TEXT</b>
+    result = result.replace(/<h1[^>]*>(.*?)<\/h1>/gis, (_, content) => `<b>${content.trim().toUpperCase()}</b>\n\n`);
+    // Convert H2..H6: <h2>Text</h2> -> <b>Text</b>
+    result = result.replace(/<h[2-6][^>]*>(.*?)<\/h[2-6]>/gis, (_, content) => `<b>${content.trim()}</b>\n\n`);
+    // Convert Paragraphs: <p>Text</p> -> Text\n\n
+    result = result.replace(/<p[^>]*>(.*?)<\/p>/gis, (_, content) => `${content.trim()}\n\n`);
+    // Convert Footer: <footer>Text</footer> -> <i>Text</i>
+    result = result.replace(/<footer[^>]*>(.*?)<\/footer>/gis, (_, content) => `<i>${content.trim()}</i>\n`);
+    // Convert Horizontal Rules: <hr/> or <hr> -> ──────────
+    result = result.replace(/<hr\s*\/?>/gi, '──────────\n');
+    // Convert Marks: <mark>Text</mark> -> <b>[Text]</b>
+    result = result.replace(/<mark[^>]*>(.*?)<\/mark>/gis, (_, content) => `<b>[${content.trim()}]</b>`);
+    // Strip unsupported sub/sup tags but keep text
+    result = result.replace(/<sub[^>]*>(.*?)<\/sub>/gis, '$1');
+    result = result.replace(/<sup[^>]*>(.*?)<\/sup>/gis, '$1');
+    // Trim extra trailing newlines (> 2 consecutive newlines)
+    result = result.replace(/\n{3,}/g, '\n\n');
+    return result.trim();
+}
+exports.sanitizeRichHtml = sanitizeRichHtml;

package/lib/core/helpers/smart-queue.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartQueue = void 0;
+/**
+ * Smart Queue & Rate-Limit Manager for Telegram Bot API calls.
+ * Prevents 429 Too Many Requests by enforcing min delay between calls per target key (e.g. chatId).
+ */
+class SmartQueue {
+    constructor(options = {}) {
+        this.queues = new Map();
+        this.processing = new Set();
+        this.minDelayMs = options.minDelayMs ?? 50;
+    }
+    static getInstance() {
+        if (!SmartQueue.instance) {
+            SmartQueue.instance = new SmartQueue();
+        }
+        return SmartQueue.instance;
+    }
+    enqueue(key, task, options) {
+        return new Promise((resolve, reject) => {
+            if (!this.queues.has(key)) {
+                this.queues.set(key, []);
+            }
+            this.queues.get(key).push({
+                task,
+                resolve,
+                reject,
+                retries: 0,
+            });
+            this.processQueue(key, options);
+        });
+    }
+    async processQueue(key, options) {
+        if (this.processing.has(key))
+            return;
+        this.processing.add(key);
+        const queue = this.queues.get(key);
+        const maxRetries = options?.maxRetries ?? 3;
+        const minDelay = options?.minDelayMs ?? this.minDelayMs;
+        while (queue && queue.length > 0) {
+            const item = queue[0];
+            try {
+                const result = await item.task();
+                queue.shift();
+                item.resolve(result);
+            }
+            catch (err) {
+                // Handle Telegram 429 Too Many Requests (retry_after)
+                const retryAfter = err?.parameters?.retry_after ?? err?.response?.parameters?.retry_after;
+                if (retryAfter && item.retries < maxRetries) {
+                    item.retries++;
+                    const waitTime = (retryAfter + 0.5) * 1000;
+                    await new Promise((res) => setTimeout(res, waitTime));
+                    continue;
+                }
+                queue.shift();
+                item.reject(err);
+            }
+            if (queue.length > 0) {
+                await new Promise((res) => setTimeout(res, minDelay));
+            }
+        }
+        this.processing.delete(key);
+        if (queue && queue.length === 0) {
+            this.queues.delete(key);
+        }
+    }
+}
+exports.SmartQueue = SmartQueue;

package/lib/core/helpers/util.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexed = exports.zip = exports.fmtCaption = exports.env = void 0;
+exports.env = process.env;
+function fmtCaption(extra) {
+    if (!extra)
+        return;
+    const caption = extra.caption;
+    if (!caption || typeof caption === 'string')
+        return extra;
+    const { text, entities } = caption;
+    return {
+        ...extra,
+        caption: text,
+        ...(entities && {
+            caption_entities: entities,
+            parse_mode: undefined,
+        }),
+    };
+}
+exports.fmtCaption = fmtCaption;
+function* zip(xs, ys) {
+    const x = xs[Symbol.iterator]();
+    const y = ys[Symbol.iterator]();
+    let x1 = x.next();
+    let y1 = y.next();
+    while (!x1.done) {
+        yield x1.value;
+        if (!y1.done)
+            yield y1.value;
+        x1 = x.next();
+        y1 = y.next();
+    }
+    while (!y1.done) {
+        yield y1.value;
+        y1 = y.next();
+    }
+}
+exports.zip = zip;
+function indexed(target, indexer) {
+    return new Proxy(target, {
+        get: function (target, prop, receiver) {
+            if ((typeof prop === 'string' || typeof prop === 'number') &&
+                !isNaN(+prop))
+                return indexer.call(target, +prop);
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+exports.indexed = indexed;