@monixlite/grammy-scenes 1.0.0

package/README.md

@@ -0,0 +1,127 @@
+# @monixlite/grammy-scenes
+
+Scene middleware for grammY with step-based navigation.
+
+## Installation
+
+```bash
+npm install @monixlite/grammy-scenes
+```
+
+## Requirements
+
+* Node.js >= 16
+* grammY >= 1.19
+
+## Basic Usage
+
+```js
+const { Bot, session } = require("grammy");
+const { Scenes } = require("@monixlite/grammy-scenes");
+
+
+const bot = new Bot(""); {
+    bot.use(session({
+        initial: () => ({
+            scene: null,
+            step: null,
+            name: null,
+            age: null,
+        }),
+    }));
+};
+
+
+const scene = new Scenes([
+    [
+        {
+            scene: {
+                title: "auth",
+                step: "phone",
+            },
+
+            callbacks: {
+                enter: async (ctx) => {
+                    await ctx.reply("Введите номер:");
+                },
+
+                message: async (ctx) => {
+                    await ctx.reply(`Номер: ${ctx.message.text.trim()}`);
+
+                    return "stop";
+                },
+            },
+        },
+    ],
+]);
+
+
+bot.command("start", async (ctx) => {
+    await scene.enter(ctx, {
+        title: "auth",
+        step: "phone",
+    });
+});
+
+
+bot.use(scene.middleware);
+
+bot.start();
+```
+
+## Scene Definition
+
+Каждый шаг сцены описывается объектом:
+
+```js
+{
+    scene: {
+        title: string,
+        step: string,
+    },
+
+    callbacks: {
+        enter?: (ctx) => Promise<void>,
+        message?: (ctx) => Promise<"next" | "stop" | void>,
+    },
+}
+```
+
+### callbacks.enter
+
+Вызывается при входе в шаг сцены.
+
+### callbacks.message
+
+Вызывается при получении сообщения пользователя.
+Возврат `"stop"` завершает сцену.
+
+## Scene Control
+
+### Enter scene
+
+```js
+await scenes.enter(ctx, {
+    title: "auth",
+    step: "phone",
+});
+```
+
+### Cancel scene manually
+
+```js
+ctx.session.scene = null;
+```
+
+## Middleware
+
+Middleware должен быть подключён **после** session middleware:
+
+```js
+bot.use(session(...));
+bot.use(scenes.middleware);
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@monixlite/grammy-scenes",
+    "version": "1.0.0",
+    "description": "Scene middleware for grammY with step-based navigation",
+    "main": "src/index.js",
+    "type": "commonjs",
+    "keywords": [
+        "grammy",
+        "telegram",
+        "bot",
+        "scenes",
+        "middleware",
+        "monixlite"
+    ],
+    "author": "monixlite",
+    "license": "MIT",
+    "peerDependencies": {
+        "grammy": "^1.0.0"
+    }
+}

package/src/index.js

@@ -0,0 +1,199 @@
+class ScenesMiddleware {
+    constructor({ scenes }) {
+        this.scenes = scenes;
+
+
+        this.steps = {}; {
+            for (const group of scenes) {
+                for (const item of group) {
+                    const { title, step } = item.scene;
+
+
+                    if (!this.steps[title]) {
+                        this.steps[title] = [];
+                    };
+
+
+                    this.steps[title].push(step);
+                };
+            };
+        };
+    };
+
+
+    scene = (scene) => {
+        return this.scenes.flat().find((x) => (x.scene.title == scene?.title && x.scene.step == scene?.step));
+    };
+
+    step = (scene, dir) => {
+        const list = this.steps[scene?.title]; {
+            if (!list) return null;
+        };
+
+
+        const index = list.indexOf(scene?.step); {
+            if (index == -1) return null;
+        };
+
+
+        if (dir == "next") return (list[(index + 1)] ?? null);
+        if (dir == "prev") return (list[(index - 1)] ?? null);
+
+
+        return null;
+    };
+
+
+    enter = async (ctx, scene) => {
+        ctx.session.scene = scene;
+
+
+        const current = this.scene(scene); {
+            if (!current?.callbacks?.enter) return;
+        };
+
+
+        const original = ctx.reply.bind(ctx); {
+            ctx.reply = (text, extra = {}) => {
+                return original(text, {
+                    ...extra,
+                    reply_markup: {
+                        inline_keyboard: [
+                            ...(extra.reply_markup?.inline_keyboard || []),
+                            [
+                                {
+                                    text: "Отменить",
+                                    callback_data: "scene:cancel",
+                                },
+                            ],
+                        ],
+                    },
+                });
+            };
+        };
+
+
+        await current.callbacks.enter(ctx);
+        ctx.reply = original;
+    };
+
+    handle = async (ctx, scene, result) => {
+        if (result?.exit || (["!", "exit", "stop"]).includes(result)) {
+            ctx.session.scene = null;
+            return;
+        };
+
+
+        if (result?.prev || (["<", "prev"]).includes(result)) {
+            const step = this.step({
+                title: scene.title,
+                step: scene.step,
+            }, "prev");
+
+
+            return await this.enter(ctx, {
+                title: scene.title,
+                step: step,
+            });
+        };
+
+        if (!result || result?.next || ([">", "next"]).includes(result)) {
+            const step = this.step({
+                title: scene.title,
+                step: scene.step,
+            }, "next");
+
+
+            return await this.enter(ctx, {
+                title: scene.title,
+                step: step,
+            });
+        };
+
+
+        if (result?.scene) return await this.enter(ctx, {
+            title: result.scene.title,
+            step: result.scene.step,
+        });
+
+        if (result?.step) return await this.enter(ctx, {
+            title: scene.title,
+            step: result.step,
+        });
+
+
+        const transition = String(result).match(/^\^(.*)$/); {
+            if (!transition || !transition?.[1]) {
+                ctx.session.scene = null;
+                return;
+            };
+
+
+            const parts = transition[1].split(":"); {
+                if (parts.length == 1) return await this.enter(ctx, {
+                    title: scene.title,
+                    step: parts[0],
+                });
+            };
+
+
+            return await this.enter(ctx, {
+                title: parts[0],
+                step: parts[1],
+            });
+        };
+    };
+
+
+    middleware = async (ctx, next) => {
+        const { scene } = ctx.session; {
+            if (!scene?.title || !scene?.step) return next();
+        };
+
+
+        const current = this.scene(scene); {
+            if (!current?.callbacks) return next();
+        };
+
+
+        if (ctx.message && current.callbacks.message) {
+            const result = await current.callbacks.message(ctx);
+
+            return await this.handle(ctx, scene, result);
+        };
+
+
+        if (ctx.callbackQuery && current.callbacks.query) {
+            const data = ctx.callbackQuery.data;
+
+
+            for (const q of current.callbacks.query) {
+                if (q.match.test(data)) {
+                    const result = await q.handler(ctx);
+
+                    return await this.handle(ctx, scene, result);
+                };
+            };
+        };
+
+
+        return next();
+    };
+};
+
+
+class Scenes {
+    constructor(scenes) {
+        this.instance = new ScenesMiddleware({
+            scenes: scenes,
+        });
+
+
+        this.middleware = this.instance.middleware;
+        this.enter = this.instance.enter.bind(this.instance);
+    };
+};
+
+module.exports = {
+    Scenes,
+};