@mtcute/core 0.17.1 → 0.18.0

package/highlevel/types/conversation.js

@@ -0,0 +1,430 @@
+import { Deque, AsyncLock, Deferred, timers, unknownToError } from "@fuman/utils";
+import { MtArgumentError, MtTimeoutError } from "../../types/errors.js";
+import { getMarkedPeerId } from "../../utils/peer-utils.js";
+import { getPeerDialogs } from "../methods/dialogs/get-peer-dialogs.js";
+import { readHistory } from "../methods/messages/read-history.js";
+import { sendMediaGroup } from "../methods/messages/send-media-group.js";
+import { sendMedia } from "../methods/messages/send-media.js";
+import { sendText } from "../methods/messages/send-text.js";
+import { resolvePeer } from "../methods/users/resolve-peer.js";
+const CONVERSATION_SYMBOL = Symbol("conversation");
+class Conversation {
+  constructor(client, chat) {
+    this.client = client;
+    this.chat = chat;
+    if (!(CONVERSATION_SYMBOL in client)) {
+      client[CONVERSATION_SYMBOL] = {
+        pendingConversations: /* @__PURE__ */ new Map(),
+        hasConversations: false
+      };
+    }
+  }
+  _inputPeer;
+  _chatId;
+  _started = false;
+  _lastMessage;
+  _lastReceivedMessage;
+  _queuedNewMessage = new Deque();
+  _pendingNewMessages = new Deque();
+  _lock = new AsyncLock();
+  _pendingEditMessage = /* @__PURE__ */ new Map();
+  _recentEdits = new Deque(void 0, { capacity: 10 });
+  _pendingRead = /* @__PURE__ */ new Map();
+  static _getState(client) {
+    return client[CONVERSATION_SYMBOL];
+  }
+  /**
+   * Pass the update to the conversation manager and all registered
+   * conversations on this client.
+   *
+   * @returns `true` if the update was handled by some conversation
+   */
+  static handleUpdate(client, update) {
+    const state = Conversation._getState(client);
+    if (!state?.hasConversations) return false;
+    let chatId;
+    switch (update.name) {
+      case "new_message":
+      case "edit_message":
+        chatId = getMarkedPeerId(update.data.raw.peerId);
+        break;
+      case "history_read":
+        chatId = update.data.chatId;
+        break;
+      default:
+        return false;
+    }
+    const conv = state.pendingConversations.get(chatId);
+    if (!conv) return false;
+    for (const c of conv) {
+      switch (update.name) {
+        case "new_message":
+          c._onNewMessage(update.data);
+          return true;
+        case "edit_message":
+          c._onEditMessage(update.data);
+          return true;
+        case "history_read":
+          c._onHistoryRead(update.data);
+          return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the input peer that this conversation is with
+   */
+  get inputPeer() {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    return this._inputPeer;
+  }
+  /**
+   * ID of the very last message in this conversation.
+   */
+  get lastMessage() {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    return this._lastMessage;
+  }
+  /**
+   * ID of the last incoming message in this conversation.
+   *
+   * Note that before any messages were received since the {@link start}
+   * of the conversation, this will equal to {@link lastMessage}
+   */
+  get lastReceivedMessage() {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    return this._lastReceivedMessage;
+  }
+  /**
+   * Start the conversation
+   */
+  async start() {
+    if (this._started) return;
+    this._started = true;
+    this._inputPeer = await resolvePeer(this.client, this.chat);
+    this._chatId = getMarkedPeerId(this._inputPeer);
+    const [dialog] = await getPeerDialogs(this.client, this._inputPeer);
+    const lastMessage = dialog?.lastMessage;
+    if (lastMessage) {
+      this._lastMessage = this._lastReceivedMessage = lastMessage.id;
+    } else {
+      this._lastMessage = this._lastReceivedMessage = 0;
+    }
+    const state = Conversation._getState(this.client);
+    if (!state.pendingConversations.has(this._chatId)) {
+      state.pendingConversations.set(this._chatId, []);
+    }
+    state.pendingConversations.get(this._chatId).push(this);
+    state.hasConversations = true;
+  }
+  /**
+   * Stop the conversation
+   */
+  stop() {
+    if (!this._started) return;
+    const state = Conversation._getState(this.client);
+    const pending = state.pendingConversations.get(this._chatId);
+    const pendingIdx = pending?.indexOf(this) ?? -1;
+    if (pendingIdx > -1) {
+      pending.splice(pendingIdx, 1);
+    }
+    if (pending && !pending.length) {
+      state.pendingConversations.delete(this._chatId);
+    }
+    state.hasConversations = Boolean(state.pendingConversations.size);
+    this._queuedNewMessage.clear();
+    this._pendingNewMessages.clear();
+    this._pendingEditMessage.clear();
+    this._recentEdits.clear();
+    this._pendingRead.clear();
+    this._started = false;
+  }
+  _recordMessage(msg, incoming = false) {
+    this._lastMessage = msg.id;
+    if (incoming) this._lastReceivedMessage = msg.id;
+    return msg;
+  }
+  /**
+   * Send a text message to this conversation.
+   *
+   * Wrapper over {@link sendText}
+   */
+  async sendText(...params) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    return this._recordMessage(await sendText(this.client, this._inputPeer, ...params));
+  }
+  /**
+   * Send a media to this conversation.
+   *
+   * Wrapper over {@link sendMedia}
+   */
+  async sendMedia(...params) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    return this._recordMessage(await sendMedia(this.client, this._inputPeer, ...params));
+  }
+  /**
+   * Send a media group to this conversation.
+   *
+   * Wrapper over {@link sendMediaGroup}
+   */
+  async sendMediaGroup(...params) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    const msgs = await sendMediaGroup(this.client, this._inputPeer, ...params);
+    this._recordMessage(msgs[msgs.length - 1]);
+    return msgs;
+  }
+  /**
+   * Mark the conversation as read up to a certain point.
+   *
+   * By default, reads until the last message.
+   * You can pass `message=null` to read the entire conversation,
+   * or pass message ID to read up until that ID.
+   */
+  markRead({
+    message,
+    clearMentions = true
+  } = {}) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    if (message === null) {
+      message = 0;
+    } else if (message === void 0) {
+      message = this._lastMessage ?? 0;
+    }
+    return readHistory(this.client, this._inputPeer, { maxId: message, clearMentions });
+  }
+  /**
+   * Helper method that calls {@link start},
+   * the provided function and then {@link stop}.
+   *
+   * It is preferred that you use this function rather than
+   * manually starting and stopping the conversation.
+   *
+   * If you don't stop the conversation when you're done,
+   * it *will* lead to memory leaks.
+   *
+   * @param handler
+   */
+  async with(handler) {
+    await this.start();
+    let err;
+    let res;
+    try {
+      res = await handler();
+    } catch (e) {
+      err = e;
+    }
+    this.stop();
+    if (err) throw err;
+    return res;
+  }
+  /**
+   * Wait for a new message in the conversation
+   *
+   * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+   * @param [timeout]  Timeout for the handler in ms. Pass `null` to disable.
+   *   When the timeout is reached, `MtTimeoutError` is thrown.
+   */
+  waitForNewMessage(filter, timeout = 15e3) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    const promise = new Deferred();
+    let timer;
+    if (timeout !== null) {
+      timer = timers.setTimeout(() => {
+        promise.reject(new MtTimeoutError(timeout));
+        this._queuedNewMessage.removeBy((it) => it.promise === promise);
+      }, timeout);
+    }
+    this._queuedNewMessage.pushBack({
+      promise,
+      check: filter,
+      timeout: timer
+    });
+    this._processPendingNewMessages();
+    return promise.promise;
+  }
+  /**
+   * Wait for a response for the given message
+   * (def. the last one) in the conversation.
+   *
+   * A message is considered to be a response if
+   * it was sent after the given one.
+   *
+   * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+   * @param params
+   */
+  waitForResponse(filter, params) {
+    const msgId = params?.message ?? this._lastMessage ?? 0;
+    const pred = filter ? (msg) => msg.id > msgId ? filter(msg) : false : (msg) => msg.id > msgId;
+    return this.waitForNewMessage(pred, params?.timeout);
+  }
+  /**
+   * Wait for the reply for the given message'
+   * (def. the last one) in the conversation.
+   *
+   * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+   * @param params
+   */
+  waitForReply(filter, params) {
+    const msgId = params?.message ?? this._lastMessage;
+    if (!msgId) {
+      throw new MtArgumentError("Provide message for which to wait for reply for");
+    }
+    const pred = filter ? (msg) => msg.replyToMessage?.id === msgId ? filter(msg) : false : (msg) => msg.replyToMessage?.id === msgId;
+    return this.waitForNewMessage(pred, params?.timeout);
+  }
+  /**
+   * Wait for a message to be edited in the conversation.
+   * By defaults wait for the last message sent by the other party
+   * (at the moment) to be edited.
+   *
+   * Returns the edited message.
+   *
+   * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+   * @param params
+   */
+  async waitForEdit(filter, params) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    const msgId = params?.message ?? this._lastReceivedMessage;
+    if (!msgId) {
+      throw new MtArgumentError("Provide message for which to wait for edit for");
+    }
+    const promise = new Deferred();
+    let timer;
+    const timeout = params?.timeout;
+    if (timeout) {
+      timer = timers.setTimeout(() => {
+        promise.reject(new MtTimeoutError(timeout));
+        this._pendingEditMessage.delete(msgId);
+      }, timeout);
+    }
+    this._pendingEditMessage.set(msgId, {
+      promise,
+      check: filter,
+      timeout: timer
+    });
+    this._processRecentEdits();
+    return promise.promise;
+  }
+  /**
+   * Wait for the message to be read by the other party.
+   *
+   * Note that reading the message doesn't mean the response was sent,
+   * and if the response was sent, it doesn't mean that the message was read.
+   *
+   * @param message  Message for which to wait for read for. Defaults to last message.
+   * @param timeout  Timeout for the handler in ms, def. 15 sec. Pass `null` to disable.
+   *   When the timeout is reached, `TimeoutError` is thrown.
+   */
+  async waitForRead(message, timeout = 15e3) {
+    if (!this._started) {
+      throw new MtArgumentError("Conversation hasn't started yet");
+    }
+    const msgId = message ?? this._lastMessage;
+    if (!msgId) {
+      throw new MtArgumentError("Provide message for which to wait for read for");
+    }
+    const [dialog] = await getPeerDialogs(this.client, this._inputPeer);
+    if (dialog.lastRead >= msgId) return;
+    const promise = new Deferred();
+    let timer;
+    if (timeout !== null) {
+      timer = timers.setTimeout(() => {
+        promise.reject(new MtTimeoutError(timeout));
+        this._pendingRead.delete(msgId);
+      }, timeout);
+    }
+    this._pendingRead.set(msgId, {
+      promise,
+      timeout: timer
+    });
+    return promise.promise;
+  }
+  _onNewMessage(msg) {
+    if (msg.chat.id !== this._chatId) return;
+    if (!this._queuedNewMessage.length) {
+      this._pendingNewMessages.pushBack(msg);
+      return;
+    }
+    const it = this._queuedNewMessage.peekFront();
+    void this._lock.acquire().then(async () => {
+      try {
+        if (!it.check || await it.check(msg)) {
+          if (it.timeout) timers.clearTimeout(it.timeout);
+          it.promise.resolve(msg);
+          this._queuedNewMessage.popFront();
+        }
+      } catch (e) {
+        this.client.onError.emit(unknownToError(e));
+      }
+      this._lastMessage = this._lastReceivedMessage = msg.id;
+      this._lock.release();
+    });
+  }
+  _onEditMessage(msg, fromRecent = false) {
+    if (msg.chat.id !== this._chatId) return;
+    const it = this._pendingEditMessage.get(msg.id);
+    if (!it) {
+      if (!fromRecent) {
+        this._recentEdits.pushBack(msg);
+      }
+      return;
+    }
+    (async () => {
+      if (!it.check || await it.check(msg)) {
+        if (it.timeout) timers.clearTimeout(it.timeout);
+        it.promise.resolve(msg);
+        this._pendingEditMessage.delete(msg.id);
+      }
+    })().catch((e) => {
+      this.client.onError.emit(unknownToError(e));
+    });
+  }
+  _onHistoryRead(upd) {
+    if (upd.chatId !== this._chatId) return;
+    const lastRead = upd.maxReadId;
+    for (const msgId of this._pendingRead.keys()) {
+      if (msgId <= lastRead) {
+        const it = this._pendingRead.get(msgId);
+        if (it.timeout) timers.clearTimeout(it.timeout);
+        it.promise.resolve();
+        this._pendingRead.delete(msgId);
+      }
+    }
+  }
+  _processPendingNewMessages() {
+    if (!this._pendingNewMessages.length) return;
+    let it;
+    while (it = this._pendingNewMessages.popFront()) {
+      this._onNewMessage(it);
+    }
+  }
+  _processRecentEdits() {
+    if (!this._recentEdits.length) return;
+    const iter = this._recentEdits[Symbol.iterator]();
+    let it;
+    while (!(it = iter.next()).done) {
+      this._onEditMessage(it.value, true);
+    }
+  }
+}
+export {
+  Conversation
+};

package/highlevel/types/errors.cjs

@@ -0,0 +1,32 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../../types/errors.cjs");
+class MtPeerNotFoundError extends errors.MtcuteError {
+}
+class MtMessageNotFoundError extends errors.MtcuteError {
+  constructor(peerId, messageId, context) {
+    super(`Message${context ? ` ${context}` : ""} ${messageId} not found in ${peerId}`);
+    this.peerId = peerId;
+    this.messageId = messageId;
+    this.context = context;
+  }
+}
+class MtInvalidPeerTypeError extends errors.MtcuteError {
+  constructor(peer, expected) {
+    super(`Provided identifier ${JSON.stringify(peer)} is not a ${expected}`);
+  }
+}
+class MtEmptyError extends errors.MtcuteError {
+  constructor() {
+    super("Property is not available on an empty object");
+  }
+}
+exports.MtEmptyError = MtEmptyError;
+exports.MtInvalidPeerTypeError = MtInvalidPeerTypeError;
+exports.MtMessageNotFoundError = MtMessageNotFoundError;
+exports.MtPeerNotFoundError = MtPeerNotFoundError;

package/highlevel/types/errors.d.cts

@@ -0,0 +1,33 @@
+import { InputPeerLike } from './peers/index.js';
+import { MtcuteError } from '../../types/errors.js';
+/**
+ * Could not find a peer by the provided information
+ */
+export declare class MtPeerNotFoundError extends MtcuteError {
+}
+/**
+ * Could not find a message by the provided information
+ */
+export declare class MtMessageNotFoundError extends MtcuteError {
+    readonly peerId: number;
+    readonly messageId: number;
+    readonly context?: string | undefined;
+    constructor(peerId: number, messageId: number, context?: string | undefined);
+}
+/**
+ * Some method that requires a particular type of peer
+ * is called, but the resolved peer type is invalid.
+ *
+ * For example, when trying to get common chats
+ * while providing another chat as `userId`
+ */
+export declare class MtInvalidPeerTypeError extends MtcuteError {
+    constructor(peer: InputPeerLike, expected: string);
+}
+/**
+ * Trying to access to some property on an object that does not
+ * contain that information.
+ */
+export declare class MtEmptyError extends MtcuteError {
+    constructor();
+}

package/highlevel/types/errors.d.ts

@@ -1,5 +1,5 @@
-import { MtcuteError } from '../../types/errors.js';
 import { InputPeerLike } from './peers/index.js';
+import { MtcuteError } from '../../types/errors.js';
 /**
  * Could not find a peer by the provided information
  */

package/highlevel/types/errors.js

@@ -0,0 +1,27 @@
+import { MtcuteError } from "../../types/errors.js";
+class MtPeerNotFoundError extends MtcuteError {
+}
+class MtMessageNotFoundError extends MtcuteError {
+  constructor(peerId, messageId, context) {
+    super(`Message${context ? ` ${context}` : ""} ${messageId} not found in ${peerId}`);
+    this.peerId = peerId;
+    this.messageId = messageId;
+    this.context = context;
+  }
+}
+class MtInvalidPeerTypeError extends MtcuteError {
+  constructor(peer, expected) {
+    super(`Provided identifier ${JSON.stringify(peer)} is not a ${expected}`);
+  }
+}
+class MtEmptyError extends MtcuteError {
+  constructor() {
+    super("Property is not available on an empty object");
+  }
+}
+export {
+  MtEmptyError,
+  MtInvalidPeerTypeError,
+  MtMessageNotFoundError,
+  MtPeerNotFoundError
+};

package/highlevel/types/files/file-location.cjs

@@ -0,0 +1,17 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const inspectable = require("../../utils/inspectable.cjs");
+class FileLocation {
+  constructor(location, fileSize, dcId) {
+    this.location = location;
+    this.fileSize = fileSize;
+    this.dcId = dcId;
+  }
+}
+const FileLocation$1 = /* @__PURE__ */ inspectable.makeInspectable(FileLocation, ["fileSize", "dcId"]);
+exports.FileLocation = FileLocation$1;

package/highlevel/types/files/file-location.d.cts

@@ -0,0 +1,48 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Information about file location.
+ *
+ * Catch-all class for all kinds of Telegram file locations,
+ * including ones that are embedded directly into the entity.
+ */
+export declare class FileLocation {
+    /**
+     * Location of the file.
+     *
+     * Either a TL object declaring remote file location,
+     * a Buffer containing actual file content (for stripped thumbnails and vector previews),
+     * or a function that will return either of those.
+     *
+     * When a function is passed, it will be lazily resolved the
+     * first time downloading the file.
+     */
+    readonly location: tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array | (() => tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array);
+    /**
+     * File size in bytes, when available
+     */
+    readonly fileSize?: number | undefined;
+    /**
+     * DC ID of the file, when available
+     */
+    readonly dcId?: number | undefined;
+    constructor(
+    /**
+     * Location of the file.
+     *
+     * Either a TL object declaring remote file location,
+     * a Buffer containing actual file content (for stripped thumbnails and vector previews),
+     * or a function that will return either of those.
+     *
+     * When a function is passed, it will be lazily resolved the
+     * first time downloading the file.
+     */
+    location: tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array | (() => tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array), 
+    /**
+     * File size in bytes, when available
+     */
+    fileSize?: number | undefined, 
+    /**
+     * DC ID of the file, when available
+     */
+    dcId?: number | undefined);
+}

package/highlevel/types/files/file-location.js

@@ -0,0 +1,12 @@
+import { makeInspectable } from "../../utils/inspectable.js";
+class FileLocation {
+  constructor(location, fileSize, dcId) {
+    this.location = location;
+    this.fileSize = fileSize;
+    this.dcId = dcId;
+  }
+}
+const FileLocation$1 = /* @__PURE__ */ makeInspectable(FileLocation, ["fileSize", "dcId"]);
+export {
+  FileLocation$1 as FileLocation
+};

package/highlevel/types/files/index.d.cts

@@ -0,0 +1,4 @@
+export * from './file-location.js';
+export * from './uploaded-file.js';
+export * from './utils.js';
+export * from './web-document.js';

package/highlevel/types/files/uploaded-file.cjs

@@ -0,0 +1,11 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isUploadedFile(obj) {
+  return obj !== null && typeof obj === "object" && "inputFile" in obj && "size" in obj && "mime" in obj;
+}
+exports.isUploadedFile = isUploadedFile;

package/highlevel/types/files/uploaded-file.d.cts

@@ -0,0 +1,24 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Describes a file uploaded to the Telegram servers
+ * using {@link TelegramClient.uploadFile} method.
+ */
+export interface UploadedFile {
+    /**
+     * Raw TL input file to be used in other methods.
+     *
+     * Very low-level stuff, usually you shouldn't care about it.
+     */
+    inputFile: tl.TypeInputFile;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * File MIME type, either the one passed or
+     * the one derived from file contents.
+     */
+    mime: string;
+}
+/** @internal */
+export declare function isUploadedFile(obj: unknown): obj is UploadedFile;

package/highlevel/types/files/uploaded-file.js

@@ -0,0 +1,6 @@
+function isUploadedFile(obj) {
+  return obj !== null && typeof obj === "object" && "inputFile" in obj && "size" in obj && "mime" in obj;
+}
+export {
+  isUploadedFile
+};