@maxhub/max-bot-api 0.2.1

package/dist/context.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const vcf_1 = __importDefault(require("vcf"));
+class Context {
+    constructor(update, api, botInfo) {
+        this.update = update;
+        this.api = api;
+        this.botInfo = botInfo;
+    }
+    has(filters) {
+        for (const filter of Array.isArray(filters) ? filters : [filters]) {
+            if (typeof filter === 'function'
+                ? filter(this.update)
+                : filter === this.update.update_type) {
+                return true;
+            }
+        }
+        return false;
+    }
+    assert(value, method) {
+        if (value === undefined) {
+            throw new TypeError(`Max: "${method}" isn't available for "${this.updateType}"`);
+        }
+    }
+    get updateType() {
+        return this.update.update_type;
+    }
+    get myId() {
+        return this.botInfo?.user_id;
+    }
+    get startPayload() {
+        return getStartPayload(this.update);
+    }
+    get chat() {
+        return getChat(this.update);
+    }
+    get chatId() {
+        return getChatId(this.update);
+    }
+    get message() {
+        return getMessage(this.update);
+    }
+    get messageId() {
+        return getMessageId(this.update);
+    }
+    get callback() {
+        return getCallback(this.update);
+    }
+    get user() {
+        return getUser(this.update);
+    }
+    get contactInfo() {
+        return (this._contactInfo ?? (this._contactInfo = getContactInfo(this.update)));
+    }
+    get location() {
+        return (this._location ?? (this._location = getLocation(this.update)));
+    }
+    get sticker() {
+        return (this._sticker ?? (this._sticker = getSticker(this.update)));
+    }
+    async reply(text, extra) {
+        this.assert(this.chatId, 'reply');
+        return this.api.sendMessageToChat(this.chatId, text, extra);
+    }
+    async getAllChats(extra) {
+        return this.api.getAllChats(extra);
+    }
+    async getChat(chatId) {
+        if (chatId !== undefined) {
+            return this.api.getChat(chatId);
+        }
+        this.assert(this.chatId, 'getChat');
+        return this.api.getChat(this.chatId);
+    }
+    async getChatByLink(link) {
+        return this.api.getChatByLink(link);
+    }
+    async editChatInfo(extra) {
+        this.assert(this.chatId, 'editChatInfo');
+        return this.api.editChatInfo(this.chatId, extra);
+    }
+    async getMessage(id) {
+        return this.api.getMessage(id);
+    }
+    async getMessages(extra) {
+        this.assert(this.chatId, 'getMessages');
+        return this.api.getMessages(this.chatId, extra);
+    }
+    async getPinnedMessage() {
+        this.assert(this.chatId, 'getPinnedMessage');
+        return this.api.getPinnedMessage(this.chatId);
+    }
+    async editMessage(extra) {
+        this.assert(this.messageId, 'editMessage');
+        return this.api.editMessage(this.messageId, extra);
+    }
+    async deleteMessage(messageId) {
+        if (messageId !== undefined) {
+            return this.api.deleteMessage(messageId);
+        }
+        this.assert(this.messageId, 'deleteMessage');
+        return this.api.deleteMessage(this.messageId);
+    }
+    async answerOnCallback(extra) {
+        this.assert(this.callback, 'answerOnCallback');
+        return this.api.answerOnCallback(this.callback.callback_id, extra);
+    }
+    async getChatMembership() {
+        this.assert(this.chatId, 'getChatMembership');
+        return this.api.getChatMembership(this.chatId);
+    }
+    async getChatAdmins() {
+        this.assert(this.chatId, 'getChatAdmins');
+        return this.api.getChatAdmins(this.chatId);
+    }
+    async addChatMembers(userIds) {
+        this.assert(this.chatId, 'addChatMembers');
+        return this.api.addChatMembers(this.chatId, userIds);
+    }
+    async getChatMembers(extra) {
+        this.assert(this.chatId, 'getChatMembers');
+        return this.api.getChatMembers(this.chatId, extra);
+    }
+    async removeChatMember(userId) {
+        this.assert(this.chatId, 'removeChatMember');
+        return this.api.removeChatMember(this.chatId, userId);
+    }
+    async pinMessage(messageId, extra) {
+        this.assert(this.chatId, 'pinMessage');
+        return this.api.pinMessage(this.chatId, messageId, extra);
+    }
+    async unpinMessage() {
+        this.assert(this.chatId, 'unpinMessage');
+        return this.api.unpinMessage(this.chatId);
+    }
+    async sendAction(action) {
+        this.assert(this.chatId, 'sendAction');
+        return this.api.sendAction(this.chatId, action);
+    }
+    async leaveChat() {
+        this.assert(this.chatId, 'leaveChat');
+        return this.api.leaveChat(this.chatId);
+    }
+}
+exports.Context = Context;
+const getChatId = (update) => {
+    if ('chat_id' in update) {
+        return update.chat_id;
+    }
+    if ('message' in update && update.message && 'recipient' in update.message) {
+        return update.message.recipient.chat_id;
+    }
+    if ('chat' in update) {
+        return update.chat.chat_id;
+    }
+    return undefined;
+};
+const getChat = (update) => {
+    if ('chat' in update) {
+        return update.chat;
+    }
+    return undefined;
+};
+const getMessage = (update) => {
+    if ('message' in update) {
+        return update.message;
+    }
+    return undefined;
+};
+const getMessageId = (update) => {
+    if ('message_id' in update) {
+        return update.message_id;
+    }
+    if ('message' in update) {
+        return update.message?.body.mid;
+    }
+    return undefined;
+};
+const getCallback = (update) => {
+    if ('callback' in update) {
+        return update.callback;
+    }
+    return undefined;
+};
+const getContactInfo = (update) => {
+    const message = getMessage(update);
+    if (!message)
+        return undefined;
+    const contact = message.body.attachments?.find((attachment) => {
+        return attachment.type === 'contact';
+    });
+    if (!contact?.payload.vcf_info)
+        return undefined;
+    // eslint-disable-next-line new-cap
+    const vcf = new vcf_1.default().parse(contact.payload.vcf_info);
+    return {
+        tel: vcf.get('tel').valueOf(),
+        fullName: vcf.get('fn').valueOf(),
+    };
+};
+const getLocation = (update) => {
+    const message = getMessage(update);
+    if (!message)
+        return undefined;
+    const location = message.body.attachments?.find((attachment) => {
+        return attachment.type === 'location';
+    });
+    if (!location)
+        return undefined;
+    return {
+        latitude: location.latitude,
+        longitude: location.longitude,
+    };
+};
+const getSticker = (update) => {
+    const message = getMessage(update);
+    if (!message)
+        return undefined;
+    const sticker = message.body.attachments?.find((attachment) => {
+        return attachment.type === 'sticker';
+    });
+    if (!sticker)
+        return undefined;
+    return {
+        width: sticker.width,
+        height: sticker.height,
+        url: sticker.payload.url,
+        code: sticker.payload.code,
+    };
+};
+const getUser = (update) => {
+    if ('user' in update) {
+        return update.user;
+    }
+    if (update.update_type === 'message_callback') {
+        return update.callback.user;
+    }
+    if (update.update_type === 'message_created') {
+        return update.message.sender || undefined;
+    }
+    return undefined;
+};
+const getStartPayload = (update) => {
+    if (update.update_type === 'bot_started') {
+        return update.payload;
+    }
+    return undefined;
+};

package/dist/core/helpers/attachments.d.ts

@@ -0,0 +1,70 @@
+import { AudioAttachmentRequest, FileAttachmentRequest, ImageAttachmentRequest, LocationAttachmentRequest, ShareAttachmentRequest, StickerAttachmentRequest, VideoAttachmentRequest } from '../network/api';
+declare class Attachment {
+    toJson(): void;
+}
+export declare class MediaAttachment extends Attachment {
+    readonly token?: string;
+    constructor({ token }: {
+        token?: string;
+    });
+    get payload(): object;
+}
+export declare class VideoAttachment extends MediaAttachment {
+    readonly type = "video";
+    toJson(): VideoAttachmentRequest;
+}
+export type ImagePhotos = {
+    [key: string]: {
+        token: string;
+    };
+};
+export declare class ImageAttachment extends MediaAttachment {
+    readonly photos?: ImagePhotos;
+    readonly url?: string;
+    constructor(options: {
+        token?: string;
+    } | {
+        photos?: ImagePhotos;
+    } | {
+        url?: string;
+    });
+    get payload(): ImageAttachmentRequest['payload'];
+    toJson(): ImageAttachmentRequest;
+}
+export declare class AudioAttachment extends MediaAttachment {
+    toJson(): AudioAttachmentRequest;
+}
+export declare class FileAttachment extends MediaAttachment {
+    toJson(): FileAttachmentRequest;
+}
+export declare class StickerAttachment extends Attachment {
+    readonly code: string;
+    constructor({ code }: {
+        code: string;
+    });
+    get payload(): StickerAttachmentRequest['payload'];
+    toJson(): StickerAttachmentRequest;
+}
+export declare class LocationAttachment extends Attachment {
+    readonly longitude: number;
+    readonly latitude: number;
+    constructor({ lon, lat }: {
+        lon: number;
+        lat: number;
+    });
+    toJson(): LocationAttachmentRequest;
+}
+export declare class ShareAttachment extends Attachment {
+    readonly url?: string;
+    readonly token?: string;
+    constructor({ url, token }?: {
+        url?: string;
+        token?: string;
+    });
+    get payload(): {
+        url: string | undefined;
+        token: string | undefined;
+    };
+    toJson(): ShareAttachmentRequest;
+}
+export {};

package/dist/core/helpers/attachments.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareAttachment = exports.LocationAttachment = exports.StickerAttachment = exports.FileAttachment = exports.AudioAttachment = exports.ImageAttachment = exports.VideoAttachment = exports.MediaAttachment = void 0;
+class Attachment {
+    toJson() {
+        throw new Error('Attachment not implemented.');
+    }
+}
+class MediaAttachment extends Attachment {
+    constructor({ token }) {
+        super();
+        this.token = token;
+    }
+    get payload() {
+        return { token: this.token };
+    }
+}
+exports.MediaAttachment = MediaAttachment;
+class VideoAttachment extends MediaAttachment {
+    constructor() {
+        super(...arguments);
+        this.type = 'video';
+    }
+    toJson() {
+        return {
+            type: this.type,
+            payload: this.payload,
+        };
+    }
+}
+exports.VideoAttachment = VideoAttachment;
+class ImageAttachment extends MediaAttachment {
+    constructor(options) {
+        super({ token: 'token' in options ? options.token : undefined });
+        if ('photos' in options) {
+            this.photos = options.photos;
+        }
+        if ('url' in options) {
+            this.url = options.url;
+        }
+    }
+    get payload() {
+        if (this.token) {
+            return { token: this.token };
+        }
+        if (this.url) {
+            return { url: this.url };
+        }
+        return { photos: this.photos };
+    }
+    toJson() {
+        return {
+            type: 'image',
+            payload: this.payload,
+        };
+    }
+}
+exports.ImageAttachment = ImageAttachment;
+class AudioAttachment extends MediaAttachment {
+    toJson() {
+        return {
+            type: 'audio',
+            payload: this.payload,
+        };
+    }
+}
+exports.AudioAttachment = AudioAttachment;
+class FileAttachment extends MediaAttachment {
+    toJson() {
+        return {
+            type: 'file',
+            payload: this.payload,
+        };
+    }
+}
+exports.FileAttachment = FileAttachment;
+class StickerAttachment extends Attachment {
+    constructor({ code }) {
+        super();
+        this.code = code;
+    }
+    get payload() {
+        return { code: this.code };
+    }
+    toJson() {
+        return {
+            type: 'sticker',
+            payload: this.payload,
+        };
+    }
+}
+exports.StickerAttachment = StickerAttachment;
+class LocationAttachment extends Attachment {
+    constructor({ lon, lat }) {
+        super();
+        this.longitude = lon;
+        this.latitude = lat;
+    }
+    toJson() {
+        return {
+            type: 'location',
+            latitude: this.latitude,
+            longitude: this.longitude,
+        };
+    }
+}
+exports.LocationAttachment = LocationAttachment;
+class ShareAttachment extends Attachment {
+    constructor({ url, token } = {}) {
+        super();
+        this.url = url;
+        this.token = token;
+    }
+    get payload() {
+        return {
+            url: this.url,
+            token: this.token,
+        };
+    }
+    toJson() {
+        return {
+            type: 'share',
+            payload: this.payload,
+        };
+    }
+}
+exports.ShareAttachment = ShareAttachment;

package/dist/core/helpers/buttons.d.ts

@@ -0,0 +1,8 @@
+import { Button, CallbackButton, ChatButton, LinkButton, RequestContactButton, RequestGeoLocationButton } from '../network/api';
+type MakeExtra<T extends Button, O extends keyof Omit<T, 'text' | 'type'> | '' = ''> = Omit<T, 'text' | 'type' | O>;
+export declare const callback: (text: string, payload: string, extra?: MakeExtra<CallbackButton, "payload">) => CallbackButton;
+export declare const link: (text: string, url: string) => LinkButton;
+export declare const requestContact: (text: string) => RequestContactButton;
+export declare const requestGeoLocation: (text: string, extra?: MakeExtra<RequestGeoLocationButton>) => RequestGeoLocationButton;
+export declare const chat: (text: string, chatTitle: string, extra?: MakeExtra<ChatButton, "chat_title">) => ChatButton;
+export {};

package/dist/core/helpers/buttons.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chat = exports.requestGeoLocation = exports.requestContact = exports.link = exports.callback = void 0;
+const callback = (text, payload, extra) => {
+    return {
+        type: 'callback', text, payload, ...extra,
+    };
+};
+exports.callback = callback;
+const link = (text, url) => {
+    return {
+        type: 'link', text, url,
+    };
+};
+exports.link = link;
+const requestContact = (text) => {
+    return {
+        type: 'request_contact', text,
+    };
+};
+exports.requestContact = requestContact;
+const requestGeoLocation = (text, extra) => {
+    return {
+        type: 'request_geo_location', text, ...extra,
+    };
+};
+exports.requestGeoLocation = requestGeoLocation;
+const chat = (text, chatTitle, extra) => {
+    return {
+        type: 'chat', text, chat_title: chatTitle, ...extra,
+    };
+};
+exports.chat = chat;

package/dist/core/helpers/keyboard.d.ts

@@ -0,0 +1,3 @@
+import { InlineKeyboardAttachmentRequest } from '../network/api';
+export declare const inlineKeyboard: (buttons: InlineKeyboardAttachmentRequest["payload"]["buttons"]) => InlineKeyboardAttachmentRequest;
+export * as button from './buttons';

package/dist/core/helpers/keyboard.js

@@ -0,0 +1,34 @@
+"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.button = exports.inlineKeyboard = void 0;
+const inlineKeyboard = (buttons) => {
+    return {
+        type: 'inline_keyboard',
+        payload: { buttons },
+    };
+};
+exports.inlineKeyboard = inlineKeyboard;
+exports.button = __importStar(require("./buttons"));

package/dist/core/helpers/types.d.ts

@@ -0,0 +1,7 @@
+export type NullableObject<T> = {
+    [K in keyof T]: T[K] | null;
+};
+export type MaybeArray<T> = T | T[];
+export type MaybePromise<T> = T | Promise<T>;
+export type Guard<X = unknown, Y extends X = X> = (x: X) => x is Y;
+export type Guarded<F> = F extends (x: any) => x is infer T ? T : never;

package/dist/core/helpers/types.js

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

package/dist/core/helpers/upload.d.ts

@@ -0,0 +1,47 @@
+import * as fs from 'fs';
+import { type Api } from '../../api';
+type FileSource = string | fs.ReadStream | Buffer;
+type DefaultOptions = {
+    timeout?: number;
+};
+type UploadFromSourceOptions = {
+    source: FileSource;
+};
+type UploadFromUrlOptions = {
+    url: string;
+};
+type UploadFromUrlOrSourceOptions = UploadFromSourceOptions | UploadFromUrlOptions;
+export type UploadImageOptions = UploadFromUrlOrSourceOptions & DefaultOptions;
+export type UploadVideoOptions = UploadFromSourceOptions & DefaultOptions;
+export type UploadFileOptions = UploadFromSourceOptions & DefaultOptions;
+export type UploadAudioOptions = UploadFromSourceOptions & DefaultOptions;
+export declare class Upload {
+    private readonly api;
+    constructor(api: Api);
+    private getStreamFromSource;
+    private upload;
+    private uploadFromStream;
+    private uploadFromBuffer;
+    image: ({ timeout, ...source }: UploadImageOptions) => Promise<{
+        photos: {
+            [key: string]: {
+                token: string;
+            };
+        };
+    } | {
+        url: string;
+    }>;
+    video: ({ source, ...options }: UploadVideoOptions) => Promise<{
+        id: number;
+        token: string;
+    }>;
+    file: ({ source, ...options }: UploadFileOptions) => Promise<{
+        id: number;
+        token: string;
+    }>;
+    audio: ({ source, ...options }: UploadAudioOptions) => Promise<{
+        id: number;
+        token: string;
+    }>;
+}
+export {};