@mtcute/core 0.17.1 → 0.18.0

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

@@ -0,0 +1,297 @@
+import Long from "long";
+import { getMarkedPeerId } from "../../../utils/peer-utils.js";
+import { Photo as Photo$2 } from "../media/photo.js";
+import { parsePeer } from "../peers/peer.js";
+import { StarGift as StarGift$2 } from "../premium/stars-gift.js";
+import { _callDiscardReasonFromTl } from "../calls/discard-reason.js";
+function _messageActionFromTl(act) {
+  switch (act._) {
+    case "messageActionChatCreate":
+      return {
+        type: "chat_created",
+        title: act.title,
+        users: act.users
+      };
+    case "messageActionChannelCreate":
+      return {
+        type: "channel_created",
+        title: act.title
+      };
+    case "messageActionChatMigrateTo":
+      return {
+        type: "chat_migrate_to",
+        id: act.channelId
+      };
+    case "messageActionChannelMigrateFrom":
+      return {
+        type: "channel_migrate_from",
+        id: act.chatId,
+        title: act.title
+      };
+    case "messageActionPinMessage":
+      return {
+        type: "message_pinned"
+      };
+    case "messageActionHistoryClear":
+      return {
+        type: "history_cleared"
+      };
+    case "messageActionGameScore":
+      return {
+        type: "game_score",
+        gameId: act.gameId,
+        score: act.score
+      };
+    case "messageActionContactSignUp":
+      return {
+        type: "contact_joined"
+      };
+    case "messageActionChatEditTitle":
+      return {
+        type: "title_changed",
+        title: act.title
+      };
+    case "messageActionChatEditPhoto":
+      return {
+        type: "photo_changed",
+        photo: new Photo$2(act.photo)
+      };
+    case "messageActionChatDeletePhoto":
+      return {
+        type: "photo_deleted"
+      };
+    case "messageActionChatAddUser":
+      return {
+        type: "users_added",
+        users: act.users
+      };
+    case "messageActionChatDeleteUser":
+      if (this.raw.fromId?._ === "peerUser" && act.userId === this.raw.fromId.userId) {
+        return {
+          type: "user_left"
+        };
+      }
+      return {
+        type: "user_removed",
+        user: act.userId
+      };
+    case "messageActionChatJoinedByLink":
+      return {
+        type: "user_joined_link",
+        inviter: act.inviterId
+      };
+    case "messageActionPaymentSentMe":
+      return {
+        type: "payment_received",
+        currency: act.currency,
+        amount: act.totalAmount,
+        payload: act.payload,
+        info: act.info,
+        shippingOptionId: act.shippingOptionId,
+        charge: act.charge,
+        subscriptionUntilDate: act.subscriptionUntilDate ? new Date(act.subscriptionUntilDate * 1e3) : void 0
+      };
+    case "messageActionPaymentSent":
+      return {
+        type: "payment_sent",
+        currency: act.currency,
+        amount: act.totalAmount,
+        subscriptionUntilDate: act.subscriptionUntilDate ? new Date(act.subscriptionUntilDate * 1e3) : void 0
+      };
+    case "messageActionPhoneCall":
+      return {
+        type: "call",
+        id: act.callId,
+        isVideo: Boolean(act.video),
+        reason: act.reason ? _callDiscardReasonFromTl(act.reason) : void 0,
+        duration: act.duration ?? 0
+      };
+    case "messageActionScreenshotTaken":
+      return {
+        type: "screenshot_taken"
+      };
+    case "messageActionBotAllowed":
+      return {
+        type: "bot_allowed",
+        domain: act.domain
+      };
+    case "messageActionGeoProximityReached":
+      if (act.fromId._ !== "peerUser" || act.toId._ !== "peerUser") {
+        return null;
+      }
+      return {
+        type: "geo_proximity",
+        targetId: act.toId.userId,
+        userId: act.fromId.userId,
+        distance: act.distance
+      };
+    case "messageActionGroupCall":
+      if (act.duration) {
+        return {
+          type: "group_call_ended",
+          call: act.call,
+          duration: act.duration
+        };
+      }
+      return {
+        type: "group_call_started",
+        call: act.call
+      };
+    case "messageActionGroupCallScheduled":
+      return {
+        type: "group_call_scheduled",
+        call: act.call,
+        date: new Date(act.scheduleDate * 1e3)
+      };
+    case "messageActionInviteToGroupCall":
+      return {
+        type: "group_call_invite",
+        call: act.call,
+        userIds: act.users
+      };
+    case "messageActionSetMessagesTTL":
+      return {
+        type: "ttl_changed",
+        period: act.period
+      };
+    case "messageActionTopicCreate":
+      return {
+        type: "topic_created",
+        title: act.title,
+        iconColor: act.iconColor,
+        iconCustomEmoji: act.iconEmojiId
+      };
+    case "messageActionTopicEdit":
+      return {
+        type: "topic_edited",
+        title: act.title,
+        iconCustomEmoji: act.iconEmojiId,
+        closed: act.closed,
+        hidden: act.hidden
+      };
+    case "messageActionCustomAction":
+      return {
+        type: "custom",
+        action: act.message
+      };
+    case "messageActionSetChatTheme":
+      return {
+        type: "theme_changed",
+        emoji: act.emoticon
+      };
+    case "messageActionChatJoinedByRequest":
+      return {
+        type: "user_joined_approved"
+      };
+    case "messageActionWebViewDataSent":
+      return {
+        type: "webview_sent",
+        text: act.text
+      };
+    case "messageActionWebViewDataSentMe":
+      return {
+        type: "webview_received",
+        text: act.text,
+        data: act.data
+      };
+    case "messageActionGiftPremium":
+      return {
+        type: "premium_gifted",
+        currency: act.currency,
+        amount: act.amount.toNumber(),
+        months: act.months,
+        crypto: act.cryptoAmount ? {
+          currency: act.cryptoCurrency,
+          amount: act.cryptoAmount.toNumber()
+        } : void 0,
+        message: act.message
+      };
+    case "messageActionSuggestProfilePhoto":
+      return {
+        type: "photo_suggested",
+        photo: new Photo$2(act.photo)
+      };
+    case "messageActionRequestedPeerSentMe":
+      return {
+        type: "peer_sent",
+        buttonId: act.buttonId,
+        peers: act.peers
+      };
+    case "messageActionRequestedPeer":
+      return {
+        type: "peer_chosen",
+        buttonId: act.buttonId,
+        peers: act.peers.map((it) => parsePeer(it, this._peers))
+      };
+    case "messageActionSetChatWallPaper":
+      return {
+        type: "wallpaper_changed",
+        same: act.same,
+        forBoth: act.forBoth,
+        wallpaper: act.wallpaper
+      };
+    case "messageActionGiftCode":
+      return {
+        type: "gift_code",
+        raw: act,
+        message: act.message
+      };
+    case "messageActionGiveawayLaunch":
+      return {
+        type: "giveaway_started"
+      };
+    case "messageActionGiveawayResults":
+      return {
+        type: "giveaway_ended",
+        winners: act.winnersCount,
+        undistributed: act.unclaimedCount
+      };
+    case "messageActionBoostApply":
+      return {
+        type: "boost_apply",
+        count: act.boosts
+      };
+    case "messageActionPaymentRefunded":
+      return {
+        type: "payment_refunded",
+        currency: act.currency,
+        peerId: getMarkedPeerId(act.peer),
+        amount: act.totalAmount,
+        payload: act.payload,
+        charge: act.charge
+      };
+    case "messageActionGiftStars":
+      return {
+        type: "stars_gifted",
+        isCrypto: Boolean(act.cryptoCurrency),
+        currency: act.cryptoCurrency ?? act.currency,
+        amount: act.cryptoAmount ?? act.amount,
+        stars: act.stars,
+        transactionId: act.transactionId
+      };
+    case "messageActionPrizeStars":
+      return {
+        type: "stars_prize",
+        claimed: !act.unclaimed,
+        stars: act.stars,
+        transactionId: act.transactionId,
+        boostPeer: parsePeer(act.boostPeer, this._peers),
+        giveawayMessageId: act.giveawayMsgId
+      };
+    case "messageActionStarGift":
+      return {
+        type: "stars_gift",
+        nameHidden: act.nameHidden,
+        saved: act.saved,
+        converted: act.converted,
+        convertStars: act.convertStars ?? Long.ZERO,
+        gift: new StarGift$2(act.gift),
+        message: act.message ?? null
+      };
+    default:
+      return null;
+  }
+}
+export {
+  _messageActionFromTl
+};

package/highlevel/types/messages/message-effect.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 errors = require("../../../types/errors.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+const memoize = require("../../utils/memoize.cjs");
+const documentUtils = require("../media/document-utils.cjs");
+class MessageEffect {
+  constructor(raw, documentsMap) {
+    this.raw = raw;
+    this.documentsMap = documentsMap;
+  }
+  /** Whether Telegram Premium is required to use this effect */
+  get isPremiumRequired() {
+    return this.raw.premiumRequired;
+  }
+  /** ID of this effect */
+  get id() {
+    return this.raw.id;
+  }
+  /** Emoji representint this reaction */
+  get emoji() {
+    return this.raw.emoticon;
+  }
+  /** Sticker representing a static icon for this effect (if any) */
+  get staticIcon() {
+    if (!this.raw.staticIconId) return null;
+    const document = this.documentsMap.get(this.raw.staticIconId);
+    if (!document) return null;
+    const parsed = documentUtils.parseSticker(document);
+    if (!parsed) {
+      throw new errors.MtTypeAssertionError("MessageEffect.staticIcon", "sticker", "null");
+    }
+    return parsed;
+  }
+  /** Animated icon representing the effect  */
+  get icon() {
+    const document = this.documentsMap.get(this.raw.effectStickerId);
+    if (!document) {
+      throw new errors.MtTypeAssertionError("MessageEffect.effect", "document", "null");
+    }
+    const parsed = documentUtils.parseSticker(document);
+    if (!parsed) {
+      throw new errors.MtTypeAssertionError("MessageEffect.effect", "sticker", "null");
+    }
+    return parsed;
+  }
+  /** The animation itself */
+  get animation() {
+    if (!this.raw.effectAnimationId) return null;
+    const document = this.documentsMap.get(this.raw.effectAnimationId);
+    if (!document) return null;
+    const parsed = documentUtils.parseSticker(document);
+    if (!parsed) {
+      throw new errors.MtTypeAssertionError("MessageEffect.effectAnimation", "sticker", "null");
+    }
+    return parsed;
+  }
+}
+const MessageEffect$1 = /* @__PURE__ */ memoize.memoizeGetters(MessageEffect, ["staticIcon", "icon", "animation"]);
+const MessageEffect$2 = /* @__PURE__ */ inspectable.makeInspectable(MessageEffect$1);
+exports.MessageEffect = MessageEffect$2;

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

@@ -0,0 +1,20 @@
+import { tl } from '@mtcute/tl';
+import { LongMap } from '../../../utils/long-utils.js';
+import { Sticker } from '../media/sticker.js';
+export declare class MessageEffect {
+    readonly raw: tl.RawAvailableEffect;
+    readonly documentsMap: LongMap<tl.RawDocument>;
+    constructor(raw: tl.RawAvailableEffect, documentsMap: LongMap<tl.RawDocument>);
+    /** Whether Telegram Premium is required to use this effect */
+    get isPremiumRequired(): boolean;
+    /** ID of this effect */
+    get id(): tl.Long;
+    /** Emoji representint this reaction */
+    get emoji(): string;
+    /** Sticker representing a static icon for this effect (if any) */
+    get staticIcon(): Sticker | null;
+    /** Animated icon representing the effect  */
+    get icon(): Sticker;
+    /** The animation itself */
+    get animation(): Sticker | null;
+}

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

@@ -0,0 +1,61 @@
+import { MtTypeAssertionError } from "../../../types/errors.js";
+import { makeInspectable } from "../../utils/inspectable.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { parseSticker } from "../media/document-utils.js";
+class MessageEffect {
+  constructor(raw, documentsMap) {
+    this.raw = raw;
+    this.documentsMap = documentsMap;
+  }
+  /** Whether Telegram Premium is required to use this effect */
+  get isPremiumRequired() {
+    return this.raw.premiumRequired;
+  }
+  /** ID of this effect */
+  get id() {
+    return this.raw.id;
+  }
+  /** Emoji representint this reaction */
+  get emoji() {
+    return this.raw.emoticon;
+  }
+  /** Sticker representing a static icon for this effect (if any) */
+  get staticIcon() {
+    if (!this.raw.staticIconId) return null;
+    const document = this.documentsMap.get(this.raw.staticIconId);
+    if (!document) return null;
+    const parsed = parseSticker(document);
+    if (!parsed) {
+      throw new MtTypeAssertionError("MessageEffect.staticIcon", "sticker", "null");
+    }
+    return parsed;
+  }
+  /** Animated icon representing the effect  */
+  get icon() {
+    const document = this.documentsMap.get(this.raw.effectStickerId);
+    if (!document) {
+      throw new MtTypeAssertionError("MessageEffect.effect", "document", "null");
+    }
+    const parsed = parseSticker(document);
+    if (!parsed) {
+      throw new MtTypeAssertionError("MessageEffect.effect", "sticker", "null");
+    }
+    return parsed;
+  }
+  /** The animation itself */
+  get animation() {
+    if (!this.raw.effectAnimationId) return null;
+    const document = this.documentsMap.get(this.raw.effectAnimationId);
+    if (!document) return null;
+    const parsed = parseSticker(document);
+    if (!parsed) {
+      throw new MtTypeAssertionError("MessageEffect.effectAnimation", "sticker", "null");
+    }
+    return parsed;
+  }
+}
+const MessageEffect$1 = /* @__PURE__ */ memoizeGetters(MessageEffect, ["staticIcon", "icon", "animation"]);
+const MessageEffect$2 = /* @__PURE__ */ makeInspectable(MessageEffect$1);
+export {
+  MessageEffect$2 as MessageEffect
+};

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

@@ -0,0 +1,104 @@
+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 memoize = require("../../utils/memoize.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+class MessageEntity {
+  constructor(raw, _text) {
+    this.raw = raw;
+    this._text = _text;
+  }
+  /**
+   * Offset in UTF-16 code units to the start of the entity.
+   *
+   * Since JS strings are UTF-16, you can use this as-is
+   */
+  get offset() {
+    return this.raw.offset;
+  }
+  /**
+   * Length of the entity in UTF-16 code units.
+   *
+   * Since JS strings are UTF-16, you can use this as-is
+   */
+  get length() {
+    return this.raw.length;
+  }
+  /**
+   * Kind of the entity (see {@link MessageEntityParams})
+   */
+  get kind() {
+    return this.params.kind;
+  }
+  /**
+   * Params of the entity
+   */
+  get params() {
+    switch (this.raw._) {
+      case "messageEntityMention":
+        return { kind: "mention" };
+      case "messageEntityHashtag":
+        return { kind: "hashtag" };
+      case "messageEntityCashtag":
+        return { kind: "cashtag" };
+      case "messageEntityBotCommand":
+        return { kind: "bot_command" };
+      case "messageEntityUrl":
+        return { kind: "url" };
+      case "messageEntityEmail":
+        return { kind: "email" };
+      case "messageEntityPhone":
+        return { kind: "phone_number" };
+      case "messageEntityBold":
+        return { kind: "bold" };
+      case "messageEntityItalic":
+        return { kind: "italic" };
+      case "messageEntityUnderline":
+        return { kind: "underline" };
+      case "messageEntityStrike":
+        return { kind: "strikethrough" };
+      case "messageEntitySpoiler":
+        return { kind: "spoiler" };
+      case "messageEntityCode":
+        return { kind: "code" };
+      case "messageEntityPre":
+        return { kind: "pre", language: this.raw.language };
+      case "messageEntityTextUrl":
+        return { kind: "text_link", url: this.raw.url };
+      case "messageEntityMentionName":
+        return { kind: "text_mention", userId: this.raw.userId };
+      case "messageEntityBlockquote":
+        return { kind: "blockquote", collapsible: this.raw.collapsed };
+      case "messageEntityCustomEmoji":
+        return { kind: "emoji", emojiId: this.raw.documentId };
+      case "messageEntityBankCard":
+        return { kind: "bank_card" };
+    }
+    return { kind: "unknown" };
+  }
+  /**
+   * Text contained in this entity.
+   *
+   * > **Note**: This does not take into account that entities may overlap,
+   * > and is only useful for simple cases.
+   */
+  get text() {
+    if (!this._text) return "";
+    return this._text.slice(this.raw.offset, this.raw.offset + this.raw.length);
+  }
+  /**
+   * Checks if this entity is of the given type, and adjusts the type accordingly.
+   * @param kind
+   * @returns
+   */
+  is(kind) {
+    return this.params.kind === kind;
+  }
+}
+const MessageEntity$1 = /* @__PURE__ */ memoize.memoizeGetters(MessageEntity, ["params"]);
+const MessageEntity$2 = /* @__PURE__ */ inspectable.makeInspectable(MessageEntity$1);
+exports.MessageEntity = MessageEntity$2;

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

@@ -0,0 +1,89 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Params of the entity. `.kind` can be:
+ *   - 'mention': `@username`.
+ *   - 'hashtag': `#hashtag`.
+ *   - 'cashtag': `$USD`.
+ *   - 'bot_command': `/start`.
+ *   - 'url': `https://example.com`
+ *   - 'email': `example@example.com`.
+ *   - 'phone_number': `+42000`.
+ *   - 'bold': **bold text**.
+ *   - 'italic': *italic text*.
+ *   - 'underline': <u>underlined</u> text.
+ *   - 'strikethrough': <s>strikethrough</s> text.
+ *   - 'code': `monospaced` string.
+ *   - 'pre': `monospaced` block. `.language` contains the language of the block (if available).
+ *   - 'text_link': for clickable text URLs.
+ *   - 'text_mention': for user mention by name. `.userId` contains the ID of the mentioned user.
+ *   - 'blockquote': A blockquote
+ *   - 'emoji': A custom emoji. `.emojiId` contains the emoji ID.
+ */
+export type MessageEntityParams = {
+    kind: 'mention' | 'hashtag' | 'cashtag' | 'bot_command' | 'url' | 'email' | 'phone_number' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'spoiler' | 'code' | 'bank_card' | 'unknown';
+} | {
+    kind: 'blockquote';
+    collapsible: boolean;
+} | {
+    kind: 'pre';
+    language?: string;
+} | {
+    kind: 'text_link';
+    url: string;
+} | {
+    kind: 'text_mention';
+    userId: number;
+} | {
+    kind: 'emoji';
+    emojiId: tl.Long;
+};
+/**
+ * Kind of the entity. For more information, see {@link MessageEntityParams}
+ */
+export type MessageEntityKind = MessageEntityParams['kind'];
+/**
+ * One special entity in a text message (like mention, hashtag, URL, etc.)
+ */
+export declare class MessageEntity {
+    readonly raw: tl.TypeMessageEntity;
+    readonly _text?: string | undefined;
+    constructor(raw: tl.TypeMessageEntity, _text?: string | undefined);
+    /**
+     * Offset in UTF-16 code units to the start of the entity.
+     *
+     * Since JS strings are UTF-16, you can use this as-is
+     */
+    get offset(): number;
+    /**
+     * Length of the entity in UTF-16 code units.
+     *
+     * Since JS strings are UTF-16, you can use this as-is
+     */
+    get length(): number;
+    /**
+     * Kind of the entity (see {@link MessageEntityParams})
+     */
+    get kind(): MessageEntityKind;
+    /**
+     * Params of the entity
+     */
+    get params(): MessageEntityParams;
+    /**
+     * Text contained in this entity.
+     *
+     * > **Note**: This does not take into account that entities may overlap,
+     * > and is only useful for simple cases.
+     */
+    get text(): string;
+    /**
+     * Checks if this entity is of the given type, and adjusts the type accordingly.
+     * @param kind
+     * @returns
+     */
+    is<const T extends MessageEntityKind>(kind: T): this is MessageEntity & {
+        params: Extract<MessageEntityParams, {
+            kind: T;
+        }>;
+        kind: T;
+    };
+}