@mtkruto/node 0.1.150 → 0.1.152

package/esm/client/3_story_manager.d.ts

@@ -0,0 +1,28 @@
+import { enums, types } from "../2_tl.js";
+import { ID, Story, Update } from "../3_types.js";
+import { InputStoryContent } from "../types/1_input_story_content.js";
+import { CreateStoryParams } from "./0_params.js";
+import { C as C_ } from "./0_types.js";
+import { FileManager } from "./1_file_manager.js";
+import { MessageManager } from "./2_message_manager.js";
+type C = C_ & {
+    fileManager: FileManager;
+    messageManager: MessageManager;
+};
+type StoryManagerUpdate = types.UpdateStory;
+export declare class StoryManager {
+    #private;
+    constructor(c: C);
+    createStory(chatId: ID, content: InputStoryContent, params?: CreateStoryParams): Promise<Story>;
+    getStories(chatId: ID, storyIds: number[]): Promise<Story[]>;
+    getStory(chatId: ID, storyId: number): Promise<Story>;
+    deleteStories(chatId: ID, storyIds: number[]): Promise<void>;
+    deleteStory(chatId: ID, storyId: number): Promise<void>;
+    addStoriesToHighlights(chatId: ID, storyIds: number[]): Promise<void>;
+    addStoryToHighlights(chatId: ID, storyId: number): Promise<void>;
+    removeStoriesFromHighlights(chatId: ID, storyIds: number[]): Promise<void>;
+    removeStoryFromHighlights(chatId: ID, storyId: number): Promise<void>;
+    static canHandleUpdate(update: enums.Update): update is StoryManagerUpdate;
+    handleUpdate(update: StoryManagerUpdate): Promise<Update | null>;
+}
+export {};

package/esm/client/3_story_manager.js

@@ -0,0 +1,143 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _StoryManager_instances, _StoryManager_c, _StoryManager_updatesToStory, _StoryManager_togglePinned;
+import { contentType } from "../0_deps.js";
+import { getRandomId, UNREACHABLE } from "../1_utilities.js";
+import { as, inputPeerToPeer, peerToChatId, types } from "../2_tl.js";
+import { constructStory, FileType, storyInteractiveAreaToTlObject, storyPrivacyToTlObject } from "../3_types.js";
+import { getFileContents, isHttpUrl } from "./0_utilities.js";
+export class StoryManager {
+    constructor(c) {
+        _StoryManager_instances.add(this);
+        _StoryManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _StoryManager_c, c, "f");
+    }
+    async createStory(chatId, content, params) {
+        let media = null;
+        const source = "video" in content ? content.video : "photo" in content ? content.photo : UNREACHABLE();
+        if (typeof source === "string") {
+            const fileId = __classPrivateFieldGet(this, _StoryManager_c, "f").messageManager.resolveFileId(source, FileType.Photo);
+            if (fileId != null) {
+                media = new types.InputMediaPhoto({
+                    id: new types.InputPhoto(fileId),
+                });
+            }
+        }
+        if (media == null) {
+            if (typeof source === "string" && isHttpUrl(source)) {
+                throw new Error("URL not supported");
+            }
+            else {
+                const [contents, fileName_] = await getFileContents(source);
+                const fileName = params?.fileName ?? fileName_;
+                const mimeType = contentType(fileName.split(".").slice(-1)[0]) ?? "application/octet-stream";
+                const file = await __classPrivateFieldGet(this, _StoryManager_c, "f").fileManager.upload(contents, { fileName, chunkSize: params?.chunkSize, signal: params?.signal });
+                if ("video" in content) {
+                    media = new types.InputMediaUploadedDocument({
+                        file,
+                        attributes: [new types.DocumentAttributeFilename({ file_name: fileName }), new types.DocumentAttributeVideo({ w: 720, h: 1280, duration: content.duration })],
+                        mime_type: mimeType,
+                    });
+                }
+                else {
+                    media = new types.InputMediaUploadedPhoto({ file });
+                }
+            }
+        }
+        const caption_ = params?.caption;
+        const parseResult = caption_ !== undefined ? await __classPrivateFieldGet(this, _StoryManager_c, "f").messageManager.parseText(caption_, { parseMode: params?.parseMode, entities: params?.captionEntities }) : undefined;
+        const caption = parseResult === undefined ? undefined : parseResult[0];
+        const entities = parseResult === undefined ? undefined : parseResult[1];
+        const peer = await __classPrivateFieldGet(this, _StoryManager_c, "f").getInputPeer(chatId);
+        const randomId = getRandomId();
+        const privacyRules = await storyPrivacyToTlObject(params?.privacy ?? { everyoneExcept: [] }, __classPrivateFieldGet(this, _StoryManager_c, "f").getEntity);
+        const mediaAreas = new Array();
+        if (params?.interactiveAreas?.length) {
+            for (const area of params.interactiveAreas) {
+                mediaAreas.push(await storyInteractiveAreaToTlObject(area, __classPrivateFieldGet(this, _StoryManager_c, "f").getEntity));
+            }
+        }
+        const updates = await __classPrivateFieldGet(this, _StoryManager_c, "f").api.stories.sendStory({
+            peer,
+            random_id: randomId,
+            media,
+            privacy_rules: privacyRules,
+            caption,
+            entities,
+            noforwards: params?.protectContent ? true : undefined,
+            period: params?.activeFor,
+            pinned: params?.highlight ? true : undefined,
+            media_areas: mediaAreas,
+        });
+        return await __classPrivateFieldGet(this, _StoryManager_instances, "m", _StoryManager_updatesToStory).call(this, updates);
+    }
+    async getStories(chatId, storyIds) {
+        const peer = await __classPrivateFieldGet(this, _StoryManager_c, "f").getInputPeer(chatId);
+        const stories_ = await __classPrivateFieldGet(this, _StoryManager_c, "f").api.stories.getStoriesByID({ peer, id: storyIds });
+        const stories = new Array();
+        for (const story of stories_.stories) {
+            stories.push(await constructStory(story[as](types.StoryItem), inputPeerToPeer(peer), __classPrivateFieldGet(this, _StoryManager_c, "f").getEntity));
+        }
+        return stories;
+    }
+    async getStory(chatId, storyId) {
+        return await this.getStories(chatId, [storyId]).then((v) => v[0] ?? null);
+    }
+    async deleteStories(chatId, storyIds) {
+        const peer = await __classPrivateFieldGet(this, _StoryManager_c, "f").getInputPeer(chatId);
+        await __classPrivateFieldGet(this, _StoryManager_c, "f").api.stories.deleteStories({ peer, id: storyIds });
+    }
+    async deleteStory(chatId, storyId) {
+        await this.deleteStories(chatId, [storyId]);
+    }
+    async addStoriesToHighlights(chatId, storyIds) {
+        await __classPrivateFieldGet(this, _StoryManager_instances, "m", _StoryManager_togglePinned).call(this, chatId, storyIds, true);
+    }
+    async addStoryToHighlights(chatId, storyId) {
+        await this.addStoriesToHighlights(chatId, [storyId]);
+    }
+    async removeStoriesFromHighlights(chatId, storyIds) {
+        await __classPrivateFieldGet(this, _StoryManager_instances, "m", _StoryManager_togglePinned).call(this, chatId, storyIds, false);
+    }
+    async removeStoryFromHighlights(chatId, storyId) {
+        await this.removeStoriesFromHighlights(chatId, [storyId]);
+    }
+    static canHandleUpdate(update) {
+        return update instanceof types.UpdateStory;
+    }
+    async handleUpdate(update) {
+        if (update.story instanceof types.StoryItemDeleted) {
+            const chatId = peerToChatId(update.peer);
+            const storyId = update.story.id;
+            return { deletedStory: { chatId, storyId } };
+        }
+        else if (update.story instanceof types.StoryItem) {
+            const story = await constructStory(update.story, update.peer, __classPrivateFieldGet(this, _StoryManager_c, "f").getEntity);
+            return { story };
+        }
+        else {
+            return null;
+        }
+    }
+}
+_StoryManager_c = new WeakMap(), _StoryManager_instances = new WeakSet(), _StoryManager_updatesToStory = async function _StoryManager_updatesToStory(updates) {
+    if (updates instanceof types.Updates) {
+        const updateStory = updates.updates.find((v) => v instanceof types.UpdateStory);
+        if (updateStory && updateStory.story instanceof types.StoryItem) {
+            return await constructStory(updateStory.story, updateStory.peer, __classPrivateFieldGet(this, _StoryManager_c, "f").getEntity);
+        }
+    }
+    UNREACHABLE();
+}, _StoryManager_togglePinned = async function _StoryManager_togglePinned(chatId, storyIds, pinned) {
+    const peer = await __classPrivateFieldGet(this, _StoryManager_c, "f").getInputPeer(chatId);
+    await __classPrivateFieldGet(this, _StoryManager_c, "f").api.stories.togglePinned({ peer, id: storyIds, pinned });
+};