teledzik 1.0.0

package/lib/input.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromFileId = exports.fromURL = exports.fromURLStream = exports.fromReadableStream = exports.fromBuffer = exports.fromLocalFile = void 0;
+/**
+ * The local file specified by path will be uploaded to Telegram using multipart/form-data.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+const fromLocalFile = (path, filename) => ({ source: path, filename });
+exports.fromLocalFile = fromLocalFile;
+/**
+ * The buffer will be uploaded as file to Telegram using multipart/form-data.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+const fromBuffer = (buffer, filename) => ({ source: buffer, filename });
+exports.fromBuffer = fromBuffer;
+/**
+ * Contents of the stream will be uploaded as file to Telegram using multipart/form-data.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+const fromReadableStream = (stream, filename) => ({ source: stream, filename });
+exports.fromReadableStream = fromReadableStream;
+/**
+ * Contents of the URL will be streamed to Telegram.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+const fromURLStream = (url, filename) => ({ url: url.toString(), filename });
+exports.fromURLStream = fromURLStream;
+/**
+ * Provide Telegram with an HTTP URL for the file to be sent.
+ * Telegram will download and send the file.
+ *
+ * * The target file must have the correct MIME type (e.g., audio/mpeg for `sendAudio`, etc.).
+ * * `sendDocument` with URL will currently only work for GIF, PDF and ZIP files.
+ * * To use `sendVoice`, the file must have the type audio/ogg and be no more than 1MB in size.
+ * 1-20MB voice notes will be sent as files.
+ *
+ * 5 MB max size for photos and 20 MB max for other types of content.
+ */
+const fromURL = (url) => url.toString();
+exports.fromURL = fromURL;
+/**
+ * If the file is already stored somewhere on the Telegram servers, you don't need to reupload it:
+ * each file object has a file_id field, simply pass this file_id as a parameter instead of uploading.
+ *
+ * It is not possible to change the file type when resending by file_id.
+ *
+ * It is not possible to resend thumbnails using file_id.
+ * They have to be uploaded using one of the other Input methods.
+ *
+ * There are no limits for files sent this way.
+ */
+const fromFileId = (fileId) => fileId;
+exports.fromFileId = fromFileId;

package/lib/markup.js

@@ -0,0 +1,111 @@
+"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.inlineKeyboard = exports.keyboard = exports.forceReply = exports.removeKeyboard = exports.button = exports.Markup = void 0;
+const check_1 = require("./core/helpers/check");
+class Markup {
+    constructor(reply_markup) {
+        this.reply_markup = reply_markup;
+    }
+    selective(value = true) {
+        return new Markup({ ...this.reply_markup, selective: value });
+    }
+    placeholder(placeholder) {
+        return new Markup({
+            ...this.reply_markup,
+            input_field_placeholder: placeholder,
+        });
+    }
+    resize(value = true) {
+        return new Markup({
+            ...this.reply_markup,
+            resize_keyboard: value,
+        });
+    }
+    oneTime(value = true) {
+        return new Markup({
+            ...this.reply_markup,
+            one_time_keyboard: value,
+        });
+    }
+    persistent(value = true) {
+        return new Markup({
+            ...this.reply_markup,
+            is_persistent: value,
+        });
+    }
+}
+exports.Markup = Markup;
+exports.button = __importStar(require("./button"));
+function removeKeyboard() {
+    return new Markup({ remove_keyboard: true });
+}
+exports.removeKeyboard = removeKeyboard;
+function forceReply() {
+    return new Markup({ force_reply: true });
+}
+exports.forceReply = forceReply;
+function keyboard(buttons, options) {
+    const keyboard = buildKeyboard(buttons, {
+        columns: 1,
+        ...options,
+    });
+    return new Markup({ keyboard });
+}
+exports.keyboard = keyboard;
+function inlineKeyboard(buttons, options) {
+    const inlineKeyboard = buildKeyboard(buttons, {
+        columns: buttons.length,
+        ...options,
+    });
+    return new Markup({ inline_keyboard: inlineKeyboard });
+}
+exports.inlineKeyboard = inlineKeyboard;
+function buildKeyboard(buttons, options) {
+    const result = [];
+    if (!Array.isArray(buttons)) {
+        return result;
+    }
+    if ((0, check_1.is2D)(buttons)) {
+        return buttons.map((row) => row.filter((button) => !button.hide));
+    }
+    const wrapFn = options.wrap !== undefined
+        ? options.wrap
+        : (_btn, _index, currentRow) => currentRow.length >= options.columns;
+    let currentRow = [];
+    let index = 0;
+    for (const btn of buttons.filter((button) => !button.hide)) {
+        if (wrapFn(btn, index, currentRow) && currentRow.length > 0) {
+            result.push(currentRow);
+            currentRow = [];
+        }
+        currentRow.push(btn);
+        index++;
+    }
+    if (currentRow.length > 0) {
+        result.push(currentRow);
+    }
+    return result;
+}

package/lib/middleware.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/paginated.js

@@ -0,0 +1,76 @@
+"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.PaginatedBuilder = void 0;
+const Markup = __importStar(require("./markup"));
+class PaginatedBuilder {
+    static create(items, options = {}) {
+        const page = options.page ?? 1;
+        const pageSize = options.pageSize ?? 5;
+        const prefix = options.callbackPrefix ?? 'page';
+        const totalItems = items.length;
+        const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+        const currentPage = Math.min(Math.max(1, page), totalPages);
+        const startIndex = (currentPage - 1) * pageSize;
+        const pageItems = items.slice(startIndex, startIndex + pageSize);
+        let text = '';
+        if (options.formatItem) {
+            text = pageItems.map((item, idx) => options.formatItem(item, startIndex + idx)).join('\n');
+            text += `\n\n<i>Halaman ${currentPage}/${totalPages} (Total: ${totalItems})</i>`;
+        }
+        const buttons = [];
+        // Item buttons if defined
+        if (options.buttonText && options.buttonData) {
+            pageItems.forEach((item) => {
+                buttons.push([Markup.button.callback(options.buttonText(item), options.buttonData(item))]);
+            });
+        }
+        // Navigation row
+        const navRow = [];
+        if (currentPage > 1) {
+            navRow.push(Markup.button.callback('« Prev', `${prefix}:${currentPage - 1}`));
+        }
+        else {
+            navRow.push(Markup.button.callback('·', 'noop'));
+        }
+        navRow.push(Markup.button.callback(`${currentPage}/${totalPages}`, 'noop'));
+        if (currentPage < totalPages) {
+            navRow.push(Markup.button.callback('Next »', `${prefix}:${currentPage + 1}`));
+        }
+        else {
+            navRow.push(Markup.button.callback('·', 'noop'));
+        }
+        buttons.push(navRow);
+        return {
+            items: pageItems,
+            page: currentPage,
+            totalPages,
+            totalItems,
+            text,
+            keyboard: Markup.inlineKeyboard(buttons),
+        };
+    }
+}
+exports.PaginatedBuilder = PaginatedBuilder;

package/lib/reactions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageReactions = exports.ReactionList = exports.Digit = void 0;
+const util_1 = require("./core/helpers/util");
+exports.Digit = new Set(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']);
+const inspectReaction = (reaction) => {
+    if (reaction.type === 'custom_emoji')
+        return `Custom(${reaction.custom_emoji_id})`;
+    else
+        return reaction.emoji;
+};
+class ReactionList {
+    constructor(list) {
+        this.list = list;
+    }
+    static fromArray(list = []) {
+        return (0, util_1.indexed)(new ReactionList(list), function (index) {
+            return this.list[index];
+        });
+    }
+    static has(reactions, reaction) {
+        if (typeof reaction === 'string')
+            if (exports.Digit.has(reaction[0]))
+                return reactions.some((r) => r.custom_emoji_id === reaction);
+            else
+                return reactions.some((r) => r.emoji === reaction);
+        return reactions.some((r) => {
+            if (r.type === 'custom_emoji')
+                return r.custom_emoji_id === reaction.custom_emoji_id;
+            else if (r.type === 'emoji')
+                return r.emoji === reaction.emoji;
+        });
+    }
+    toArray() {
+        return [...this.list];
+    }
+    filter(filterFn) {
+        return ReactionList.fromArray(this.list.filter(filterFn));
+    }
+    has(reaction) {
+        return ReactionList.has(this.list, reaction);
+    }
+    get count() {
+        return this.list.length;
+    }
+    [Symbol.iterator]() {
+        return this.list[Symbol.iterator]();
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const flattened = this.list.map(inspectReaction).join(', ');
+        return ['ReactionList {', flattened, '}'].join(' ');
+    }
+}
+exports.ReactionList = ReactionList;
+class MessageReactions extends ReactionList {
+    constructor(ctx) {
+        super(ctx.update.message_reaction?.new_reaction ?? []);
+        this.ctx = ctx;
+    }
+    static from(ctx) {
+        return (0, util_1.indexed)(new MessageReactions(ctx), function (index) {
+            return this.list[index];
+        });
+    }
+    get old() {
+        return ReactionList.fromArray(this.ctx.update.message_reaction?.old_reaction);
+    }
+    get new() {
+        return ReactionList.fromArray(this.ctx.update.message_reaction?.new_reaction);
+    }
+    get added() {
+        return this.new.filter((reaction) => !this.old.has(reaction));
+    }
+    get removed() {
+        return this.old.filter((reaction) => !this.new.has(reaction));
+    }
+    get kept() {
+        return this.new.filter((reaction) => this.old.has(reaction));
+    }
+}
+exports.MessageReactions = MessageReactions;

package/lib/router.js

@@ -0,0 +1,45 @@
+"use strict";
+/** @format */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const composer_1 = __importDefault(require("./composer"));
+/** @deprecated in favor of {@link Composer.dispatch} */
+class Router {
+    constructor(routeFn, handlers = new Map()) {
+        this.routeFn = routeFn;
+        this.handlers = handlers;
+        this.otherwiseHandler = composer_1.default.passThru();
+        if (typeof routeFn !== 'function') {
+            throw new Error('Missing routing function');
+        }
+    }
+    on(route, ...fns) {
+        if (fns.length === 0) {
+            throw new TypeError('At least one handler must be provided');
+        }
+        this.handlers.set(route, composer_1.default.compose(fns));
+        return this;
+    }
+    otherwise(...fns) {
+        if (fns.length === 0) {
+            throw new TypeError('At least one otherwise handler must be provided');
+        }
+        this.otherwiseHandler = composer_1.default.compose(fns);
+        return this;
+    }
+    middleware() {
+        return composer_1.default.lazy((ctx) => {
+            const result = this.routeFn(ctx);
+            if (result == null) {
+                return this.otherwiseHandler;
+            }
+            Object.assign(ctx, result.context);
+            Object.assign(ctx.state, result.state);
+            return this.handlers.get(result.route) ?? this.otherwiseHandler;
+        });
+    }
+}
+exports.Router = Router;

package/lib/scenes/base.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseScene = void 0;
+const composer_1 = __importDefault(require("../composer"));
+const { compose } = composer_1.default;
+class BaseScene extends composer_1.default {
+    constructor(id, options) {
+        const opts = {
+            handlers: [],
+            enterHandlers: [],
+            leaveHandlers: [],
+            ...options,
+        };
+        super(...opts.handlers);
+        this.id = id;
+        this.ttl = opts.ttl;
+        this.enterHandler = compose(opts.enterHandlers);
+        this.leaveHandler = compose(opts.leaveHandlers);
+    }
+    enter(...fns) {
+        this.enterHandler = compose([this.enterHandler, ...fns]);
+        return this;
+    }
+    leave(...fns) {
+        this.leaveHandler = compose([this.leaveHandler, ...fns]);
+        return this;
+    }
+    enterMiddleware() {
+        return this.enterHandler;
+    }
+    leaveMiddleware() {
+        return this.leaveHandler;
+    }
+}
+exports.BaseScene = BaseScene;
+exports.default = BaseScene;

package/lib/scenes/context.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const composer_1 = __importDefault(require("../composer"));
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('telegraf:scenes:context');
+const noop = () => Promise.resolve();
+const now = () => Math.floor(Date.now() / 1000);
+class SceneContextScene {
+    constructor(ctx, scenes, options) {
+        this.ctx = ctx;
+        this.scenes = scenes;
+        this.leaving = false;
+        // @ts-expect-error {} might not be assignable to D
+        const fallbackSessionDefault = {};
+        this.options = { defaultSession: fallbackSessionDefault, ...options };
+    }
+    get session() {
+        const defaultSession = Object.assign({}, this.options.defaultSession);
+        let session = this.ctx.session?.__scenes ?? defaultSession;
+        if (session.expires !== undefined && session.expires < now()) {
+            session = defaultSession;
+        }
+        if (this.ctx.session === undefined) {
+            this.ctx.session = { __scenes: session };
+        }
+        else {
+            this.ctx.session.__scenes = session;
+        }
+        return session;
+    }
+    get state() {
+        return (this.session.state ??= {});
+    }
+    set state(value) {
+        this.session.state = { ...value };
+    }
+    get current() {
+        const sceneId = this.session.current ?? this.options.default;
+        return sceneId === undefined || !this.scenes.has(sceneId)
+            ? undefined
+            : this.scenes.get(sceneId);
+    }
+    reset() {
+        if (this.ctx.session !== undefined)
+            this.ctx.session.__scenes = Object.assign({}, this.options.defaultSession);
+    }
+    async enter(sceneId, initialState = {}, silent = false) {
+        if (!this.scenes.has(sceneId)) {
+            throw new Error(`Can't find scene: ${sceneId}`);
+        }
+        if (!silent) {
+            await this.leave();
+        }
+        debug('Entering scene', sceneId, initialState, silent);
+        this.session.current = sceneId;
+        this.state = initialState;
+        const ttl = this.current?.ttl ?? this.options.ttl;
+        if (ttl !== undefined) {
+            this.session.expires = now() + ttl;
+        }
+        if (this.current === undefined || silent) {
+            return;
+        }
+        const handler = 'enterMiddleware' in this.current &&
+            typeof this.current.enterMiddleware === 'function'
+            ? this.current.enterMiddleware()
+            : this.current.middleware();
+        return await handler(this.ctx, noop);
+    }
+    reenter() {
+        return this.session.current === undefined
+            ? undefined
+            : this.enter(this.session.current, this.state);
+    }
+    async leave() {
+        if (this.leaving)
+            return;
+        debug('Leaving scene');
+        try {
+            this.leaving = true;
+            if (this.current === undefined) {
+                return;
+            }
+            const handler = 'leaveMiddleware' in this.current &&
+                typeof this.current.leaveMiddleware === 'function'
+                ? this.current.leaveMiddleware()
+                : composer_1.default.passThru();
+            await handler(this.ctx, noop);
+            return this.reset();
+        }
+        finally {
+            this.leaving = false;
+        }
+    }
+}
+exports.default = SceneContextScene;

package/lib/scenes/form-scene.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormScene = void 0;
+const composer_1 = require("../composer");
+class FormScene extends composer_1.Composer {
+    constructor(id) {
+        super();
+        this.steps = [];
+        this.id = id;
+    }
+    field(field, options) {
+        this.steps.push({ field, ...options });
+        return this;
+    }
+    onComplete(handler) {
+        this.completionHandler = handler;
+        return this;
+    }
+    getSteps() {
+        return this.steps;
+    }
+}
+exports.FormScene = FormScene;

package/lib/scenes/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @see https://github.com/telegraf/telegraf/issues/705#issuecomment-549056045
+ * @see https://www.npmjs.com/package/telegraf-stateless-question
+ * @packageDocumentation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WizardContextWizard = exports.WizardScene = exports.BaseScene = exports.SceneContextScene = exports.Stage = void 0;
+var stage_1 = require("./stage");
+Object.defineProperty(exports, "Stage", { enumerable: true, get: function () { return stage_1.Stage; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "SceneContextScene", { enumerable: true, get: function () { return __importDefault(context_1).default; } });
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseScene", { enumerable: true, get: function () { return base_1.BaseScene; } });
+var wizard_1 = require("./wizard");
+Object.defineProperty(exports, "WizardScene", { enumerable: true, get: function () { return wizard_1.WizardScene; } });
+var context_2 = require("./wizard/context");
+Object.defineProperty(exports, "WizardContextWizard", { enumerable: true, get: function () { return __importDefault(context_2).default; } });

package/lib/scenes/stage.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stage = void 0;
+const session_1 = require("../session");
+const context_1 = __importDefault(require("./context"));
+const composer_1 = require("../composer");
+class Stage extends composer_1.Composer {
+    constructor(scenes = [], options) {
+        super();
+        this.options = { ...options };
+        this.scenes = new Map();
+        scenes.forEach((scene) => this.register(scene));
+    }
+    register(...scenes) {
+        scenes.forEach((scene) => {
+            if (scene?.id == null || typeof scene.middleware !== 'function') {
+                throw new Error('telegraf: Unsupported scene');
+            }
+            this.scenes.set(scene.id, scene);
+        });
+        return this;
+    }
+    middleware() {
+        const handler = composer_1.Composer.compose([
+            (ctx, next) => {
+                const scenes = this.scenes;
+                const scene = new context_1.default(ctx, scenes, this.options);
+                ctx.scene = scene;
+                return next();
+            },
+            super.middleware(),
+            composer_1.Composer.lazy((ctx) => ctx.scene.current ?? composer_1.Composer.passThru()),
+        ]);
+        return composer_1.Composer.optional(session_1.isSessionContext, handler);
+    }
+    static enter(...args) {
+        return (ctx) => ctx.scene.enter(...args);
+    }
+    static reenter(...args) {
+        return (ctx) => ctx.scene.reenter(...args);
+    }
+    static leave(...args) {
+        return (ctx) => ctx.scene.leave(...args);
+    }
+}
+exports.Stage = Stage;

package/lib/scenes/wizard/context.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WizardContextWizard {
+    constructor(ctx, steps) {
+        this.ctx = ctx;
+        this.steps = steps;
+        this.state = ctx.scene.state;
+        this.cursor = ctx.scene.session.cursor ?? 0;
+    }
+    get step() {
+        return this.steps[this.cursor];
+    }
+    get cursor() {
+        return this.ctx.scene.session.cursor;
+    }
+    set cursor(cursor) {
+        this.ctx.scene.session.cursor = cursor;
+    }
+    selectStep(index) {
+        this.cursor = index;
+        return this;
+    }
+    next() {
+        return this.selectStep(this.cursor + 1);
+    }
+    back() {
+        return this.selectStep(this.cursor - 1);
+    }
+}
+exports.default = WizardContextWizard;