@mtcute/core 0.17.1 → 0.18.0

package/highlevel/types/messages/message-replies.cjs

@@ -0,0 +1,66 @@
+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 peerUtils = require("../../../utils/peer-utils.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+const memoize = require("../../utils/memoize.cjs");
+const peer = require("../peers/peer.cjs");
+class MessageRepliesInfo {
+  constructor(raw, _peers) {
+    this.raw = raw;
+    this._peers = _peers;
+  }
+  /**
+   * Whether this message is a channel post that has a comments thread
+   * in the linked discussion group
+   */
+  get hasComments() {
+    return this.raw.comments;
+  }
+  /**
+   * Total number of replies
+   */
+  get count() {
+    return this.raw.replies;
+  }
+  /**
+   * Whether this reply thread has unread messages
+   */
+  get hasUnread() {
+    return this.raw.readMaxId !== void 0 && this.raw.readMaxId !== this.raw.maxId;
+  }
+  /**
+   * ID of the last message in the thread (if any)
+   */
+  get lastMessageId() {
+    return this.raw.maxId ?? null;
+  }
+  /**
+   * ID of the last read message in the thread (if any)
+   */
+  get lastReadMessageId() {
+    return this.raw.readMaxId ?? null;
+  }
+  /**
+   * ID of the discussion group for the post
+   *
+   * `null` if the post is not a channel post
+   */
+  get discussion() {
+    if (!this.raw.channelId) return null;
+    return peerUtils.getMarkedPeerId(this.raw.channelId, "channel");
+  }
+  /**
+   * Last few commenters to the post (usually 3)
+   */
+  get repliers() {
+    return this.raw.recentRepliers?.map((it) => peer.parsePeer(it, this._peers)) ?? [];
+  }
+}
+const MessageRepliesInfo$1 = /* @__PURE__ */ memoize.memoizeGetters(MessageRepliesInfo, ["discussion", "repliers"]);
+const MessageRepliesInfo$2 = /* @__PURE__ */ inspectable.makeInspectable(MessageRepliesInfo$1);
+exports.MessageRepliesInfo = MessageRepliesInfo$2;

package/highlevel/types/messages/message-replies.d.cts

@@ -0,0 +1,42 @@
+import { tl } from '@mtcute/tl';
+import { Peer } from '../peers/peer.js';
+import { PeersIndex } from '../peers/peers-index.js';
+/**
+ * Information about replies to a message
+ */
+export declare class MessageRepliesInfo {
+    readonly raw: tl.RawMessageReplies;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawMessageReplies, _peers: PeersIndex);
+    /**
+     * Whether this message is a channel post that has a comments thread
+     * in the linked discussion group
+     */
+    get hasComments(): boolean;
+    /**
+     * Total number of replies
+     */
+    get count(): number;
+    /**
+     * Whether this reply thread has unread messages
+     */
+    get hasUnread(): boolean;
+    /**
+     * ID of the last message in the thread (if any)
+     */
+    get lastMessageId(): number | null;
+    /**
+     * ID of the last read message in the thread (if any)
+     */
+    get lastReadMessageId(): number | null;
+    /**
+     * ID of the discussion group for the post
+     *
+     * `null` if the post is not a channel post
+     */
+    get discussion(): number | null;
+    /**
+     * Last few commenters to the post (usually 3)
+     */
+    get repliers(): Peer[];
+}

package/highlevel/types/messages/message-replies.js

@@ -0,0 +1,61 @@
+import { getMarkedPeerId } from "../../../utils/peer-utils.js";
+import { makeInspectable } from "../../utils/inspectable.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { parsePeer } from "../peers/peer.js";
+class MessageRepliesInfo {
+  constructor(raw, _peers) {
+    this.raw = raw;
+    this._peers = _peers;
+  }
+  /**
+   * Whether this message is a channel post that has a comments thread
+   * in the linked discussion group
+   */
+  get hasComments() {
+    return this.raw.comments;
+  }
+  /**
+   * Total number of replies
+   */
+  get count() {
+    return this.raw.replies;
+  }
+  /**
+   * Whether this reply thread has unread messages
+   */
+  get hasUnread() {
+    return this.raw.readMaxId !== void 0 && this.raw.readMaxId !== this.raw.maxId;
+  }
+  /**
+   * ID of the last message in the thread (if any)
+   */
+  get lastMessageId() {
+    return this.raw.maxId ?? null;
+  }
+  /**
+   * ID of the last read message in the thread (if any)
+   */
+  get lastReadMessageId() {
+    return this.raw.readMaxId ?? null;
+  }
+  /**
+   * ID of the discussion group for the post
+   *
+   * `null` if the post is not a channel post
+   */
+  get discussion() {
+    if (!this.raw.channelId) return null;
+    return getMarkedPeerId(this.raw.channelId, "channel");
+  }
+  /**
+   * Last few commenters to the post (usually 3)
+   */
+  get repliers() {
+    return this.raw.recentRepliers?.map((it) => parsePeer(it, this._peers)) ?? [];
+  }
+}
+const MessageRepliesInfo$1 = /* @__PURE__ */ memoizeGetters(MessageRepliesInfo, ["discussion", "repliers"]);
+const MessageRepliesInfo$2 = /* @__PURE__ */ makeInspectable(MessageRepliesInfo$1);
+export {
+  MessageRepliesInfo$2 as MessageRepliesInfo
+};

package/highlevel/types/messages/message.cjs

@@ -0,0 +1,444 @@
+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");
+const utils = require("../../../types/utils.cjs");
+const peerUtils = require("../../../utils/peer-utils.cjs");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const memoize = require("../../utils/memoize.cjs");
+const peer = require("../peers/peer.cjs");
+const user = require("../peers/user.cjs");
+const factCheck = require("./fact-check.cjs");
+const messageAction = require("./message-action.cjs");
+const messageEntity = require("./message-entity.cjs");
+const messageForward = require("./message-forward.cjs");
+const messageMedia = require("./message-media.cjs");
+const messageReactions = require("./message-reactions.cjs");
+const messageReplies = require("./message-replies.cjs");
+const repliedMessage = require("./replied-message.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+const factories = require("../bots/keyboards/factories.cjs");
+class Message {
+  constructor(raw, _peers, isScheduled = false) {
+    this._peers = _peers;
+    this.isScheduled = isScheduled;
+    typeAssertions.assertTypeIsNot("Message#ctor", raw, "messageEmpty");
+    this.raw = raw;
+  }
+  /**
+   * Raw TL object.
+   */
+  raw;
+  /** Unique message identifier inside this chat */
+  get id() {
+    return this.raw.id;
+  }
+  /**
+   * For channel posts, number of views
+   *
+   * `null` for service messages and non-post messages.
+   */
+  get views() {
+    return this.raw._ === "message" ? this.raw.views ?? null : null;
+  }
+  /**
+   * For channel posts, number of forwards
+   *
+   * `null` for service messages and non-post messages, or
+   * if the current user is not an admin in the channel
+   */
+  get forwards() {
+    return this.raw._ === "message" ? this.raw.forwards ?? null : null;
+  }
+  /**
+   * For channel posts with signatures enabled, name of the post author
+   */
+  get signature() {
+    return this.raw._ === "message" ? this.raw.postAuthor ?? null : null;
+  }
+  /**
+   * Whether the message is incoming or outgoing:
+   *  - Messages received from other chats are incoming (`outgoing = false`)
+   *  - Messages sent by you to other chats are outgoing (`outgoing = true`)
+   *  - Messages to yourself (i.e. *Saved Messages*) are incoming (`outgoing = false`)
+   */
+  get isOutgoing() {
+    return this.raw.out;
+  }
+  /**
+   * Whether this message is a service message
+   */
+  get isService() {
+    return this.raw._ === "messageService";
+  }
+  /** Whether this message has content protection (i.e. disabled forwards) */
+  get isContentProtected() {
+    return this.raw._ === "message" && this.raw.noforwards;
+  }
+  /**
+   * Whether the message was sent by an implicit action, for example,
+   * as an away or a greeting business message, or as a scheduled message
+   */
+  get isFromOffline() {
+    return this.raw._ === "message" && this.raw.offline;
+  }
+  /** Whether this is a silent message (no notification triggered) */
+  get isSilent() {
+    return this.raw.silent;
+  }
+  /** Whether there are unread media attachments in this message */
+  get hasUnreadMedia() {
+    return this.raw.mediaUnread;
+  }
+  /** Whether this is a broadcast channel post */
+  get isChannelPost() {
+    return this.raw._ === "message" && this.raw.post;
+  }
+  /**
+   * Whether this message was automatically sent from a scheduled message.
+   *
+   * **Note**: for messages sent by other users, this is always `false`.
+   */
+  get isFromScheduled() {
+    return this.raw._ === "message" && this.raw.fromScheduled;
+  }
+  /** Whether the message is pinned in the current chat */
+  get isPinned() {
+    return this.raw._ === "message" && this.raw.pinned;
+  }
+  /** Whether the message should be considered unedited, even if {@link editDate} ≠ null */
+  get hideEditMark() {
+    return this.raw._ === "message" && this.raw.editHide;
+  }
+  /**
+   * If set, any eventual webpage preview should be shown on top of
+   * the message instead of at the bottom.
+   */
+  get invertMedia() {
+    return this.raw._ === "message" && this.raw.invertMedia;
+  }
+  /**
+   * Multiple media messages with the same grouped ID
+   * indicate an album or media group
+   *
+   * `null` for service messages and non-grouped messages
+   */
+  get groupedId() {
+    return this.raw._ === "message" ? this.raw.groupedId ?? null : null;
+  }
+  /**
+   * Same as {@link groupedId}, but is globally unique across chats.
+   */
+  get groupedIdUnique() {
+    if (!(this.raw._ === "message" && this.raw.groupedId !== void 0)) return null;
+    return `${this.raw.groupedId.low}|${this.raw.groupedId.high}|${peerUtils.getMarkedPeerId(this.raw.peerId)}`;
+  }
+  /**
+   * Message sender.
+   *
+   * Usually is a {@link User}, but can be a {@link Peer}
+   * in case the message was sent by an anonymous admin, anonymous premium user,
+   * or if the message is a forwarded channel post.
+   *
+   * If the message was sent by an anonymous admin,
+   * sender will equal to {@link chat}.
+   *
+   * If the message is a forwarded channel post,
+   * sender is the channel itself.
+   */
+  get sender() {
+    const from = this.raw.fromId;
+    if (!from) {
+      if (this.raw.peerId._ === "peerUser") {
+        return new user.User(this._peers.user(this.raw.peerId.userId));
+      }
+      return this.chat;
+    }
+    return peer.parsePeer(from, this._peers);
+  }
+  /**
+   * Number of boosts applied to this {@link chat} by the sender
+   */
+  get senderBoostCount() {
+    if (this.raw._ !== "message") return 0;
+    return this.raw.fromBoostsApplied ?? 0;
+  }
+  /**
+   * Conversation the message belongs to
+   */
+  get chat() {
+    return peer.parsePeer(this.raw.peerId, this._peers);
+  }
+  /**
+   * Date when the message was sent
+   */
+  get date() {
+    return new Date(this.raw.date * 1e3);
+  }
+  /**
+   * Date when the message was last edited
+   */
+  get editDate() {
+    if (this.raw._ === "messageService") return null;
+    return this.raw.editDate ? new Date(this.raw.editDate * 1e3) : null;
+  }
+  /**
+   * If this message is a forward, contains info about it.
+   */
+  get forward() {
+    if (this.raw._ !== "message" || !this.raw.fwdFrom) {
+      return null;
+    }
+    return new messageForward.MessageForwardInfo(this.raw.fwdFrom, this._peers);
+  }
+  /**
+   * Whether the message is a channel post that was
+   * automatically forwarded to the connected discussion group
+   */
+  get isAutomaticForward() {
+    if (this.raw._ === "messageService" || !this.raw.fwdFrom) return false;
+    const fwd = this.raw.fwdFrom;
+    return Boolean(
+      this.chat.type === "chat" && this.chat.chatType === "supergroup" && fwd.savedFromMsgId && fwd.savedFromPeer?._ === "peerChannel" && peerUtils.getMarkedPeerId(fwd.savedFromPeer) !== peerUtils.getMarkedPeerId(this.raw.peerId)
+    );
+  }
+  /**
+   * Information about comments (for channels) or replies (for groups)
+   */
+  get replies() {
+    if (this.raw._ !== "message" || !this.raw.replies) return null;
+    return new messageReplies.MessageRepliesInfo(this.raw.replies, this._peers);
+  }
+  /**
+   * For replies, information about the that is being replied to.
+   *
+   * Mutually exclusive with {@link replyToStory}
+   */
+  get replyToMessage() {
+    if (this.raw.replyTo?._ !== "messageReplyHeader") return null;
+    return new repliedMessage.RepliedMessageInfo(this.raw.replyTo, this._peers);
+  }
+  /**
+   * For replies, information about the story that is being replied to
+   *
+   * Mutually exclusive with {@link replyToMessage}
+   */
+  get replyToStory() {
+    if (this.raw.replyTo?._ !== "messageReplyStoryHeader") return null;
+    return this.raw.replyTo;
+  }
+  /** Whether this message is in a forum topic */
+  get isTopicMessage() {
+    if (this.raw.replyTo?._ !== "messageReplyHeader") return false;
+    return this.raw.replyTo.forumTopic;
+  }
+  /**
+   * Whether this message contains mention of the current user
+   */
+  get isMention() {
+    return this.raw.mentioned;
+  }
+  /**
+   * If non-null, this message is not actually sent, and is
+   * instead inside a group of "quick reply" messages
+   * under the given shortcut ID
+   */
+  get quickReplyShortcutId() {
+    if (this.raw._ === "messageService") return null;
+    return this.raw.quickReplyShortcutId ?? null;
+  }
+  /**
+   * If this message is generated from an inline query,
+   * information about the bot which generated it
+   */
+  get viaBot() {
+    if (this.raw._ === "messageService" || !this.raw.viaBotId) {
+      return null;
+    }
+    return new user.User(this._peers.user(this.raw.viaBotId));
+  }
+  /**
+   * If this message was sent by a business bot on behalf of {@link sender},
+   * information about the business bot.
+   *
+   * **Note**: only available to the business account and the bot itself.
+   */
+  get viaBusinessBot() {
+    if (this.raw._ === "messageService" || !this.raw.viaBusinessBotId) {
+      return null;
+    }
+    return new user.User(this._peers.user(this.raw.viaBusinessBotId));
+  }
+  /**
+   * Message text or media caption.
+   *
+   * Empty string for service messages
+   * (you should handle i18n yourself)
+   */
+  get text() {
+    return this.raw._ === "messageService" ? "" : this.raw.message;
+  }
+  /**
+   * Message text/caption entities (may be empty)
+   */
+  get entities() {
+    const entities = [];
+    if (this.raw._ === "message" && this.raw.entities?.length) {
+      for (const ent of this.raw.entities) {
+        entities.push(new messageEntity.MessageEntity(ent, this.raw.message));
+      }
+    }
+    return entities;
+  }
+  get textWithEntities() {
+    if (this.raw._ === "messageService") return { text: "", entities: [] };
+    return {
+      text: this.raw.message,
+      entities: this.raw.entities
+    };
+  }
+  /**
+   * Message action. `null` for non-service messages
+   * or for unsupported events.
+   *
+   * For unsupported events, use `.raw.action` directly.
+   */
+  get action() {
+    if (this.raw._ === "message") {
+      return null;
+    }
+    return messageAction._messageActionFromTl.call(this, this.raw.action);
+  }
+  /**
+   * Message media. `null` for text-only and service messages
+   * and for unsupported media types.
+   *
+   * For unsupported media types, use `.raw.media` directly.
+   */
+  get media() {
+    if (this.raw._ === "messageService" || !this.raw.media || this.raw.media._ === "messageMediaEmpty") {
+      return null;
+    }
+    return messageMedia._messageMediaFromTl(this._peers, this.raw.media);
+  }
+  /**
+   * Whether this is a premium media
+   * (e.g. >2gb file or fullscreen sticker)
+   * that was forwarded without author by a non-premium user
+   */
+  get isForwardedPremiumMedia() {
+    return this.raw._ === "message" && this.raw.media?._ === "messageMediaDocument" && this.raw.media.nopremium;
+  }
+  /**
+   * TTL period of the message, in seconds.
+   */
+  get ttlPeriod() {
+    return this.raw.ttlPeriod ?? null;
+  }
+  /**
+   * Reply markup provided with this message, if any.
+   */
+  get markup() {
+    if (this.raw._ === "messageService" || !this.raw.replyMarkup) {
+      return null;
+    }
+    const rm = this.raw.replyMarkup;
+    switch (rm._) {
+      case "replyKeyboardHide":
+        return {
+          type: "reply_hide",
+          selective: rm.selective
+        };
+      case "replyKeyboardForceReply":
+        return {
+          type: "force_reply",
+          singleUse: rm.singleUse,
+          selective: rm.selective
+        };
+      case "replyKeyboardMarkup":
+        return {
+          type: "reply",
+          resize: rm.resize,
+          singleUse: rm.singleUse,
+          selective: rm.selective,
+          buttons: factories._rowsTo2d(rm.rows)
+        };
+      case "replyInlineMarkup":
+        return {
+          type: "inline",
+          buttons: factories._rowsTo2d(rm.rows)
+        };
+      default:
+        utils.assertNever();
+    }
+  }
+  /**
+   * Whether this message can be forwarded
+   *
+   * `false` for service mesasges and private restricted chats/chanenls
+   */
+  get canBeForwarded() {
+    return this.raw._ === "message" && !this.raw.noforwards;
+  }
+  /**
+   * Reactions added to this message, if any
+   */
+  get reactions() {
+    if (this.raw._ === "messageService" || !this.raw.reactions) {
+      return null;
+    }
+    return new messageReactions.MessageReactions(this.raw.id, peerUtils.getMarkedPeerId(this.raw.peerId), this.raw.reactions, this._peers);
+  }
+  /**
+   * Information about fact-check added to the message, if any
+   */
+  get factCheck() {
+    if (this.raw._ === "messageService") return null;
+    if (!this.raw.factcheck || this.raw.factcheck.hash.isZero()) return null;
+    return new factCheck.FactCheck(this.raw.factcheck);
+  }
+  /**
+   * If this message was sent with a message effect, ID of the effect
+   */
+  get effectId() {
+    if (this.raw._ === "messageService") return null;
+    return this.raw.effect ?? null;
+  }
+  /** Whether this message has a video that is still being processed */
+  get videoProcessingPending() {
+    return this.raw._ === "message" && this.raw.videoProcessingPending;
+  }
+  /**
+   * Generated permalink to this message, only for groups and channels
+   *
+   * @throws MtArgumentError  In case the chat does not support message links
+   */
+  get link() {
+    if (this.chat.type === "chat" && (this.chat.chatType === "supergroup" || this.chat.chatType === "channel")) {
+      if (this.chat.username) {
+        return `https://t.me/${this.chat.username}/${this.id}`;
+      }
+      return `https://t.me/c/${peerUtils.toggleChannelIdMark(this.chat.id)}/${this.id}`;
+    }
+    throw new errors.MtArgumentError(`Cannot generate message link for ${this.chat.chatType ?? this.chat.type}`);
+  }
+}
+const Message$1 = /* @__PURE__ */ memoize.memoizeGetters(Message, [
+  "sender",
+  "chat",
+  "forward",
+  "replies",
+  "viaBot",
+  "entities",
+  "action",
+  "media",
+  "markup",
+  "reactions",
+  "factCheck"
+]);
+const Message$2 = /* @__PURE__ */ inspectable.makeInspectable(Message$1, ["isScheduled"], ["link"]);
+exports.Message = Message$2;